libpetri 2.3.2 → 2.5.0

package/dist/{petri-net-CKZYPOsL.d.ts → petri-net-DXdpd0r5.d.ts}

@@ -1297,8 +1297,20 @@ declare class PetriNet {
     readonly name: string;
     readonly places: ReadonlySet<Place<any>>;
     readonly transitions: ReadonlySet<Transition>;
+    /**
+     * Subnet-membership metadata per **MOD-026**: maps each node name (place or
+     * transition) contributed by exactly one directly-composed subnet to that
+     * subnet's name. Shared places contributed by two or more subnets, and every
+     * node of a net not built via {@link PetriNetBuilder.compose}`(SubnetDef)`,
+     * are absent. Never null — an empty map when there is no metadata. The DOT
+     * exporter renders `subgraph cluster_*` blocks from this map.
+     *
+     * V8 `Map` is insertion-ordered, preserving compose order so cluster
+     * subgraphs render deterministically (cross-language byte-parity).
+     */
+    readonly subnetMembership: ReadonlyMap<string, string>;
     /** @internal Use {@link PetriNet.builder} to create instances. */
-    constructor(key: symbol, name: string, places: ReadonlySet<Place<any>>, transitions: ReadonlySet<Transition>);
+    constructor(key: symbol, name: string, places: ReadonlySet<Place<any>>, transitions: ReadonlySet<Transition>, subnetMembership?: ReadonlyMap<string, string>);
     /**
      * Creates a new PetriNet with actions bound to transitions by name.
      * Unbound transitions keep passthrough action.
@@ -1315,6 +1327,7 @@ declare class PetriNetBuilder {
     private readonly _places;
     private readonly _transitions;
     private readonly _fusionSets;
+    private readonly _subnetContributions;
     constructor(name: string);
     /** Add an explicit place. */
     place(place: Place<any>): this;
@@ -1363,6 +1376,42 @@ declare class PetriNetBuilder {
     compose(instance: Instance<unknown>): this;
     compose(instance: Instance<unknown>, portMappings: ReadonlyMap<string, Place<unknown>> | Record<string, Place<unknown>>): this;
     compose(instance: Instance<unknown>, bind: (b: ComposeBindings) => void): this;
+    compose(def: SubnetDef<unknown>): this;
+    /**
+     * Composes a subnet {@link SubnetDef} **directly** into this builder per
+     * **MOD-025** — **without instantiation**, and without the prefix-renaming
+     * of {@link SubnetDef.instantiate}.
+     *
+     * Every body place and transition is added under its **original**
+     * (un-prefixed) name. Places merge into this builder by name: a body place
+     * whose name equals an enclosing-net place *is* that place in the composed
+     * flat net. This is the mode for wiring a subnet in as a single shared copy.
+     *
+     * Direct composition is **order-independent**: composing the same set of
+     * subnets in any order yields the same flat net, because merging is by
+     * place name and not by a probe of the builder's place set at call time —
+     * contrast the no-interface body-inference branch of {@link composeAuto}
+     * (MOD-024), which is order-sensitive.
+     *
+     * For multiple *independent* copies — each with isolated per-instance state
+     * per [MOD-012] — use {@link SubnetDef.instantiate} + the `compose(instance)`
+     * overload instead.
+     *
+     * Rejections: a body transition whose name already exists in this builder
+     * (use `instantiate(prefix)` for independent copies); a subnet whose
+     * interface declares any channel (direct composition does not bind
+     * channels — use `instantiate` + the channel-binding `compose` overload).
+     *
+     * Token-type conflicts on a same-named place cannot be detected: TS
+     * {@link Place} equality is name-only at runtime (the documented carve-out,
+     * same as MOD-024).
+     *
+     * @throws when the subnet declares channels, or a body transition name
+     *         collides with a transition already in this builder.
+     */
+    private composeDirect;
+    /** @internal MOD-026: records a node as contributed by the named subnet. */
+    private recordContribution;
     /**
      * Identity-default auto-compose per **MOD-024**.
      *
@@ -1481,6 +1530,22 @@ declare class PetriNetBuilder {
      * @throws when two fusion sets share a place
      */
     build(): PetriNet;
+    /**
+     * @internal Resolves the per-compose contributions recorded by
+     * `composeDirect` into the final node-name → subnet-name membership map per
+     * **MOD-026**. A node contributed by exactly one subnet maps to that subnet;
+     * a place contributed by two or more subnets is a shared rendezvous place
+     * and is omitted (it renders top-level, outside any cluster). Returns an
+     * empty map — the common case — when no subnet was composed directly.
+     */
+    private resolveSubnetMembership;
+    /**
+     * @internal Drops membership entries for places removed by fusion: a
+     * non-canonical fused member no longer exists in the net, so its
+     * `node-name → subnet` entry would dangle. The surviving canonical place
+     * keeps its own entry. Per **MOD-026**.
+     */
+    private static filterFusedMembership;
     /**
      * @internal Fusion-resolution pass per **MOD-061**. Split out from
      * {@link build} so the no-fusion fast path stays trivial.

package/dist/verification/index.d.ts

@@ -1,5 +1,5 @@
-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-CKZYPOsL.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-CKZYPOsL.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-DXdpd0r5.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-DXdpd0r5.js';
 import { Expr, init, Bool, FuncDecl } from 'z3-solver';
 
 /**

package/dist/viewer/index.d.ts

@@ -63,10 +63,16 @@ interface ClusterDescriptor {
  *
  * Graphviz emits cluster nodes as SIBLINGS of the cluster `<g>`, not as
  * children — `<g class="cluster">` only carries title, polygon border, and
- * the cluster's text label. To recover cluster membership we match each
- * node's `<title>` (the original graph id) against libpetri's prefixing
- * convention: interior places are emitted as `p_<prefix>_<name>`,
- * transitions as `t_<prefix>_<name>`, and junctions as `j_<prefix>_<name>`.
+ * the cluster's text label. Cluster membership is recovered two ways:
+ *
+ *  - **Name-based** — instance composition prefixes interior names
+ *    (`p_<prefix>_…`, `t_<prefix>_…`, `j_<prefix>_…`) or uses slash-separated
+ *    names (`<prefix>/…`).
+ *  - **Geometric** — direct composition (spec MOD-026) keeps each node's
+ *    original, un-prefixed name, so the only structural signal left in the
+ *    rendered SVG is the node's drawn position: a node whose centre falls
+ *    inside the cluster's border box belongs to it. This is what Graphviz
+ *    itself draws the box around.
  *
  * Does not split nested-cluster prefixes (`outer_inner` could mean either
  * `outer/inner` or a flat `outer_inner` prefix — Graphviz sanitisation is

package/dist/viewer/index.js

@@ -30,13 +30,14 @@ function discoverClusters(svg) {
     if (!raw.startsWith("cluster_")) continue;
     const prefix = raw.slice("cluster_".length);
     if (out.has(prefix)) continue;
+    const rect = clusterRect(g);
     let nodeCount = 0;
     for (const node of allNodes) {
       if (node.getAttribute("data-instance")) continue;
       const nodeTitle = directChild(node, "title");
       if (!nodeTitle) continue;
       const id = (nodeTitle.textContent ?? "").trim();
-      if (nodeBelongsToPrefix(id, prefix)) {
+      if (nodeBelongsToCluster(id, node, prefix, rect)) {
         node.setAttribute("data-instance", prefix);
         nodeCount++;
       }
@@ -50,9 +51,77 @@ function discoverClusters(svg) {
   }
   return out;
 }
+function nodeBelongsToCluster(nodeId, node, prefix, rect) {
+  if (nodeBelongsToPrefix(nodeId, prefix)) return true;
+  if (rect) {
+    const c = nodeCenter(node);
+    if (c && c.x >= rect.minX && c.x <= rect.maxX && c.y >= rect.minY && c.y <= rect.maxY) {
+      return true;
+    }
+  }
+  return false;
+}
 function nodeBelongsToPrefix(nodeId, prefix) {
   return nodeId === prefix || nodeId.startsWith(`${prefix}/`) || nodeId.startsWith(`p_${prefix}_`) || nodeId.startsWith(`t_${prefix}_`) || nodeId.startsWith(`j_${prefix}_`);
 }
+function clusterRect(group) {
+  const border = directChild(group, "polygon") ?? directChild(group, "path");
+  if (!border) return null;
+  const raw = border.getAttribute("points") ?? border.getAttribute("d") ?? "";
+  return boundsOf(raw);
+}
+function nodeCenter(node) {
+  const ellipse = directChild(node, "ellipse");
+  if (ellipse) {
+    const x = parseFloat(ellipse.getAttribute("cx") ?? "");
+    const y = parseFloat(ellipse.getAttribute("cy") ?? "");
+    if (!Number.isNaN(x) && !Number.isNaN(y)) return { x, y };
+  }
+  const shape = directChild(node, "polygon") ?? directChild(node, "path");
+  if (shape) {
+    const bounds = boundsOf(
+      shape.getAttribute("points") ?? shape.getAttribute("d") ?? ""
+    );
+    if (bounds) {
+      return {
+        x: (bounds.minX + bounds.maxX) / 2,
+        y: (bounds.minY + bounds.maxY) / 2
+      };
+    }
+  }
+  return null;
+}
+function boundsOf(coords) {
+  const nums = coords.match(/-?\d+(?:\.\d+)?/g);
+  if (!nums || nums.length < 2) return null;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let i = 0; i + 1 < nums.length; i += 2) {
+    const x = parseFloat(nums[i]);
+    const y = parseFloat(nums[i + 1]);
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  }
+  if (minX === Infinity) return null;
+  return { minX, minY, maxX, maxY };
+}
+function nodeClusterMap(svg) {
+  const map = /* @__PURE__ */ new Map();
+  svg.querySelectorAll("g.node[data-instance]").forEach((node) => {
+    const di = node.getAttribute("data-instance");
+    const title = directChild(node, "title");
+    const id = (title?.textContent ?? "").trim();
+    if (di && id) map.set(id, di);
+  });
+  return map;
+}
+function endpointInCluster(id, prefix, clusterMap) {
+  return nodeBelongsToPrefix(id, prefix) || clusterMap.get(id) === prefix;
+}
 function colorForPrefix(prefix) {
   let h = 2166136261;
   for (let i = 0; i < prefix.length; i++) {
@@ -84,6 +153,7 @@ function setClusterCollapsed(cluster, collapsed) {
       node.classList.add("petri-collapsed-inside");
       hidden.push(node);
     });
+    const clusterMap = nodeClusterMap(root);
     root.querySelectorAll("g.edge").forEach((edge) => {
       const titleEl = directChild(edge, "title");
       if (!titleEl) return;
@@ -92,7 +162,7 @@ function setClusterCollapsed(cluster, collapsed) {
       if (arrow < 0) return;
       const from = t.slice(0, arrow);
       const to = t.slice(arrow + 2);
-      if (nodeBelongsToPrefix(from, cluster.prefix) && nodeBelongsToPrefix(to, cluster.prefix)) {
+      if (endpointInCluster(from, cluster.prefix, clusterMap) && endpointInCluster(to, cluster.prefix, clusterMap)) {
         edge.classList.add("petri-collapsed-inside");
         hidden.push(edge);
       }
@@ -135,6 +205,7 @@ function applyFilter(svg, prefix) {
   }
   svg.setAttribute("data-active-filter", prefix);
   svg.classList.add("has-active-filter");
+  const clusterMap = nodeClusterMap(svg);
   svg.querySelectorAll("g.node").forEach((node) => {
     const di = node.getAttribute("data-instance");
     const match = !!di && (di === prefix || di.indexOf(prefix + "_") === 0 || di.indexOf(prefix + "/") === 0);
@@ -152,7 +223,7 @@ function applyFilter(svg, prefix) {
     }
     const from = titleText.slice(0, arrow);
     const to = titleText.slice(arrow + 2);
-    const matches = (name) => name.indexOf(prefix + "/") >= 0 || name.indexOf(prefix + "_") >= 0 || name === prefix;
+    const matches = (name) => name.indexOf(prefix + "/") >= 0 || name.indexOf(prefix + "_") >= 0 || name === prefix || clusterMap.get(name) === prefix;
     if (matches(from) || matches(to)) edge.classList.remove("petri-dimmed");
     else edge.classList.add("petri-dimmed");
   });
@@ -160,9 +231,10 @@ function applyFilter(svg, prefix) {
 function isInsideCollapsedCluster(svg, clusters, collapsedPrefixes, graphId) {
   if (collapsedPrefixes.size === 0) return false;
   if (!svg) return false;
+  const clusterMap = nodeClusterMap(svg);
   for (const prefix of collapsedPrefixes) {
     if (!clusters.has(prefix)) continue;
-    if (nodeBelongsToPrefix(graphId, prefix)) return true;
+    if (endpointInCluster(graphId, prefix, clusterMap)) return true;
   }
   return false;
 }