libpetri 2.13.0 → 3.0.1

package/dist/pan-zoom-Cp51IkDl.d.ts

@@ -0,0 +1,33 @@
+import panzoom from 'panzoom';
+
+/**
+ * Pan/zoom wrapper for the canonical libpetri viewer.
+ *
+ * Delegates to the `panzoom` library (no hand-rolled wheel handlers — we
+ * intentionally drop the IIFE/javadoc version's bespoke math in favour of
+ * a single battle-tested implementation). Defaults match the old debug-ui
+ * and dev-preview values so the canonical viewer feels identical to what
+ * users had before.
+ *
+ * @module viewer/pan-zoom
+ */
+
+type PanzoomInstance = ReturnType<typeof panzoom>;
+type PanzoomOptions = Parameters<typeof panzoom>[1];
+/**
+ * Default panzoom configuration shared across all viewer surfaces.
+ *
+ * - `maxZoom: 1000` — effectively unlimited; lets users dive into ~150-node
+ *   diagrams without hitting an artificial ceiling.
+ * - `minZoom: 0.02` — allows fitting very large nets in a small viewport.
+ * - `smoothScroll: false` — sharper interactive feel.
+ * - `zoomDoubleClickSpeed: 1` — single-click double-zoom toggle.
+ */
+declare const DEFAULT_PANZOOM_OPTS: {
+    readonly smoothScroll: false;
+    readonly zoomDoubleClickSpeed: 1;
+    readonly maxZoom: 1000;
+    readonly minZoom: 0.02;
+};
+
+export { DEFAULT_PANZOOM_OPTS as D, type PanzoomInstance as P, type PanzoomOptions as a };

package/dist/{petri-net-C3LSY-vm.d.ts → petri-net-WSScMyDL.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. */
@@ -988,6 +982,25 @@ interface SmtVerificationResult {
     readonly discoveredInvariants: readonly string[];
     readonly counterexampleTrace: readonly MarkingState[];
     readonly counterexampleTransitions: readonly string[];
+    /**
+     * Outcome of the abstract counterexample replay, as a TRI-STATE. `null` means
+     * "the replay did not apply"; the two booleans both mean it ran.
+     *
+     * - `true` — an abstract firing chain from M₀ to a property-violating state
+     *   was re-executed TS-side; `counterexampleTrace` is that chain in FIRING
+     *   (replay) order and the verdict is `violated`.
+     * - `false` — the replay ran without confirming the trace. Either it could not
+     *   settle the question (nothing decoded from the Z3 derivation, M₀ absent
+     *   from the decoded set, or a node/segment budget hit), in which case the
+     *   `violated` verdict rests on Spacer's SAT answer alone; or the search
+     *   completed and found NO chain, in which case the verdict was downgraded to
+     *   `unknown`. The report distinguishes the two ("UNCONFIRMED" vs "FAILED").
+     * - `null` — replay did not apply: non-violated verdict, replay disabled via
+     *   `counterexampleReplay(false)`, the coloured ν-encoding / Route B (whose
+     *   state shapes are outside the flat replayer's scope), or a structural
+     *   proof.
+     */
+    readonly counterexampleConfirmed: boolean | null;
     readonly elapsedMs: number;
     readonly statistics: SmtStatistics;
 }
@@ -1746,7 +1759,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
@@ -1782,4 +1796,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 SmtStatistics 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, produce as aA, readArc as aB, requiredCount as aC, resetArc as aD, timeout as aE, timeoutPlace as aF, tokenAt as aG, tokenOf as aH, transform as aI, transformAsync as aJ, transformFrom as aK, unitToken as aL, window as aM, withTimeout as aN, xor as aO, xorPlaces as aP, MarkingState as aQ, type PInvariant as aR, MarkingStateBuilder as aS, type SmtProperty as aT, type SmtVerificationResult as aU, type BranchPlaceBound as aV, type DeadlockFree as aW, type JoinedOrDeadLettered as aX, type MutualExclusion as aY, type PlaceBound as aZ, type Proven 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, isPassthrough as am, isUnit as an, keyForPlace as ao, latest as ap, matchCorrelates as aq, matchKey as ar, matchSpec as as, matchesGuard as at, nameId as au, one as av, outPlace as aw, outputArc as ax, passthrough as ay, place as az, Transition as b, type TokenSupplier as b0, type Unknown as b1, type Unreachable as b2, type Verdict as b3, type Violated as b4, branchPlaceBound as b5, deadlockFree as b6, isProven as b7, isViolated as b8, joinedOrDeadLettered as b9, mutualExclusion as ba, pInvariant as bb, pInvariantToString as bc, placeBound as bd, propertyDescription as be, unreachable as bf, 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, type SmtProperty as aQ, MarkingStateBuilder 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/preprocess-FN3F75JR.js

@@ -0,0 +1,193 @@
+// src/viewer/layout/preprocess.ts
+function classifyKind(id) {
+  if (id.startsWith("p_")) return "place";
+  if (id.startsWith("t_")) return "transition";
+  return "junction";
+}
+function parseAttrs(body) {
+  const attrs = {};
+  for (const m of body.matchAll(/(\w+)=("(?:[^"]|\\.)*"|\S+?)(?=[\s,]|$)/g)) {
+    const [, key, raw] = m;
+    const v = raw.startsWith('"') && raw.endsWith('"') ? raw.slice(1, -1) : raw;
+    attrs[key] = v;
+  }
+  return attrs;
+}
+function parseLibpetriDot(dot) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const m of dot.matchAll(/^\s*([pjt]_[A-Za-z0-9_]+)\s*\[(.*)\];\s*$/gm)) {
+    const [, id, body] = m;
+    nodes.set(id, { id, kind: classifyKind(id), attrs: parseAttrs(body) });
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  const nodeToCluster = /* @__PURE__ */ new Map();
+  for (const cm of dot.matchAll(/subgraph (cluster_\w+)\s*\{([^]*?)^\s*\}/gm)) {
+    const [, clusterId, body] = cm;
+    const memberIds = [...body.matchAll(/^\s*([pjt]_[A-Za-z0-9_]+)\s*\[/gm)].map((m) => m[1]);
+    clusters.set(clusterId, {
+      id: clusterId,
+      shortName: clusterId.replace(/^cluster_/, ""),
+      nodes: memberIds
+    });
+    for (const n of memberIds) nodeToCluster.set(n, clusterId);
+  }
+  const stripped = dot.replace(/subgraph cluster_\w+\s*\{[^]*?^\s*\}/gm, "");
+  for (const m of stripped.matchAll(/^\s*([pjt]_[A-Za-z0-9_]+)\s*\[/gm)) {
+    const id = m[1];
+    if (!nodes.has(id)) {
+      nodes.set(id, { id, kind: classifyKind(id), attrs: {} });
+    }
+  }
+  const orphans = [...nodes.keys()].filter((n) => !nodeToCluster.has(n));
+  const edges = [];
+  for (const m of dot.matchAll(/([pjt]_[A-Za-z0-9_]+)\s*->\s*([pjt]_[A-Za-z0-9_]+)\s*(\[[^\]]*\])?/g)) {
+    const [, src, dst, rawAttrs] = m;
+    const attrs = rawAttrs ?? "";
+    if (attrs.includes("lhead=") || attrs.includes("ltail=")) continue;
+    let arc = "normal";
+    if (attrs.includes('label="reset"') || attrs.includes("#fd7e14")) arc = "reset";
+    else if (attrs.includes('arrowhead="odot"') || attrs.includes("#dc3545")) arc = "inhibitor";
+    else if (attrs.includes('label="read"')) arc = "read";
+    const stripped2 = attrs.startsWith("[") && attrs.endsWith("]") ? attrs.slice(1, -1) : "";
+    edges.push({ src, dst, arc, rawAttrs: stripped2 });
+  }
+  return { nodes, clusters, nodeToCluster, orphans, edges };
+}
+function foldOrphans(graph, threshold = 0.7) {
+  if (threshold <= 0) return graph;
+  const nodeToCluster = new Map(graph.nodeToCluster);
+  const clusterMembers = /* @__PURE__ */ new Map();
+  for (const [id, c] of graph.clusters) clusterMembers.set(id, [...c.nodes]);
+  const tally = /* @__PURE__ */ new Map();
+  const bump = (orphan, other) => {
+    const oc = nodeToCluster.get(other);
+    if (!oc) return;
+    let t = tally.get(orphan);
+    if (!t) {
+      t = /* @__PURE__ */ new Map();
+      tally.set(orphan, t);
+    }
+    t.set(oc, (t.get(oc) ?? 0) + 1);
+  };
+  for (const e of graph.edges) {
+    const sIsOrphan = !nodeToCluster.has(e.src);
+    const dIsOrphan = !nodeToCluster.has(e.dst);
+    if (sIsOrphan && !dIsOrphan) bump(e.src, e.dst);
+    if (dIsOrphan && !sIsOrphan) bump(e.dst, e.src);
+  }
+  for (const id of graph.orphans) {
+    const t = tally.get(id);
+    if (!t) continue;
+    let total = 0;
+    let bestCluster = null;
+    let bestCount = 0;
+    for (const [c, n] of t) {
+      total += n;
+      if (n > bestCount) {
+        bestCount = n;
+        bestCluster = c;
+      }
+    }
+    if (bestCluster && total > 0 && bestCount / total >= threshold) {
+      clusterMembers.get(bestCluster).push(id);
+      nodeToCluster.set(id, bestCluster);
+    }
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  for (const [id, c] of graph.clusters) {
+    clusters.set(id, { ...c, nodes: clusterMembers.get(id) });
+  }
+  const orphans = [...graph.nodes.keys()].filter((n) => !nodeToCluster.has(n));
+  return { ...graph, clusters, nodeToCluster, orphans };
+}
+function replicateShared(graph, opts = {}) {
+  const max = opts.max ?? Infinity;
+  const replicateTransitions = opts.replicateTransitions ?? false;
+  const nodes = new Map(graph.nodes);
+  const nodeToCluster = new Map(graph.nodeToCluster);
+  const clusterMembers = /* @__PURE__ */ new Map();
+  for (const [id, c] of graph.clusters) clusterMembers.set(id, [...c.nodes]);
+  const edges = graph.edges.map((e) => ({ ...e }));
+  const foreignByNode = /* @__PURE__ */ new Map();
+  const noteForeign = (nodeId, otherId) => {
+    if (!nodeId.startsWith("p_") && !(replicateTransitions && nodeId.startsWith("t_"))) return;
+    const home = nodeToCluster.get(nodeId);
+    const otherCluster = nodeToCluster.get(otherId);
+    if (!otherCluster) return;
+    if (otherCluster === home) return;
+    let s = foreignByNode.get(nodeId);
+    if (!s) {
+      s = /* @__PURE__ */ new Set();
+      foreignByNode.set(nodeId, s);
+    }
+    s.add(otherCluster);
+  };
+  for (const e of edges) {
+    noteForeign(e.src, e.dst);
+    noteForeign(e.dst, e.src);
+  }
+  const replicaMap = /* @__PURE__ */ new Map();
+  let replicatedPlaces = 0;
+  let totalCopies = 0;
+  for (const [placeId, foreigns] of foreignByNode) {
+    if (foreigns.size === 0) continue;
+    if (foreigns.size > max) continue;
+    const perCluster = /* @__PURE__ */ new Map();
+    const orig = nodes.get(placeId);
+    if (!orig) continue;
+    for (const clusterId of foreigns) {
+      const shortName = clusterId.replace(/^cluster_/, "");
+      const repId = `${placeId}__rep__${shortName}`;
+      perCluster.set(clusterId, repId);
+      clusterMembers.get(clusterId).push(repId);
+      nodeToCluster.set(repId, clusterId);
+      nodes.set(repId, {
+        id: repId,
+        kind: orig.kind,
+        attrs: { ...orig.attrs },
+        replica: true,
+        replicaOf: placeId
+      });
+      totalCopies++;
+    }
+    replicaMap.set(placeId, perCluster);
+    replicatedPlaces++;
+    nodes.set(placeId, { ...orig, replica: true, replicaOf: placeId });
+  }
+  for (const e of edges) {
+    const sMap = replicaMap.get(e.src);
+    const dMap = replicaMap.get(e.dst);
+    if (sMap) {
+      const dCl = nodeToCluster.get(e.dst);
+      if (dCl && sMap.has(dCl)) e.src = sMap.get(dCl);
+    }
+    if (dMap) {
+      const sCl = nodeToCluster.get(e.src);
+      if (sCl && dMap.has(sCl)) e.dst = dMap.get(sCl);
+    }
+  }
+  for (const [origId] of replicaMap) {
+    if (nodeToCluster.has(origId)) continue;
+    const stillHasEdge = edges.some((e) => e.src === origId || e.dst === origId);
+    if (!stillHasEdge) nodes.delete(origId);
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  for (const [id, c] of graph.clusters) {
+    clusters.set(id, { ...c, nodes: clusterMembers.get(id) });
+  }
+  const orphans = [...nodes.keys()].filter((n) => !nodeToCluster.has(n));
+  return {
+    nodes,
+    clusters,
+    nodeToCluster,
+    orphans,
+    edges,
+    replicateStats: { replicatedPlaces, totalCopies }
+  };
+}
+export {
+  foldOrphans,
+  parseLibpetriDot,
+  replicateShared
+};
+//# sourceMappingURL=preprocess-FN3F75JR.js.map

package/dist/preprocess-FN3F75JR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/viewer/layout/preprocess.ts"],"sourcesContent":["/**\n * Graph pre-processing for the C0-replicate-default layout pipeline.\n *\n * Three pure-ish transforms operate on a {@link GraphModel} parsed from a\n * libpetri-exported DOT string:\n *\n *   parseLibpetriDot(dot)           → GraphModel\n *   foldOrphans(graph, threshold)   → GraphModel    (REASSIGN_ORPHANS)\n *   replicateShared(graph, opts)    → GraphModel    (REPLICATE_SHARED)\n *\n * The pipeline turns a flat cluster soup into a cluster-internal one by\n * (a) folding orphan nodes whose edges concentrate in one cluster into that\n * cluster, and (b) cloning shared places into every foreign cluster they\n * touch so cross-cluster spaghetti disappears. The resulting GraphModel is\n * what ELK lays out (Stage 2) and Graphviz then renders in pin-mode.\n *\n * Algorithm lineage: ported from\n * `/home/db/otto-repos/nucleus_marvin/.scratch/javadoc-layout-exp/CHECKPOINTS/run16_GOOD_v3_skip-junctions.mjs`\n * lines 14–220. The arc-type detection, replica naming\n * (`${placeId}__rep__${clusterShortName}`), and the `__replica` /\n * `replicaOf` markers are load-bearing — downstream stages key off them.\n *\n * @module viewer/layout/preprocess\n */\n\nexport type ArcType = 'normal' | 'reset' | 'inhibitor' | 'read';\nexport type NodeKind = 'place' | 'transition' | 'junction';\n\nexport interface ParsedNode {\n  readonly id: string;\n  readonly kind: NodeKind;\n  readonly attrs: Record<string, string>;\n  /** True iff this node was emitted by replicateShared. */\n  readonly replica?: boolean;\n  /** For a replica, the id of the original logical place. */\n  readonly replicaOf?: string;\n}\n\nexport interface ParsedEdge {\n  readonly src: string;\n  readonly dst: string;\n  readonly arc: ArcType;\n  /**\n   * Raw attribute body from the libpetri DOT (between the `[…]` brackets,\n   * brackets stripped). Carries style/penwidth/label that we want to\n   * round-trip verbatim so the rendered output matches `DotExporter`'s\n   * native look.\n   */\n  readonly rawAttrs: string;\n}\n\nexport interface ParsedCluster {\n  readonly id: string;          // \"cluster_productSearch\"\n  readonly shortName: string;   // \"productSearch\"\n  readonly nodes: readonly string[];\n}\n\nexport interface GraphModel {\n  readonly nodes: ReadonlyMap<string, ParsedNode>;\n  readonly clusters: ReadonlyMap<string, ParsedCluster>;\n  readonly nodeToCluster: ReadonlyMap<string, string>;\n  /** Node ids not in any cluster (rendered at the orchestrator root). */\n  readonly orphans: readonly string[];\n  readonly edges: readonly ParsedEdge[];\n}\n\nfunction classifyKind(id: string): NodeKind {\n  if (id.startsWith('p_')) return 'place';\n  if (id.startsWith('t_')) return 'transition';\n  return 'junction';\n}\n\n/**\n * Recover key=value attributes from inside a DOT `[...]` block.\n *\n * Mirrors v3 line 29. The regex is intentionally permissive about quoted\n * values containing escaped quotes; it does not validate DOT syntax.\n */\nfunction parseAttrs(body: string): Record<string, string> {\n  const attrs: Record<string, string> = {};\n  for (const m of body.matchAll(/(\\w+)=(\"(?:[^\"]|\\\\.)*\"|\\S+?)(?=[\\s,]|$)/g)) {\n    const [, key, raw] = m as unknown as [string, string, string];\n    const v = raw.startsWith('\"') && raw.endsWith('\"') ? raw.slice(1, -1) : raw;\n    attrs[key] = v;\n  }\n  return attrs;\n}\n\n/**\n * Parse a libpetri-exported DOT string into a {@link GraphModel}.\n *\n * Tolerates the current exporter shape (see\n * `java/src/main/java/org/libpetri/export/StyleConstants.java`):\n *  - inhibitor arcs use `arrowhead=\"odot\"` + color `#dc3545`\n *  - reset arcs use `label=\"reset\"` + color `#fd7e14`\n *  - read arcs use `label=\"read\"` + color `#6c757d`\n *\n * Mirrors v3 lines 24–103.\n */\nexport function parseLibpetriDot(dot: string): GraphModel {\n  const nodes = new Map<string, ParsedNode>();\n  // Greedy `.*` (no /s flag) consumes the full attrs body up to the line's\n  // trailing `];`. The v3 reference used `[^\\]]*` which silently dropped\n  // transitions whose label contained `[…]` text (e.g., `\"[0, ∞]ms\"`); we\n  // can't tolerate that here because the typed model wants every cluster\n  // member to have a Node entry.\n  for (const m of dot.matchAll(/^\\s*([pjt]_[A-Za-z0-9_]+)\\s*\\[(.*)\\];\\s*$/gm)) {\n    const [, id, body] = m as unknown as [string, string, string];\n    nodes.set(id, { id, kind: classifyKind(id), attrs: parseAttrs(body) });\n  }\n\n  const clusters = new Map<string, ParsedCluster>();\n  const nodeToCluster = new Map<string, string>();\n  for (const cm of dot.matchAll(/subgraph (cluster_\\w+)\\s*\\{([^]*?)^\\s*\\}/gm)) {\n    const [, clusterId, body] = cm as unknown as [string, string, string];\n    const memberIds = [...body.matchAll(/^\\s*([pjt]_[A-Za-z0-9_]+)\\s*\\[/gm)]\n      .map(m => (m as unknown as [string, string])[1]);\n    clusters.set(clusterId, {\n      id: clusterId,\n      shortName: clusterId.replace(/^cluster_/, ''),\n      nodes: memberIds,\n    });\n    for (const n of memberIds) nodeToCluster.set(n, clusterId);\n  }\n\n  // Catch nodes declared at root (orphans) — strip cluster bodies, then scan\n  const stripped = dot.replace(/subgraph cluster_\\w+\\s*\\{[^]*?^\\s*\\}/gm, '');\n  for (const m of stripped.matchAll(/^\\s*([pjt]_[A-Za-z0-9_]+)\\s*\\[/gm)) {\n    const id = (m as unknown as [string, string])[1];\n    if (!nodes.has(id)) {\n      // Root-declared node without full attrs (rare); seed with empty attrs.\n      nodes.set(id, { id, kind: classifyKind(id), attrs: {} });\n    }\n  }\n\n  const orphans = [...nodes.keys()].filter(n => !nodeToCluster.has(n));\n\n  const edges: ParsedEdge[] = [];\n  for (const m of dot.matchAll(/([pjt]_[A-Za-z0-9_]+)\\s*->\\s*([pjt]_[A-Za-z0-9_]+)\\s*(\\[[^\\]]*\\])?/g)) {\n    const [, src, dst, rawAttrs] = m as unknown as [string, string, string, string | undefined];\n    const attrs = rawAttrs ?? '';\n    // Cluster-anchor edges (lhead/ltail) are exporter-internal routing hints,\n    // not real arcs in the Petri net — skip per v3 line 97.\n    if (attrs.includes('lhead=') || attrs.includes('ltail=')) continue;\n    let arc: ArcType = 'normal';\n    if (attrs.includes('label=\"reset\"') || attrs.includes('#fd7e14')) arc = 'reset';\n    else if (attrs.includes('arrowhead=\"odot\"') || attrs.includes('#dc3545')) arc = 'inhibitor';\n    else if (attrs.includes('label=\"read\"')) arc = 'read';\n    // Strip the `[…]` brackets so writeBack can splice the body into a new\n    // attr list. Empty if libpetri emitted a bare `src -> dst;`.\n    const stripped = attrs.startsWith('[') && attrs.endsWith(']')\n      ? attrs.slice(1, -1)\n      : '';\n    edges.push({ src, dst, arc, rawAttrs: stripped });\n  }\n\n  return { nodes, clusters, nodeToCluster, orphans, edges };\n}\n\n/**\n * Adopt orphan nodes into the cluster their edges most prefer.\n *\n * For each orphan, tally how many of its edges touch each cluster. If the\n * dominant cluster gets at least `threshold` of the orphan's cluster-touching\n * edges, the orphan is reassigned to that cluster.\n *\n * Mirrors v3 lines 105–136. Default threshold 0.7 matches REASSIGN_ORPHANS.\n */\nexport function foldOrphans(graph: GraphModel, threshold = 0.7): GraphModel {\n  if (threshold <= 0) return graph;\n\n  const nodeToCluster = new Map(graph.nodeToCluster);\n  const clusterMembers = new Map<string, string[]>();\n  for (const [id, c] of graph.clusters) clusterMembers.set(id, [...c.nodes]);\n\n  const tally = new Map<string, Map<string, number>>();\n  const bump = (orphan: string, other: string): void => {\n    const oc = nodeToCluster.get(other);\n    if (!oc) return;\n    let t = tally.get(orphan);\n    if (!t) { t = new Map(); tally.set(orphan, t); }\n    t.set(oc, (t.get(oc) ?? 0) + 1);\n  };\n\n  for (const e of graph.edges) {\n    const sIsOrphan = !nodeToCluster.has(e.src);\n    const dIsOrphan = !nodeToCluster.has(e.dst);\n    if (sIsOrphan && !dIsOrphan) bump(e.src, e.dst);\n    if (dIsOrphan && !sIsOrphan) bump(e.dst, e.src);\n  }\n\n  for (const id of graph.orphans) {\n    const t = tally.get(id);\n    if (!t) continue;\n    let total = 0;\n    let bestCluster: string | null = null;\n    let bestCount = 0;\n    for (const [c, n] of t) {\n      total += n;\n      if (n > bestCount) { bestCount = n; bestCluster = c; }\n    }\n    if (bestCluster && total > 0 && bestCount / total >= threshold) {\n      clusterMembers.get(bestCluster)!.push(id);\n      nodeToCluster.set(id, bestCluster);\n    }\n  }\n\n  const clusters = new Map<string, ParsedCluster>();\n  for (const [id, c] of graph.clusters) {\n    clusters.set(id, { ...c, nodes: clusterMembers.get(id)! });\n  }\n  const orphans = [...graph.nodes.keys()].filter(n => !nodeToCluster.has(n));\n  return { ...graph, clusters, nodeToCluster, orphans };\n}\n\nexport interface ReplicateOptions {\n  /**\n   * Skip places that touch more than this many foreign clusters. Per the\n   * plan's \"no cap\" decision, default is `Infinity`. Set to a finite value\n   * to suppress replication of hub places that would otherwise produce many\n   * copies.\n   */\n  readonly max?: number;\n  /** If true, replicate transitions as well as places. Default false. */\n  readonly replicateTransitions?: boolean;\n}\n\nexport interface ReplicateStats {\n  readonly replicatedPlaces: number;\n  readonly totalCopies: number;\n}\n\n/**\n * For each place P, replicate it into every foreign cluster touched by its\n * edges, and redirect those cross-cluster edges to the local copy.\n *\n * Replica id convention is load-bearing: `${placeId}__rep__${shortClusterName}`.\n * Downstream stages (mount-time tagging, overlay highlight, click-all-copies)\n * key off this naming and the `replica: true` / `replicaOf` markers.\n *\n * If P has a home cluster (folded earlier), the original stays as the primary\n * copy and is also marked as a replica so the ⇄ glyph renders consistently.\n * If P is an orphan with all its edges redirected, the original is dropped.\n *\n * Mirrors v3 lines 138–221.\n */\nexport function replicateShared(\n  graph: GraphModel,\n  opts: ReplicateOptions = {},\n): GraphModel & { readonly replicateStats: ReplicateStats } {\n  const max = opts.max ?? Infinity;\n  const replicateTransitions = opts.replicateTransitions ?? false;\n\n  const nodes = new Map(graph.nodes);\n  const nodeToCluster = new Map(graph.nodeToCluster);\n  const clusterMembers = new Map<string, string[]>();\n  for (const [id, c] of graph.clusters) clusterMembers.set(id, [...c.nodes]);\n  const edges = graph.edges.map(e => ({ ...e }));\n\n  // 1. Compute foreign-cluster set per replicable node.\n  const foreignByNode = new Map<string, Set<string>>();\n  const noteForeign = (nodeId: string, otherId: string): void => {\n    if (!nodeId.startsWith('p_') && !(replicateTransitions && nodeId.startsWith('t_'))) return;\n    const home = nodeToCluster.get(nodeId);\n    const otherCluster = nodeToCluster.get(otherId);\n    if (!otherCluster) return;\n    if (otherCluster === home) return;\n    let s = foreignByNode.get(nodeId);\n    if (!s) { s = new Set(); foreignByNode.set(nodeId, s); }\n    s.add(otherCluster);\n  };\n  for (const e of edges) {\n    noteForeign(e.src, e.dst);\n    noteForeign(e.dst, e.src);\n  }\n\n  // 2. Emit replicas for nodes within the cap.\n  const replicaMap = new Map<string, Map<string, string>>();  // orig → cluster → replicaId\n  let replicatedPlaces = 0;\n  let totalCopies = 0;\n  for (const [placeId, foreigns] of foreignByNode) {\n    if (foreigns.size === 0) continue;\n    if (foreigns.size > max) continue;\n    const perCluster = new Map<string, string>();\n    const orig = nodes.get(placeId);\n    if (!orig) continue;\n    for (const clusterId of foreigns) {\n      const shortName = clusterId.replace(/^cluster_/, '');\n      const repId = `${placeId}__rep__${shortName}`;\n      perCluster.set(clusterId, repId);\n      clusterMembers.get(clusterId)!.push(repId);\n      nodeToCluster.set(repId, clusterId);\n      nodes.set(repId, {\n        id: repId,\n        kind: orig.kind,\n        attrs: { ...orig.attrs },\n        replica: true,\n        replicaOf: placeId,\n      });\n      totalCopies++;\n    }\n    replicaMap.set(placeId, perCluster);\n    replicatedPlaces++;\n    // Mark the original as a shared place so the ⇄ glyph renders uniformly.\n    nodes.set(placeId, { ...orig, replica: true, replicaOf: placeId });\n  }\n\n  // 3. Redirect cross-cluster edges to the local replica on each end.\n  for (const e of edges) {\n    const sMap = replicaMap.get(e.src);\n    const dMap = replicaMap.get(e.dst);\n    if (sMap) {\n      const dCl = nodeToCluster.get(e.dst);\n      if (dCl && sMap.has(dCl)) e.src = sMap.get(dCl)!;\n    }\n    if (dMap) {\n      const sCl = nodeToCluster.get(e.src);\n      if (sCl && dMap.has(sCl)) e.dst = dMap.get(sCl)!;\n    }\n  }\n\n  // 4. Drop orphan originals whose edges all got redirected away.\n  for (const [origId] of replicaMap) {\n    if (nodeToCluster.has(origId)) continue;  // folded — keep as primary\n    const stillHasEdge = edges.some(e => e.src === origId || e.dst === origId);\n    if (!stillHasEdge) nodes.delete(origId);\n  }\n\n  const clusters = new Map<string, ParsedCluster>();\n  for (const [id, c] of graph.clusters) {\n    clusters.set(id, { ...c, nodes: clusterMembers.get(id)! });\n  }\n  const orphans = [...nodes.keys()].filter(n => !nodeToCluster.has(n));\n\n  return {\n    nodes,\n    clusters,\n    nodeToCluster,\n    orphans,\n    edges,\n    replicateStats: { replicatedPlaces, totalCopies },\n  };\n}\n"],"mappings":"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","names":["stripped"]}

package/dist/render-QOHGDWNE.js

@@ -0,0 +1,78 @@
+// 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, cfg) {
+  const key = fnv1a(dotSource + "\0" + JSON.stringify(cfg ?? {}));
+  let pinnedDot = getCachedPinnedDot(key);
+  if (pinnedDot === void 0) {
+    const { foldOrphans, parseLibpetriDot, replicateShared } = await import("./preprocess-FN3F75JR.js");
+    const { elkLayout, writeBack } = await import("./elk-place-YVNQFGXI.js").catch(
+      (cause) => {
+        throw new Error(
+          "the viewer's default 'elk' layout requires the optional peer dependency 'elkjs'. Install it, or pass { layout: 'graphviz' } to mount() for stock Graphviz layout with spline edges.",
+          { cause }
+        );
+      }
+    );
+    const graph = replicateShared(
+      foldOrphans(parseLibpetriDot(dotSource), 0.7),
+      { max: Infinity }
+    );
+    const layout = await elkLayout(graph, cfg);
+    pinnedDot = writeBack(graph, layout);
+    setCachedPinnedDot(key, pinnedDot);
+  }
+  const viz = await getViz();
+  return viz.renderSVGElement(pinnedDot, {
+    // nop2 draws the pinned node positions AND our ELK-computed orthogonal
+    // edge routes verbatim. See writeBack/edgePosSpline: we route edges
+    // ourselves rather than let Graphviz's ortho router run, which crashes
+    // the wasm on large nets.
+    engine: "nop2",
+    yInvert: true
+  });
+}
+export {
+  _clearElkLayoutCache,
+  getViz,
+  renderDotToSvg,
+  renderDotToSvgWithElkLayout
+};
+//# sourceMappingURL=render-QOHGDWNE.js.map

package/dist/render-QOHGDWNE.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 `nop2` (pinned nodes AND\n *                                        edge routes). 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 * The ELK stage is pulled in by dynamic import rather than at module load, so\n * the plain-Graphviz path genuinely works without `elkjs` present. Under a\n * static import the whole module failed to load and `layout: 'graphviz'` was\n * an escape hatch that could never be reached.\n *\n * @module viewer/render\n */\n\nimport { instance as vizInstance } from '@viz-js/viz';\nimport type { ElkLayoutConfig } 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 plus the layout config, so\n * re-mounts on the same net structure and config skip everything except the\n * 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 *\n * `cfg` tunes the ELK stage — see {@link ElkLayoutConfig}.\n */\nexport async function renderDotToSvgWithElkLayout(\n  dotSource: string,\n  cfg?: ElkLayoutConfig,\n): Promise<SVGSVGElement> {\n  const key = fnv1a(dotSource + '\\0' + JSON.stringify(cfg ?? {}));\n  let pinnedDot = getCachedPinnedDot(key);\n  if (pinnedDot === undefined) {\n    const { foldOrphans, parseLibpetriDot, replicateShared } =\n      await import('./layout/preprocess.js');\n    // `elkjs` is an optional peer dependency, in line with the viewer's other\n    // browser-only peers. Name it explicitly here: the raw resolution failure\n    // mentions a deep path inside elkjs and reads as a libpetri bug.\n    const { elkLayout, writeBack } = await import('./layout/elk-place.js').catch(\n      (cause: unknown) => {\n        throw new Error(\n          \"the viewer's default 'elk' layout requires the optional peer \"\n            + \"dependency 'elkjs'. Install it, or pass { layout: 'graphviz' } \"\n            + 'to mount() for stock Graphviz layout with spline edges.',\n          { cause },\n        );\n      },\n    );\n    const graph = replicateShared(\n      foldOrphans(parseLibpetriDot(dotSource), 0.7),\n      { max: Infinity },\n    );\n    const layout = await elkLayout(graph, cfg);\n    pinnedDot = writeBack(graph, layout);\n    setCachedPinnedDot(key, pinnedDot);\n  }\n  const viz = await getViz();\n  return viz.renderSVGElement(pinnedDot, {\n    // nop2 draws the pinned node positions AND our ELK-computed orthogonal\n    // edge routes verbatim. See writeBack/edgePosSpline: we route edges\n    // ourselves rather than let Graphviz's ortho router run, which crashes\n    // the wasm on large nets.\n    engine: 'nop2',\n    yInvert: true,\n  });\n}\n"],"mappings":";AAuBA,SAAS,YAAY,mBAAmB;AAKxC,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;AAcA,eAAsB,4BACpB,WACA,KACwB;AACxB,QAAM,MAAM,MAAM,YAAY,OAAO,KAAK,UAAU,OAAO,CAAC,CAAC,CAAC;AAC9D,MAAI,YAAY,mBAAmB,GAAG;AACtC,MAAI,cAAc,QAAW;AAC3B,UAAM,EAAE,aAAa,kBAAkB,gBAAgB,IACrD,MAAM,OAAO,0BAAwB;AAIvC,UAAM,EAAE,WAAW,UAAU,IAAI,MAAM,OAAO,yBAAuB,EAAE;AAAA,MACrE,CAAC,UAAmB;AAClB,cAAM,IAAI;AAAA,UACR;AAAA,UAGA,EAAE,MAAM;AAAA,QACV;AAAA,MACF;AAAA,IACF;AACA,UAAM,QAAQ;AAAA,MACZ,YAAY,iBAAiB,SAAS,GAAG,GAAG;AAAA,MAC5C,EAAE,KAAK,SAAS;AAAA,IAClB;AACA,UAAM,SAAS,MAAM,UAAU,OAAO,GAAG;AACzC,gBAAY,UAAU,OAAO,MAAM;AACnC,uBAAmB,KAAK,SAAS;AAAA,EACnC;AACA,QAAM,MAAM,MAAM,OAAO;AACzB,SAAO,IAAI,iBAAiB,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA,IAKrC,QAAQ;AAAA,IACR,SAAS;AAAA,EACX,CAAC;AACH;","names":[]}

package/dist/render-dom/index.d.ts

@@ -1,20 +1,33 @@
-import panzoom from 'panzoom';
+import { P as PanzoomInstance, a as PanzoomOptions } from '../pan-zoom-Cp51IkDl.js';
+export { D as DEFAULT_PANZOOM_OPTS } from '../pan-zoom-Cp51IkDl.js';
+import 'panzoom';
 
 /**
- * DOM rendering helper for libpetri DOT diagrams.
+ * Compatibility wrapper over the canonical viewer.
  *
- * Single source of truth for the viz.js + panzoom pipeline used by both
- * debug-ui (live sessions) and the internal dev-preview Vite app
- * (sample.dot iteration loop). Doc generators (Javadoc taglet, Rustdoc
- * build.rs, TypeDoc plugin) take a different path — they shell out to the
- * Graphviz `dot` binary at build time — and do not consume this module.
+ * This module predates `libpetri/viewer` and used to be the shared viz.js +
+ * panzoom pipeline behind debug-ui and the dev-preview app. Both moved to the
+ * canonical viewer at `274cb41`, and the doc generators (Javadoc taglet,
+ * `libpetri-docgen`, TypeDoc plugin) never shelled out to a `dot` binary
+ * again either: they embed the viewer IIFE and mount client-side.
  *
- * Browser-only: requires `@viz-js/viz` and `panzoom` as peer dependencies.
+ * What was left behind was a public export that still pinned Graphviz
+ * `engine: 'dot'`, so anything reaching for it got stock spline layout with
+ * diagonal edges while every first-party surface rendered ELK-placed nodes
+ * with orthogonal routes. `renderDotToContainer` now delegates to
+ * {@link mount}, so all render paths agree.
+ *
+ * Prefer importing `libpetri/viewer` directly in new code: `mount()` returns a
+ * {@link ViewerHandle} with cluster collapse, subnet toggling, filtering and
+ * highlight control, of which this wrapper surfaces only the SVG and the
+ * panzoom instance.
+ *
+ * Browser-only. Requires `@viz-js/viz`, `panzoom`, and `elkjs` (the viewer's
+ * default layout) as peer dependencies.
  *
  * @module render-dom
  */
 
-type PanzoomInstance = ReturnType<typeof panzoom>;
 interface RenderDotOptions {
     /**
      * Existing panzoom instance to dispose before initializing a new one.
@@ -27,33 +40,19 @@ interface RenderDotOptions {
      * so partial overrides keep the unspecified defaults (e.g. passing only
      * `smoothScroll: true` retains `maxZoom: 1000` and `minZoom: 0.02`).
      */
-    readonly panzoom?: Parameters<typeof panzoom>[1];
+    readonly panzoom?: PanzoomOptions;
 }
 interface RenderDotResult {
     readonly svg: SVGSVGElement;
     readonly panzoom: PanzoomInstance;
 }
-/**
- * Default panzoom configuration shared by debug-ui and the dev preview.
- *
- * - `maxZoom: 1000` — effectively unlimited; lets users dive into ~150-node
- *   diagrams without hitting an artificial ceiling.
- * - `minZoom: 0.02` — allows fitting very large nets in a small viewport.
- * - `smoothScroll: false` — sharper interactive feel.
- * - `zoomDoubleClickSpeed: 1` — single-click double-zoom toggle.
- */
-declare const DEFAULT_PANZOOM_OPTS: {
-    readonly smoothScroll: false;
-    readonly zoomDoubleClickSpeed: 1;
-    readonly maxZoom: 1000;
-    readonly minZoom: 0.02;
-};
 /**
  * Render a DOT string into a container element and wrap it with panzoom.
  *
- * Engine is pinned to `'dot'` so layout is deterministic across reloads;
- * libpetri mappers emit byte-stable DOT (per spec EXP-014) and the `dot`
- * engine produces identical SVG for identical input.
+ * Layout is the viewer default: ELK node placement plus ELK-computed
+ * orthogonal edge routes, drawn by Graphviz `nop2`. Deterministic across
+ * reloads, since libpetri mappers emit byte-stable DOT (spec EXP-014) and
+ * neither stage introduces randomness.
  *
  * The container's existing children are removed before the new SVG is
  * appended.
@@ -64,4 +63,4 @@ declare const DEFAULT_PANZOOM_OPTS: {
  */
 declare function renderDotToContainer(dotSource: string, container: HTMLElement, opts?: RenderDotOptions): Promise<RenderDotResult>;
 
-export { DEFAULT_PANZOOM_OPTS, type PanzoomInstance, type RenderDotOptions, type RenderDotResult, renderDotToContainer };
+export { PanzoomInstance, PanzoomOptions, type RenderDotOptions, type RenderDotResult, renderDotToContainer };