libpetri 0.3.2

package/README.md

@@ -0,0 +1,121 @@
+# libpetri
+
+TypeScript implementation of a **Coloured Time Petri Net** (CTPN) engine with bitmap-based execution, formal verification via Z3, and DOT/Graphviz visualization.
+
+## Architecture
+
+```
+src/
+├── core/          # Net definition: places, transitions, arcs, timing, output specs
+├── runtime/       # Async bitmap-based executor, marking, compiled net
+├── event/         # Event store and net event types (discriminated union)
+├── export/        # DOT (Graphviz) diagram exporter
+└── verification/  # SMT-based property verification (Z3)
+```
+
+### Core (`src/core/`)
+
+Immutable net definitions with typed, colored tokens.
+
+| Type | Description |
+|------|-------------|
+| `Place<T>` | Typed token container (phantom type for compile-time safety) |
+| `EnvironmentPlace<T>` | External event injection point |
+| `Transition` | Arc specs, timing, priority, guards, action binding |
+| `PetriNet` | Immutable net definition; `bindActions()` separates structure from runtime behavior |
+| `Out` | Discriminated union for output specs: `and`, `xor`, `place`, `timeout`, `forward-input` |
+| `In` | Input arc specs with cardinality: `one`, `exactly`, `all`, `at-least` |
+| `Timing` | TPN firing intervals: `immediate`, `deadline`, `delayed`, `window`, `exact` |
+| `TransitionAction` | `(ctx: TransitionContext) => Promise<void>` — async action bound to a transition |
+
+### Runtime (`src/runtime/`)
+
+Async single-threaded executor using bitmap-based enablement tracking.
+
+| Type | Description |
+|------|-------------|
+| `BitmapNetExecutor` | Main executor — dirty-set tracking, priority scheduling, deadline enforcement |
+| `CompiledNet` | Precomputed bitmap masks and reverse indices for O(W) enablement checks |
+| `Marking` | Mutable FIFO token state per place |
+
+Key performance features:
+- `Uint32Array` bitmaps for place marking and transition dirty sets
+- Kernighan's bit-trick for dirty set iteration
+- Pre-allocated buffers to reduce GC pressure
+- Precomputed reverse index (place → affected transitions)
+
+### Event (`src/event/`)
+
+Observable execution events as a discriminated union (`NetEvent`).
+
+Event types: `execution-started`, `execution-completed`, `transition-enabled`, `transition-started`, `transition-completed`, `transition-failed`, `transition-timed-out`, `action-timed-out`, `token-added`, `token-removed`, `log-message`, `marking-snapshot`.
+
+`InMemoryEventStore` captures events; `noopEventStore()` is a zero-cost singleton for production.
+
+### Export (`src/export/`)
+
+`dotExport(net, config)` generates DOT (Graphviz) diagram syntax with proper Petri net visual conventions, including arc types (inhibitor, read, reset), timing annotations, and priority labels.
+
+### Verification (`src/verification/`)
+
+SMT-based formal verification using Z3. Encodes the Petri net as an integer linear program and checks reachability properties.
+
+Supported properties:
+- **Deadlock freedom** — no reachable state where all transitions are disabled
+- **Mutual exclusion** — two places never both hold tokens simultaneously
+- **Place bounds** — token count in a place never exceeds a limit
+- **Unreachability** — a marking is never reachable
+
+Also computes **P-invariants** (Farkas variant) and supports IC3/PDR-style incremental verification.
+
+## Quick Start
+
+```typescript
+import { place, PetriNet, Transition, one, outPlace, tokenOf, BitmapNetExecutor } from 'libpetri';
+
+// Define places
+const input = place<string>('input');
+const output = place<string>('output');
+
+// Define transition
+const process = Transition.builder('process')
+  .inputs(one(input))
+  .outputs(outPlace(output))
+  .action(async (ctx) => {
+    const value = ctx.input(input);
+    ctx.output(output, value.toUpperCase());
+  })
+  .build();
+
+// Build net
+const net = PetriNet.builder('Example').transition(process).build();
+
+// Execute
+const executor = new BitmapNetExecutor(
+  net,
+  new Map([[input, [tokenOf('hello')]]]),
+);
+const marking = await executor.run();
+console.log(marking.peekTokens(output)); // [Token { value: 'HELLO' }]
+```
+
+## Verification Example
+
+```typescript
+import { SmtVerifier, deadlockFree } from 'libpetri/verification';
+
+const result = await SmtVerifier.forNet(net)
+  .initialMarking(m => m.tokens(input, 1))
+  .property(deadlockFree())
+  .verify();
+
+console.log(result.verdict); // { type: 'proven', method: 'structural' }
+```
+
+## Build & Test
+
+```bash
+npm run build    # Build with tsup
+npm run check    # Type-check with tsc --noEmit
+npm test         # Run tests with vitest
+```

package/dist/chunk-FN773SSE.js

@@ -0,0 +1,87 @@
+// src/core/timing.ts
+var MAX_DURATION_MS = 365 * 100 * 24 * 60 * 60 * 1e3;
+function immediate() {
+  return { type: "immediate" };
+}
+function deadline(byMs) {
+  if (byMs <= 0) {
+    throw new Error(`Deadline must be positive: ${byMs}`);
+  }
+  return { type: "deadline", byMs };
+}
+function delayed(afterMs) {
+  if (afterMs < 0) {
+    throw new Error(`Delay must be non-negative: ${afterMs}`);
+  }
+  return { type: "delayed", afterMs };
+}
+function window(earliestMs, latestMs) {
+  if (earliestMs < 0) {
+    throw new Error(`Earliest must be non-negative: ${earliestMs}`);
+  }
+  if (latestMs < earliestMs) {
+    throw new Error(`Latest (${latestMs}) must be >= earliest (${earliestMs})`);
+  }
+  return { type: "window", earliestMs, latestMs };
+}
+function exact(atMs) {
+  if (atMs < 0) {
+    throw new Error(`Exact time must be non-negative: ${atMs}`);
+  }
+  return { type: "exact", atMs };
+}
+function earliest(timing) {
+  switch (timing.type) {
+    case "immediate":
+      return 0;
+    case "deadline":
+      return 0;
+    case "delayed":
+      return timing.afterMs;
+    case "window":
+      return timing.earliestMs;
+    case "exact":
+      return timing.atMs;
+  }
+}
+function latest(timing) {
+  switch (timing.type) {
+    case "immediate":
+      return MAX_DURATION_MS;
+    case "deadline":
+      return timing.byMs;
+    case "delayed":
+      return MAX_DURATION_MS;
+    case "window":
+      return timing.latestMs;
+    case "exact":
+      return timing.atMs;
+  }
+}
+function hasDeadline(timing) {
+  switch (timing.type) {
+    case "immediate":
+      return false;
+    case "deadline":
+      return true;
+    case "delayed":
+      return false;
+    case "window":
+      return true;
+    case "exact":
+      return true;
+  }
+}
+
+export {
+  MAX_DURATION_MS,
+  immediate,
+  deadline,
+  delayed,
+  window,
+  exact,
+  earliest,
+  latest,
+  hasDeadline
+};
+//# sourceMappingURL=chunk-FN773SSE.js.map

package/dist/chunk-FN773SSE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/timing.ts"],"sourcesContent":["/**\n * Firing timing specification for transitions.\n *\n * Based on classical Time Petri Net (TPN) semantics:\n * - Transition CANNOT fire before earliest time (lower bound)\n * - Transition MUST fire by deadline OR become disabled (upper bound)\n *\n * All durations are in milliseconds.\n */\nexport type Timing = TimingImmediate | TimingDeadline | TimingDelayed | TimingWindow | TimingExact;\n\nexport interface TimingImmediate {\n  readonly type: 'immediate';\n}\n\nexport interface TimingDeadline {\n  readonly type: 'deadline';\n  /** Deadline in milliseconds. Must be positive. */\n  readonly byMs: number;\n}\n\nexport interface TimingDelayed {\n  readonly type: 'delayed';\n  /** Minimum delay in milliseconds. Must be non-negative. */\n  readonly afterMs: number;\n}\n\nexport interface TimingWindow {\n  readonly type: 'window';\n  /** Earliest firing time in milliseconds. Must be non-negative. */\n  readonly earliestMs: number;\n  /** Latest firing time in milliseconds. Must be >= earliestMs. */\n  readonly latestMs: number;\n}\n\nexport interface TimingExact {\n  readonly type: 'exact';\n  /** Exact firing time in milliseconds. Must be non-negative. */\n  readonly atMs: number;\n}\n\n/** ~100 years in milliseconds, used for \"unconstrained\" intervals. */\nexport const MAX_DURATION_MS = 365 * 100 * 24 * 60 * 60 * 1000;\n\n// ==================== Factory Functions ====================\n\n/** Immediate firing: can fire as soon as enabled, no deadline. [0, inf) */\nexport function immediate(): TimingImmediate {\n  return { type: 'immediate' };\n}\n\n/** Immediate with deadline: can fire immediately, must fire by deadline. [0, by] */\nexport function deadline(byMs: number): TimingDeadline {\n  if (byMs <= 0) {\n    throw new Error(`Deadline must be positive: ${byMs}`);\n  }\n  return { type: 'deadline', byMs };\n}\n\n/** Delayed firing: must wait, then can fire anytime. [after, inf) */\nexport function delayed(afterMs: number): TimingDelayed {\n  if (afterMs < 0) {\n    throw new Error(`Delay must be non-negative: ${afterMs}`);\n  }\n  return { type: 'delayed', afterMs };\n}\n\n/** Time window: can fire within [earliest, latest]. */\nexport function window(earliestMs: number, latestMs: number): TimingWindow {\n  if (earliestMs < 0) {\n    throw new Error(`Earliest must be non-negative: ${earliestMs}`);\n  }\n  if (latestMs < earliestMs) {\n    throw new Error(`Latest (${latestMs}) must be >= earliest (${earliestMs})`);\n  }\n  return { type: 'window', earliestMs, latestMs };\n}\n\n/** Exact timing: fires at precisely the specified time. [at, at] */\nexport function exact(atMs: number): TimingExact {\n  if (atMs < 0) {\n    throw new Error(`Exact time must be non-negative: ${atMs}`);\n  }\n  return { type: 'exact', atMs };\n}\n\n// ==================== Query Functions ====================\n\n/** Returns the earliest time (ms) the transition can fire after enabling. */\nexport function earliest(timing: Timing): number {\n  switch (timing.type) {\n    case 'immediate': return 0;\n    case 'deadline': return 0;\n    case 'delayed': return timing.afterMs;\n    case 'window': return timing.earliestMs;\n    case 'exact': return timing.atMs;\n  }\n}\n\n/** Returns the latest time (ms) by which the transition must fire. */\nexport function latest(timing: Timing): number {\n  switch (timing.type) {\n    case 'immediate': return MAX_DURATION_MS;\n    case 'deadline': return timing.byMs;\n    case 'delayed': return MAX_DURATION_MS;\n    case 'window': return timing.latestMs;\n    case 'exact': return timing.atMs;\n  }\n}\n\n/** Returns true if this timing has a finite deadline. */\nexport function hasDeadline(timing: Timing): boolean {\n  switch (timing.type) {\n    case 'immediate': return false;\n    case 'deadline': return true;\n    case 'delayed': return false;\n    case 'window': return true;\n    case 'exact': return true;\n  }\n}\n"],"mappings":";AA0CO,IAAM,kBAAkB,MAAM,MAAM,KAAK,KAAK,KAAK;AAKnD,SAAS,YAA6B;AAC3C,SAAO,EAAE,MAAM,YAAY;AAC7B;AAGO,SAAS,SAAS,MAA8B;AACrD,MAAI,QAAQ,GAAG;AACb,UAAM,IAAI,MAAM,8BAA8B,IAAI,EAAE;AAAA,EACtD;AACA,SAAO,EAAE,MAAM,YAAY,KAAK;AAClC;AAGO,SAAS,QAAQ,SAAgC;AACtD,MAAI,UAAU,GAAG;AACf,UAAM,IAAI,MAAM,+BAA+B,OAAO,EAAE;AAAA,EAC1D;AACA,SAAO,EAAE,MAAM,WAAW,QAAQ;AACpC;AAGO,SAAS,OAAO,YAAoB,UAAgC;AACzE,MAAI,aAAa,GAAG;AAClB,UAAM,IAAI,MAAM,kCAAkC,UAAU,EAAE;AAAA,EAChE;AACA,MAAI,WAAW,YAAY;AACzB,UAAM,IAAI,MAAM,WAAW,QAAQ,0BAA0B,UAAU,GAAG;AAAA,EAC5E;AACA,SAAO,EAAE,MAAM,UAAU,YAAY,SAAS;AAChD;AAGO,SAAS,MAAM,MAA2B;AAC/C,MAAI,OAAO,GAAG;AACZ,UAAM,IAAI,MAAM,oCAAoC,IAAI,EAAE;AAAA,EAC5D;AACA,SAAO,EAAE,MAAM,SAAS,KAAK;AAC/B;AAKO,SAAS,SAAS,QAAwB;AAC/C,UAAQ,OAAO,MAAM;AAAA,IACnB,KAAK;AAAa,aAAO;AAAA,IACzB,KAAK;AAAY,aAAO;AAAA,IACxB,KAAK;AAAW,aAAO,OAAO;AAAA,IAC9B,KAAK;AAAU,aAAO,OAAO;AAAA,IAC7B,KAAK;AAAS,aAAO,OAAO;AAAA,EAC9B;AACF;AAGO,SAAS,OAAO,QAAwB;AAC7C,UAAQ,OAAO,MAAM;AAAA,IACnB,KAAK;AAAa,aAAO;AAAA,IACzB,KAAK;AAAY,aAAO,OAAO;AAAA,IAC/B,KAAK;AAAW,aAAO;AAAA,IACvB,KAAK;AAAU,aAAO,OAAO;AAAA,IAC7B,KAAK;AAAS,aAAO,OAAO;AAAA,EAC9B;AACF;AAGO,SAAS,YAAY,QAAyB;AACnD,UAAQ,OAAO,MAAM;AAAA,IACnB,KAAK;AAAa,aAAO;AAAA,IACzB,KAAK;AAAY,aAAO;AAAA,IACxB,KAAK;AAAW,aAAO;AAAA,IACvB,KAAK;AAAU,aAAO;AAAA,IACtB,KAAK;AAAS,aAAO;AAAA,EACvB;AACF;","names":[]}

package/dist/chunk-VQ4XMJTD.js

@@ -0,0 +1,107 @@
+// src/core/out.ts
+function and(...children) {
+  if (children.length === 0) {
+    throw new Error("AND requires at least 1 child");
+  }
+  return { type: "and", children };
+}
+function andPlaces(...places) {
+  return and(...places.map(outPlace));
+}
+function xor(...children) {
+  if (children.length < 2) {
+    throw new Error("XOR requires at least 2 children");
+  }
+  return { type: "xor", children };
+}
+function xorPlaces(...places) {
+  return xor(...places.map(outPlace));
+}
+function outPlace(p) {
+  return { type: "place", place: p };
+}
+function timeout(afterMs, child) {
+  if (afterMs <= 0) {
+    throw new Error(`Timeout must be positive: ${afterMs}`);
+  }
+  return { type: "timeout", afterMs, child };
+}
+function timeoutPlace(afterMs, p) {
+  return timeout(afterMs, outPlace(p));
+}
+function forwardInput(from, to) {
+  return { type: "forward-input", from, to };
+}
+function allPlaces(out) {
+  const result = /* @__PURE__ */ new Set();
+  collectPlaces(out, result);
+  return result;
+}
+function collectPlaces(out, result) {
+  switch (out.type) {
+    case "place":
+      result.add(out.place);
+      break;
+    case "forward-input":
+      result.add(out.to);
+      break;
+    case "and":
+    case "xor":
+      for (const child of out.children) {
+        collectPlaces(child, result);
+      }
+      break;
+    case "timeout":
+      collectPlaces(out.child, result);
+      break;
+  }
+}
+function enumerateBranches(out) {
+  switch (out.type) {
+    case "place":
+      return [/* @__PURE__ */ new Set([out.place])];
+    case "forward-input":
+      return [/* @__PURE__ */ new Set([out.to])];
+    case "and": {
+      let result = [/* @__PURE__ */ new Set()];
+      for (const child of out.children) {
+        result = crossProduct(result, enumerateBranches(child));
+      }
+      return result;
+    }
+    case "xor": {
+      const result = [];
+      for (const child of out.children) {
+        result.push(...enumerateBranches(child));
+      }
+      return result;
+    }
+    case "timeout":
+      return enumerateBranches(out.child);
+  }
+}
+function crossProduct(a, b) {
+  const result = [];
+  for (const setA of a) {
+    for (const setB of b) {
+      const merged = new Set(setA);
+      for (const p of setB) merged.add(p);
+      result.push(merged);
+    }
+  }
+  return result;
+}
+
+export {
+  and,
+  andPlaces,
+  xor,
+  xorPlaces,
+  outPlace,
+  timeout,
+  timeoutPlace,
+  forwardInput,
+  allPlaces,
+  enumerateBranches
+};
+//# sourceMappingURL=chunk-VQ4XMJTD.js.map

package/dist/chunk-VQ4XMJTD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/out.ts"],"sourcesContent":["import type { Place } from './place.js';\n\n/**\n * Output specification with explicit split semantics.\n * Supports composite structures (XOR of ANDs, AND of XORs, etc.)\n *\n * - And: ALL children must receive tokens\n * - Xor: EXACTLY ONE child receives token\n * - Place: Leaf node representing a single output place\n * - Timeout: Timeout branch that activates if action exceeds duration\n * - ForwardInput: Forward consumed input to output on timeout\n */\nexport type Out = OutAnd | OutXor | OutPlace | OutTimeout | OutForwardInput;\n\nexport interface OutAnd {\n  readonly type: 'and';\n  readonly children: readonly Out[];\n}\n\nexport interface OutXor {\n  readonly type: 'xor';\n  readonly children: readonly Out[];\n}\n\nexport interface OutPlace {\n  readonly type: 'place';\n  readonly place: Place<any>;\n}\n\nexport interface OutTimeout {\n  readonly type: 'timeout';\n  /** Timeout duration in milliseconds. */\n  readonly afterMs: number;\n  readonly child: Out;\n}\n\nexport interface OutForwardInput {\n  readonly type: 'forward-input';\n  readonly from: Place<any>;\n  readonly to: Place<any>;\n}\n\n// ==================== Factory Functions ====================\n\n/**\n * AND-split: all children must receive tokens.\n *\n * @example\n * ```ts\n * // AND of XOR branches: one of (A,B) AND one of (C,D)\n * and(xorPlaces(placeA, placeB), xorPlaces(placeC, placeD))\n *\n * // AND with a fixed place + XOR branch\n * and(outPlace(always), xorPlaces(left, right))\n * ```\n */\nexport function and(...children: Out[]): OutAnd {\n  if (children.length === 0) {\n    throw new Error('AND requires at least 1 child');\n  }\n  return { type: 'and', children };\n}\n\n/** AND-split from places: all places must receive tokens. */\nexport function andPlaces(...places: Place<any>[]): OutAnd {\n  return and(...places.map(outPlace));\n}\n\n/** XOR-split: exactly one child receives token. */\nexport function xor(...children: Out[]): OutXor {\n  if (children.length < 2) {\n    throw new Error('XOR requires at least 2 children');\n  }\n  return { type: 'xor', children };\n}\n\n/** XOR-split from places: exactly one place receives token. */\nexport function xorPlaces(...places: Place<any>[]): OutXor {\n  return xor(...places.map(outPlace));\n}\n\n/** Leaf output spec for a single place. */\nexport function outPlace(p: Place<any>): OutPlace {\n  return { type: 'place', place: p };\n}\n\n/** Timeout output: activates if action exceeds duration. */\nexport function timeout(afterMs: number, child: Out): OutTimeout {\n  if (afterMs <= 0) {\n    throw new Error(`Timeout must be positive: ${afterMs}`);\n  }\n  return { type: 'timeout', afterMs, child };\n}\n\n/** Timeout output pointing to a single place. */\nexport function timeoutPlace(afterMs: number, p: Place<any>): OutTimeout {\n  return timeout(afterMs, outPlace(p));\n}\n\n/** Forward consumed input value to output place on timeout. */\nexport function forwardInput(from: Place<any>, to: Place<any>): OutForwardInput {\n  return { type: 'forward-input', from, to };\n}\n\n// ==================== Helper Functions ====================\n\n/** Collects all leaf places from this output spec (flattened). */\nexport function allPlaces(out: Out): Set<Place<any>> {\n  const result = new Set<Place<any>>();\n  collectPlaces(out, result);\n  return result;\n}\n\nfunction collectPlaces(out: Out, result: Set<Place<any>>): void {\n  switch (out.type) {\n    case 'place':\n      result.add(out.place);\n      break;\n    case 'forward-input':\n      result.add(out.to);\n      break;\n    case 'and':\n    case 'xor':\n      for (const child of out.children) {\n        collectPlaces(child, result);\n      }\n      break;\n    case 'timeout':\n      collectPlaces(out.child, result);\n      break;\n  }\n}\n\n/**\n * Enumerates all possible output branches for structural analysis.\n *\n * - AND = single branch containing all child places (Cartesian product)\n * - XOR = one branch per alternative child\n * - Nested = Cartesian product for AND, union for XOR\n */\nexport function enumerateBranches(out: Out): ReadonlyArray<ReadonlySet<Place<any>>> {\n  switch (out.type) {\n    case 'place':\n      return [new Set([out.place])];\n\n    case 'forward-input':\n      return [new Set<Place<any>>([out.to])];\n\n    case 'and': {\n      let result: Set<Place<any>>[] = [new Set()];\n      for (const child of out.children) {\n        result = crossProduct(result, enumerateBranches(child) as Set<Place<any>>[]);\n      }\n      return result;\n    }\n\n    case 'xor': {\n      const result: Set<Place<any>>[] = [];\n      for (const child of out.children) {\n        result.push(...(enumerateBranches(child) as Set<Place<any>>[]));\n      }\n      return result;\n    }\n\n    case 'timeout':\n      return enumerateBranches(out.child);\n  }\n}\n\nfunction crossProduct(\n  a: Set<Place<any>>[],\n  b: ReadonlyArray<ReadonlySet<Place<any>>>,\n): Set<Place<any>>[] {\n  const result: Set<Place<any>>[] = [];\n  for (const setA of a) {\n    for (const setB of b) {\n      const merged = new Set<Place<any>>(setA);\n      for (const p of setB) merged.add(p);\n      result.push(merged);\n    }\n  }\n  return result;\n}\n"],"mappings":";AAwDO,SAAS,OAAO,UAAyB;AAC9C,MAAI,SAAS,WAAW,GAAG;AACzB,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACjD;AACA,SAAO,EAAE,MAAM,OAAO,SAAS;AACjC;AAGO,SAAS,aAAa,QAA8B;AACzD,SAAO,IAAI,GAAG,OAAO,IAAI,QAAQ,CAAC;AACpC;AAGO,SAAS,OAAO,UAAyB;AAC9C,MAAI,SAAS,SAAS,GAAG;AACvB,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACpD;AACA,SAAO,EAAE,MAAM,OAAO,SAAS;AACjC;AAGO,SAAS,aAAa,QAA8B;AACzD,SAAO,IAAI,GAAG,OAAO,IAAI,QAAQ,CAAC;AACpC;AAGO,SAAS,SAAS,GAAyB;AAChD,SAAO,EAAE,MAAM,SAAS,OAAO,EAAE;AACnC;AAGO,SAAS,QAAQ,SAAiB,OAAwB;AAC/D,MAAI,WAAW,GAAG;AAChB,UAAM,IAAI,MAAM,6BAA6B,OAAO,EAAE;AAAA,EACxD;AACA,SAAO,EAAE,MAAM,WAAW,SAAS,MAAM;AAC3C;AAGO,SAAS,aAAa,SAAiB,GAA2B;AACvE,SAAO,QAAQ,SAAS,SAAS,CAAC,CAAC;AACrC;AAGO,SAAS,aAAa,MAAkB,IAAiC;AAC9E,SAAO,EAAE,MAAM,iBAAiB,MAAM,GAAG;AAC3C;AAKO,SAAS,UAAU,KAA2B;AACnD,QAAM,SAAS,oBAAI,IAAgB;AACnC,gBAAc,KAAK,MAAM;AACzB,SAAO;AACT;AAEA,SAAS,cAAc,KAAU,QAA+B;AAC9D,UAAQ,IAAI,MAAM;AAAA,IAChB,KAAK;AACH,aAAO,IAAI,IAAI,KAAK;AACpB;AAAA,IACF,KAAK;AACH,aAAO,IAAI,IAAI,EAAE;AACjB;AAAA,IACF,KAAK;AAAA,IACL,KAAK;AACH,iBAAW,SAAS,IAAI,UAAU;AAChC,sBAAc,OAAO,MAAM;AAAA,MAC7B;AACA;AAAA,IACF,KAAK;AACH,oBAAc,IAAI,OAAO,MAAM;AAC/B;AAAA,EACJ;AACF;AASO,SAAS,kBAAkB,KAAkD;AAClF,UAAQ,IAAI,MAAM;AAAA,IAChB,KAAK;AACH,aAAO,CAAC,oBAAI,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC;AAAA,IAE9B,KAAK;AACH,aAAO,CAAC,oBAAI,IAAgB,CAAC,IAAI,EAAE,CAAC,CAAC;AAAA,IAEvC,KAAK,OAAO;AACV,UAAI,SAA4B,CAAC,oBAAI,IAAI,CAAC;AAC1C,iBAAW,SAAS,IAAI,UAAU;AAChC,iBAAS,aAAa,QAAQ,kBAAkB,KAAK,CAAsB;AAAA,MAC7E;AACA,aAAO;AAAA,IACT;AAAA,IAEA,KAAK,OAAO;AACV,YAAM,SAA4B,CAAC;AACnC,iBAAW,SAAS,IAAI,UAAU;AAChC,eAAO,KAAK,GAAI,kBAAkB,KAAK,CAAuB;AAAA,MAChE;AACA,aAAO;AAAA,IACT;AAAA,IAEA,KAAK;AACH,aAAO,kBAAkB,IAAI,KAAK;AAAA,EACtC;AACF;AAEA,SAAS,aACP,GACA,GACmB;AACnB,QAAM,SAA4B,CAAC;AACnC,aAAW,QAAQ,GAAG;AACpB,eAAW,QAAQ,GAAG;AACpB,YAAM,SAAS,IAAI,IAAgB,IAAI;AACvC,iBAAW,KAAK,KAAM,QAAO,IAAI,CAAC;AAClC,aAAO,KAAK,MAAM;AAAA,IACpB;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/export/index.d.ts

@@ -0,0 +1,153 @@
+import { a as PetriNet } from '../petri-net-C3Jy5HCt.js';
+
+/**
+ * Format-agnostic typed graph model.
+ *
+ * Consumed by both the DOT renderer and the animation layer. Nodes carry a
+ * `semanticId` that maps back to `Place.name` / `Transition.name` — the stable
+ * bridge for animation targeting.
+ *
+ * ID convention: places get `p_` prefix, transitions get `t_` prefix.
+ *
+ * @module export/graph
+ */
+type RankDir = 'TB' | 'BT' | 'LR' | 'RL';
+type NodeShape = 'circle' | 'doublecircle' | 'box' | 'diamond' | 'ellipse' | 'record';
+type EdgeLineStyle = 'solid' | 'dashed' | 'bold';
+type ArrowHead = 'normal' | 'odot' | 'none' | 'diamond' | 'dot';
+interface GraphNode {
+    readonly id: string;
+    readonly label: string;
+    readonly shape: NodeShape;
+    readonly fill: string;
+    readonly stroke: string;
+    readonly penwidth: number;
+    /** Maps back to Place.name or Transition.name for animation targeting. */
+    readonly semanticId: string;
+    readonly style?: string;
+    readonly height?: number;
+    readonly width?: number;
+    readonly attrs?: Readonly<Record<string, string>>;
+}
+interface GraphEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly label?: string;
+    readonly color: string;
+    readonly style: EdgeLineStyle;
+    readonly arrowhead: ArrowHead;
+    readonly penwidth?: number;
+    /** The arc type that produced this edge (for semantic queries). */
+    readonly arcType: 'input' | 'output' | 'inhibitor' | 'read' | 'reset';
+    readonly attrs?: Readonly<Record<string, string>>;
+}
+interface Subgraph {
+    readonly id: string;
+    readonly label?: string;
+    readonly nodes: readonly GraphNode[];
+    readonly attrs?: Readonly<Record<string, string>>;
+}
+interface Graph {
+    readonly id: string;
+    readonly rankdir: RankDir;
+    readonly nodes: readonly GraphNode[];
+    readonly edges: readonly GraphEdge[];
+    readonly subgraphs: readonly Subgraph[];
+    readonly graphAttrs: Readonly<Record<string, string>>;
+    readonly nodeDefaults: Readonly<Record<string, string>>;
+    readonly edgeDefaults: Readonly<Record<string, string>>;
+}
+
+/**
+ * Style loader for Petri net visualization.
+ *
+ * Reads the shared style definition from `spec/petri-net-styles.json` and
+ * exposes typed accessors for node and edge visual properties.
+ *
+ * @module export/styles
+ */
+
+interface NodeVisual {
+    readonly shape: NodeShape;
+    readonly fill: string;
+    readonly stroke: string;
+    readonly penwidth: number;
+    readonly style?: string;
+    readonly height?: number;
+    readonly width?: number;
+}
+interface EdgeVisual {
+    readonly color: string;
+    readonly style: EdgeLineStyle;
+    readonly arrowhead: ArrowHead;
+    readonly penwidth?: number;
+}
+interface FontStyle {
+    readonly family: string;
+    readonly nodeSize: number;
+    readonly edgeSize: number;
+}
+interface GraphStyle {
+    readonly nodesep: number;
+    readonly ranksep: number;
+}
+declare const FONT: FontStyle;
+declare const GRAPH: GraphStyle;
+type NodeCategory = 'place' | 'start' | 'end' | 'environment' | 'transition';
+type EdgeCategory = 'input' | 'output' | 'inhibitor' | 'read' | 'reset';
+/** Returns the visual style for the given node category. */
+declare function nodeStyle(category: NodeCategory): NodeVisual;
+/** Returns the visual style for the given edge/arc type. */
+declare function edgeStyle(arcType: EdgeCategory): EdgeVisual;
+
+/**
+ * Maps a PetriNet definition to a format-agnostic Graph.
+ *
+ * This is where all the Petri net semantics live. The mapper understands
+ * places, transitions, arcs, timing, and priority. It produces a Graph
+ * that can be rendered to DOT (or any other format) without Petri net knowledge.
+ *
+ * @module export/petri-net-mapper
+ */
+
+interface DotConfig {
+    readonly direction: RankDir;
+    readonly showTypes: boolean;
+    readonly showIntervals: boolean;
+    readonly showPriority: boolean;
+    readonly environmentPlaces?: ReadonlySet<string>;
+}
+declare const DEFAULT_DOT_CONFIG: DotConfig;
+/** Sanitizes a name for use as a graph node ID. */
+declare function sanitize(name: string): string;
+/** Maps a PetriNet to a format-agnostic Graph. */
+declare function mapToGraph(net: PetriNet, config?: DotConfig): Graph;
+
+/**
+ * Renders a Graph to DOT (Graphviz) string.
+ *
+ * Pure function with zero Petri net knowledge. Operates solely on the
+ * format-agnostic Graph model.
+ *
+ * @module export/dot-renderer
+ */
+
+/** Renders a Graph to a DOT string suitable for Graphviz. */
+declare function renderDot(graph: Graph): string;
+
+/**
+ * Convenience function for exporting a PetriNet to DOT format.
+ *
+ * @module export/dot-exporter
+ */
+
+/**
+ * Exports a PetriNet to DOT (Graphviz) format.
+ *
+ * @param net the Petri net to export
+ * @param config optional export configuration
+ * @returns DOT string suitable for rendering with Graphviz
+ */
+declare function dotExport(net: PetriNet, config?: DotConfig): string;
+
+export { type ArrowHead, DEFAULT_DOT_CONFIG, type DotConfig, type EdgeCategory, type EdgeLineStyle, type EdgeVisual, FONT, GRAPH, type Graph, type GraphEdge, type GraphNode, type NodeCategory, type NodeShape, type NodeVisual, type RankDir, type Subgraph, dotExport, edgeStyle, mapToGraph, nodeStyle, renderDot, sanitize };