libpetri 1.8.5 → 2.1.0

package/dist/render-QK57X4TP.js

@@ -0,0 +1,73 @@
+import {
+  elkLayout,
+  foldOrphans,
+  parseLibpetriDot,
+  replicateShared,
+  writeBack
+} from "./chunk-RNWTYK5B.js";
+
+// src/viewer/render.ts
+import { instance as vizInstance } from "@viz-js/viz";
+var vizPromise = null;
+function getViz() {
+  if (!vizPromise) vizPromise = vizInstance();
+  return vizPromise;
+}
+async function renderDotToSvg(dotSource) {
+  const viz = await getViz();
+  return viz.renderSVGElement(dotSource, { engine: "dot" });
+}
+function fnv1a(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+var PINNED_DOT_CACHE_CAP = 16;
+var pinnedDotCache = /* @__PURE__ */ new Map();
+function getCachedPinnedDot(key) {
+  const hit = pinnedDotCache.get(key);
+  if (hit !== void 0) {
+    pinnedDotCache.delete(key);
+    pinnedDotCache.set(key, hit);
+  }
+  return hit;
+}
+function setCachedPinnedDot(key, value) {
+  pinnedDotCache.set(key, value);
+  while (pinnedDotCache.size > PINNED_DOT_CACHE_CAP) {
+    const oldest = pinnedDotCache.keys().next().value;
+    if (oldest === void 0) break;
+    pinnedDotCache.delete(oldest);
+  }
+}
+function _clearElkLayoutCache() {
+  pinnedDotCache.clear();
+}
+async function renderDotToSvgWithElkLayout(dotSource) {
+  const key = fnv1a(dotSource);
+  let pinnedDot = getCachedPinnedDot(key);
+  if (pinnedDot === void 0) {
+    const graph = replicateShared(
+      foldOrphans(parseLibpetriDot(dotSource), 0.7),
+      { max: Infinity }
+    );
+    const layout = await elkLayout(graph);
+    pinnedDot = writeBack(graph, layout);
+    setCachedPinnedDot(key, pinnedDot);
+  }
+  const viz = await getViz();
+  return viz.renderSVGElement(pinnedDot, {
+    engine: "nop",
+    yInvert: true
+  });
+}
+export {
+  _clearElkLayoutCache,
+  getViz,
+  renderDotToSvg,
+  renderDotToSvgWithElkLayout
+};
+//# sourceMappingURL=render-QK57X4TP.js.map

package/dist/render-QK57X4TP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/viewer/render.ts"],"sourcesContent":["/**\n * DOT → SVG rendering for the canonical libpetri viewer.\n *\n * Two render paths:\n *\n *   renderDotToSvg(dot)                — plain Graphviz `dot` engine.\n *   renderDotToSvgWithElkLayout(dot)   — C0 pipeline: parse → fold →\n *                                        replicate → ELK → writeBack →\n *                                        Graphviz `neato` with `nop=1`\n *                                        (pin mode). Cached by DOT hash.\n *\n * The ELK path is the default for {@link mount}; the plain-Graphviz path\n * remains as a fallback for callers that want stock layout (or for\n * environments where elkjs isn't installed).\n *\n * @module viewer/render\n */\n\nimport { instance as vizInstance } from '@viz-js/viz';\nimport {\n  foldOrphans,\n  parseLibpetriDot,\n  replicateShared,\n} from './layout/preprocess.js';\nimport { elkLayout, writeBack } from './layout/elk-place.js';\n\ntype Viz = Awaited<ReturnType<typeof vizInstance>>;\n\nlet vizPromise: Promise<Viz> | null = null;\n\n/** Memoize the viz.js instance so the wasm loads only once per page. */\nexport function getViz(): Promise<Viz> {\n  if (!vizPromise) vizPromise = vizInstance();\n  return vizPromise;\n}\n\n/**\n * Render a DOT source string to an SVGSVGElement using the plain `dot`\n * engine. Deterministic across runs; libpetri exporters emit byte-stable\n * DOT per spec EXP-014 so the same DOT yields the same SVG.\n */\nexport async function renderDotToSvg(dotSource: string): Promise<SVGSVGElement> {\n  const viz = await getViz();\n  return viz.renderSVGElement(dotSource, { engine: 'dot' });\n}\n\n// ---- C0 / ELK pin-mode cache ---------------------------------------------\n\n/** FNV-1a 32-bit hash. Fast enough that a SHA isn't worth the import. */\nfunction fnv1a(input: string): string {\n  let h = 0x811c9dc5;\n  for (let i = 0; i < input.length; i++) {\n    h ^= input.charCodeAt(i);\n    h = Math.imul(h, 0x01000193);\n  }\n  return (h >>> 0).toString(16);\n}\n\nconst PINNED_DOT_CACHE_CAP = 16;\nconst pinnedDotCache = new Map<string, string>();\n\nfunction getCachedPinnedDot(key: string): string | undefined {\n  const hit = pinnedDotCache.get(key);\n  if (hit !== undefined) {\n    // LRU touch: re-insert moves to most-recent position in Map ordering.\n    pinnedDotCache.delete(key);\n    pinnedDotCache.set(key, hit);\n  }\n  return hit;\n}\n\nfunction setCachedPinnedDot(key: string, value: string): void {\n  pinnedDotCache.set(key, value);\n  while (pinnedDotCache.size > PINNED_DOT_CACHE_CAP) {\n    const oldest = pinnedDotCache.keys().next().value;\n    if (oldest === undefined) break;\n    pinnedDotCache.delete(oldest);\n  }\n}\n\n/** Test helper — clears the pinned-DOT LRU cache between mounts. */\nexport function _clearElkLayoutCache(): void {\n  pinnedDotCache.clear();\n}\n\n/**\n * Run the C0 layout pipeline against a libpetri DOT source and return the\n * rendered SVG. The expensive steps (preprocess + ELK layout + DOT rewrite)\n * are cached keyed on the input DOT's hash, so re-mounts on the same net\n * structure skip everything except the Graphviz pin-mode draw.\n *\n * Per-tick marking updates do NOT call this — they toggle classes on the\n * already-mounted SVG. ELK only runs when the net structure changes.\n */\nexport async function renderDotToSvgWithElkLayout(\n  dotSource: string,\n): Promise<SVGSVGElement> {\n  const key = fnv1a(dotSource);\n  let pinnedDot = getCachedPinnedDot(key);\n  if (pinnedDot === undefined) {\n    const graph = replicateShared(\n      foldOrphans(parseLibpetriDot(dotSource), 0.7),\n      { max: Infinity },\n    );\n    const layout = await elkLayout(graph);\n    pinnedDot = writeBack(graph, layout);\n    setCachedPinnedDot(key, pinnedDot);\n  }\n  const viz = await getViz();\n  return viz.renderSVGElement(pinnedDot, {\n    engine: 'nop',\n    yInvert: true,\n  });\n}\n"],"mappings":";;;;;;;;;AAkBA,SAAS,YAAY,mBAAmB;AAUxC,IAAI,aAAkC;AAG/B,SAAS,SAAuB;AACrC,MAAI,CAAC,WAAY,cAAa,YAAY;AAC1C,SAAO;AACT;AAOA,eAAsB,eAAe,WAA2C;AAC9E,QAAM,MAAM,MAAM,OAAO;AACzB,SAAO,IAAI,iBAAiB,WAAW,EAAE,QAAQ,MAAM,CAAC;AAC1D;AAKA,SAAS,MAAM,OAAuB;AACpC,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,SAAK,MAAM,WAAW,CAAC;AACvB,QAAI,KAAK,KAAK,GAAG,QAAU;AAAA,EAC7B;AACA,UAAQ,MAAM,GAAG,SAAS,EAAE;AAC9B;AAEA,IAAM,uBAAuB;AAC7B,IAAM,iBAAiB,oBAAI,IAAoB;AAE/C,SAAS,mBAAmB,KAAiC;AAC3D,QAAM,MAAM,eAAe,IAAI,GAAG;AAClC,MAAI,QAAQ,QAAW;AAErB,mBAAe,OAAO,GAAG;AACzB,mBAAe,IAAI,KAAK,GAAG;AAAA,EAC7B;AACA,SAAO;AACT;AAEA,SAAS,mBAAmB,KAAa,OAAqB;AAC5D,iBAAe,IAAI,KAAK,KAAK;AAC7B,SAAO,eAAe,OAAO,sBAAsB;AACjD,UAAM,SAAS,eAAe,KAAK,EAAE,KAAK,EAAE;AAC5C,QAAI,WAAW,OAAW;AAC1B,mBAAe,OAAO,MAAM;AAAA,EAC9B;AACF;AAGO,SAAS,uBAA6B;AAC3C,iBAAe,MAAM;AACvB;AAWA,eAAsB,4BACpB,WACwB;AACxB,QAAM,MAAM,MAAM,SAAS;AAC3B,MAAI,YAAY,mBAAmB,GAAG;AACtC,MAAI,cAAc,QAAW;AAC3B,UAAM,QAAQ;AAAA,MACZ,YAAY,iBAAiB,SAAS,GAAG,GAAG;AAAA,MAC5C,EAAE,KAAK,SAAS;AAAA,IAClB;AACA,UAAM,SAAS,MAAM,UAAU,KAAK;AACpC,gBAAY,UAAU,OAAO,MAAM;AACnC,uBAAmB,KAAK,SAAS;AAAA,EACnC;AACA,QAAM,MAAM,MAAM,OAAO;AACzB,SAAO,IAAI,iBAAiB,WAAW;AAAA,IACrC,QAAQ;AAAA,IACR,SAAS;AAAA,EACX,CAAC;AACH;","names":[]}

package/dist/verification/index.d.ts

@@ -1,47 +1,7 @@
-import { P as Place, b as Transition, a as PetriNet, E as EnvironmentPlace } from '../petri-net-D-GN9g_D.js';
+import { b as Transition, a as Place, P as PetriNet, E as EnvironmentPlace, aG as MarkingState, aH as PInvariant, aI as MarkingStateBuilder, aJ as SmtProperty, aK as SmtVerificationResult } from '../petri-net-BDrj4XZE.js';
+export { aL as DeadlockFree, aM as MutualExclusion, aN as PlaceBound, aO as Proven, aP as SmtStatistics, aQ as TokenSupplier, aR as Unknown, aS as Unreachable, aT as Verdict, X as VerificationHarness, Y as VerificationResult, aU as Violated, aV as deadlockFree, aW as isProven, aX as isViolated, aY as mutualExclusion, aZ as pInvariant, a_ as pInvariantToString, a$ as placeBound, b0 as propertyDescription, b1 as unreachable } from '../petri-net-BDrj4XZE.js';
 import { Expr, init, Bool, FuncDecl } from 'z3-solver';
 
-/**
- * Immutable snapshot of a Petri net marking for state space analysis.
- *
- * Maps places (by name) to integer token counts. Only stores places with count > 0.
- * Used for invariant computation and structural verification, not runtime execution.
- */
-declare class MarkingState {
-    private readonly tokenCounts;
-    private readonly placesByName;
-    /** @internal Use {@link MarkingState.builder} or {@link MarkingState.empty} to create instances. */
-    constructor(key: symbol, tokenCounts: Map<string, number>, placesByName: Map<string, Place<any>>);
-    /** Returns the token count for a place (0 if absent). */
-    tokens(place: Place<any>): number;
-    /** Checks if a place has at least one token. */
-    hasTokens(place: Place<any>): boolean;
-    /** Checks if any of the given places has tokens. */
-    hasTokensInAny(places: Iterable<Place<any>>): boolean;
-    /** Returns all places with tokens > 0. */
-    placesWithTokens(): Place<any>[];
-    /** Returns the total number of tokens. */
-    totalTokens(): number;
-    /** Checks if no tokens exist anywhere. */
-    isEmpty(): boolean;
-    toString(): string;
-    static empty(): MarkingState;
-    static builder(): MarkingStateBuilder;
-}
-declare class MarkingStateBuilder {
-    private readonly tokenCounts;
-    private readonly placesByName;
-    /** Sets the token count for a place. */
-    tokens(place: Place<any>, count: number): this;
-    /** Adds tokens to a place. */
-    addTokens(place: Place<any>, count: number): this;
-    /** Removes tokens from a place. Throws if insufficient. */
-    removeTokens(place: Place<any>, count: number): this;
-    /** Copies all token counts from another marking state. */
-    copyFrom(other: MarkingState): this;
-    build(): MarkingState;
-}
-
 /**
  * A flattened transition with pre/post vectors for SMT encoding.
  *
@@ -166,27 +126,6 @@ declare function bounded$1(maxTokens: number): EnvironmentAnalysisMode$1;
  */
 declare function flatten(net: PetriNet, environmentPlaces?: Set<EnvironmentPlace<any>>, environmentMode?: EnvironmentAnalysisMode$1): FlatNet;
 
-/**
- * A P-invariant (place invariant) of a Petri net.
- *
- * A P-invariant is a vector y such that y^T * C = 0, where C is the
- * incidence matrix. This means that for any reachable marking M:
- * sum(y_i * M_i) = constant, where constant = sum(y_i * M0_i).
- *
- * P-invariants provide structural bounds on places and are used as
- * strengthening lemmas for the IC3/PDR engine.
- */
-interface PInvariant {
-    /** Weight vector (one entry per place index). */
-    readonly weights: readonly number[];
-    /** The invariant value sum(y_i * M0_i). */
-    readonly constant: number;
-    /** Set of place indices where weight != 0. */
-    readonly support: ReadonlySet<number>;
-}
-declare function pInvariant(weights: number[], constant: number, support: Set<number>): PInvariant;
-declare function pInvariantToString(inv: PInvariant): string;
-
 /**
  * @module p-invariant-computer
  *
@@ -285,86 +224,6 @@ declare function findMinimalSiphons(flatNet: FlatNet): ReadonlySet<number>[];
  */
 declare function findMaximalTrapIn(flatNet: FlatNet, places: ReadonlySet<number>): ReadonlySet<number>;
 
-/**
- * Safety properties that can be verified via IC3/PDR.
- *
- * Each property is encoded as an error condition: if a reachable state
- * violates the property, Spacer finds a counterexample. If no violation
- * is reachable, the property is proven.
- */
-type SmtProperty = DeadlockFree | MutualExclusion | PlaceBound | Unreachable;
-/** Deadlock-freedom: no reachable marking has all transitions disabled. */
-interface DeadlockFree {
-    readonly type: 'deadlock-free';
-}
-/** Mutual exclusion: two places never have tokens simultaneously. */
-interface MutualExclusion {
-    readonly type: 'mutual-exclusion';
-    readonly p1: Place<any>;
-    readonly p2: Place<any>;
-}
-/** Place bound: a place never exceeds a given token count. */
-interface PlaceBound {
-    readonly type: 'place-bound';
-    readonly place: Place<any>;
-    readonly bound: number;
-}
-/** Unreachability: the given places never all have tokens simultaneously. */
-interface Unreachable {
-    readonly type: 'unreachable';
-    readonly places: ReadonlySet<Place<any>>;
-}
-declare function deadlockFree(): DeadlockFree;
-declare function mutualExclusion(p1: Place<any>, p2: Place<any>): MutualExclusion;
-declare function placeBound(place: Place<any>, bound: number): PlaceBound;
-declare function unreachable(places: ReadonlySet<Place<any>>): Unreachable;
-/** Human-readable description of a property. */
-declare function propertyDescription(prop: SmtProperty): string;
-
-/**
- * Verification verdict.
- */
-type Verdict = Proven | Violated | Unknown;
-/** Property proven safe. No reachable state violates it. */
-interface Proven {
-    readonly type: 'proven';
-    readonly method: string;
-    readonly inductiveInvariant: string | null;
-}
-/** Property violated. A counterexample trace is available. */
-interface Violated {
-    readonly type: 'violated';
-}
-/** Could not determine. */
-interface Unknown {
-    readonly type: 'unknown';
-    readonly reason: string;
-}
-/**
- * Solver statistics.
- */
-interface SmtStatistics {
-    readonly places: number;
-    readonly transitions: number;
-    readonly invariantsFound: number;
-    readonly structuralResult: string;
-}
-/**
- * Result of SMT-based verification.
- */
-interface SmtVerificationResult {
-    readonly verdict: Verdict;
-    readonly report: string;
-    readonly invariants: readonly PInvariant[];
-    readonly discoveredInvariants: readonly string[];
-    readonly counterexampleTrace: readonly MarkingState[];
-    readonly counterexampleTransitions: readonly string[];
-    readonly elapsedMs: number;
-    readonly statistics: SmtStatistics;
-}
-declare function isProven(result: SmtVerificationResult): boolean;
-declare function isViolated(result: SmtVerificationResult): boolean;
-
 /**
  * IC3/PDR-based safety verifier for Petri nets using Z3's Spacer engine.
  *
@@ -702,4 +561,4 @@ declare class TimePetriNetAnalyzerBuilder {
     build(): TimePetriNetAnalyzer;
 }
 
-export { type EnvironmentAnalysisMode as AnalysisEnvironmentMode, type BranchEdge, DBM, type DeadlockFree, type DecodedTrace, type EncodingResult, type EnvironmentAnalysisMode$1 as EnvironmentAnalysisMode, type FlatNet, type FlatTransition, IncidenceMatrix, type LivenessResult, MarkingState, MarkingStateBuilder, type MutualExclusion, type PInvariant, type PlaceBound, type Proven, type QueryProven, type QueryResult, type QueryUnknown, type QueryViolated, type SmtProperty, type SmtStatistics, type SmtVerificationResult, SmtVerifier, type SpacerContext, StateClass, StateClassGraph, type StructuralCheckResult, TimePetriNetAnalyzer, TimePetriNetAnalyzerBuilder, type Unknown, type Unreachable, type Verdict, type Violated, type XorBranchAnalysis, type XorBranchInfo, alwaysAvailable as analysisAlwaysAvailable, bounded as analysisBounded, ignore as analysisIgnore, bounded$1 as bounded, computePInvariants, computeSCCs, createSpacerRunner, deadlockFree, decode, encode, findMaximalTrapIn, findMinimalSiphons, findTerminalSCCs, flatNetIndexOf, flatNetPlaceCount, flatNetTransitionCount, flatTransition, flatten, isCoveredByInvariants, isProven, isViolated, mutualExclusion, pInvariant, pInvariantToString, placeBound, propertyDescription, structuralCheck, unbounded, unreachable };
+export { type EnvironmentAnalysisMode as AnalysisEnvironmentMode, type BranchEdge, DBM, type DecodedTrace, type EncodingResult, type EnvironmentAnalysisMode$1 as EnvironmentAnalysisMode, type FlatNet, type FlatTransition, IncidenceMatrix, type LivenessResult, MarkingState, MarkingStateBuilder, PInvariant, type QueryProven, type QueryResult, type QueryUnknown, type QueryViolated, SmtProperty, SmtVerificationResult, SmtVerifier, type SpacerContext, StateClass, StateClassGraph, type StructuralCheckResult, TimePetriNetAnalyzer, TimePetriNetAnalyzerBuilder, type XorBranchAnalysis, type XorBranchInfo, alwaysAvailable as analysisAlwaysAvailable, bounded as analysisBounded, ignore as analysisIgnore, bounded$1 as bounded, computePInvariants, computeSCCs, createSpacerRunner, decode, encode, findMaximalTrapIn, findMinimalSiphons, findTerminalSCCs, flatNetIndexOf, flatNetPlaceCount, flatNetTransitionCount, flatTransition, flatten, isCoveredByInvariants, structuralCheck, unbounded };