libpetri 1.8.5 → 2.0.0

package/dist/index.js

@@ -1,15 +1,22 @@
 import {
+  SmtVerifier,
   allPlaces,
   and,
   andPlaces,
   enumerateBranches,
   forwardInput,
+  isProven,
+  isViolated,
   outPlace,
   timeout,
   timeoutPlace,
   xor,
   xorPlaces
-} from "./chunk-VQ4XMJTD.js";
+} from "./chunk-H62Z76FY.js";
+import {
+  eventTransitionName,
+  isFailureEvent
+} from "./chunk-SXK2Z45Z.js";
 import {
   MAX_DURATION_MS,
   deadline,
@@ -126,9 +133,10 @@ function consumptionCount(spec, available) {
 
 // src/core/transition-action.ts
 function passthrough() {
-  return async () => {
-  };
+  return PASSTHROUGH;
 }
+var PASSTHROUGH = async () => {
+};
 function transform(fn) {
   return async (ctx) => {
     const result = fn(ctx);
@@ -165,13 +173,13 @@ function produce(place2, value) {
 }
 function withTimeout(action, timeoutMs, timeoutPlace2, timeoutValue) {
   return (ctx) => {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let completed = false;
       const timer = setTimeout(() => {
         if (!completed) {
           completed = true;
           ctx.output(timeoutPlace2, timeoutValue);
-          resolve();
+          resolve2();
         }
       }, timeoutMs);
       action(ctx).then(
@@ -179,7 +187,7 @@ function withTimeout(action, timeoutMs, timeoutPlace2, timeoutValue) {
           if (!completed) {
             completed = true;
             clearTimeout(timer);
-            resolve();
+            resolve2();
           }
         },
         (err) => {
@@ -627,6 +635,423 @@ function findForwardInputs(out) {
   }
 }
 
+// src/core/compose-bindings.ts
+var COMPOSE_BINDINGS_KEY = /* @__PURE__ */ Symbol("ComposeBindings.internal");
+var ComposeBindings = class {
+  _portBindings = /* @__PURE__ */ new Map();
+  _channelBindings = /* @__PURE__ */ new Map();
+  /**
+   * @internal Use {@link PetriNetBuilder.compose} — instances are produced
+   * by the host builder and supplied to the caller's callback.
+   */
+  constructor(key) {
+    if (key !== COMPOSE_BINDINGS_KEY) {
+      throw new Error(
+        "Use PetriNetBuilder.compose(instance, b => ...) \u2014 ComposeBindings is not directly constructible"
+      );
+    }
+  }
+  /**
+   * Binds the named interface port to the given caller place per **MOD-020**.
+   *
+   * The port name is the **original** (pre-prefix) name declared in the
+   * subnet's `Interface`. The typed `<T>` parameter ensures the caller
+   * place's token type matches the interface port's token type at compile
+   * time per [MOD-022]; TypeScript does not validate the type at runtime
+   * because generics are erased.
+   *
+   * @throws when `portName` is already bound on this builder
+   */
+  bindPort(portName, callerPlace) {
+    if (this._portBindings.has(portName)) {
+      throw new Error(`Port '${portName}' is already bound`);
+    }
+    this._portBindings.set(portName, callerPlace);
+    return this;
+  }
+  /**
+   * Records a synchronous channel binding per **MOD-021**: at compose time,
+   * the instance-side renamed channel transition is merged with
+   * `callerTransition` into a single transition in the resulting flat net.
+   *
+   * **Status**: channel composition is implemented in task #13. Recording a
+   * channel binding here is permitted, but `compose(...)` currently raises
+   * an `Error` when any channel binding is present.
+   *
+   * @throws when `channelName` is already bound on this builder
+   */
+  bindChannel(channelName, callerTransition) {
+    if (this._channelBindings.has(channelName)) {
+      throw new Error(`Channel '${channelName}' is already bound`);
+    }
+    this._channelBindings.set(channelName, callerTransition);
+    return this;
+  }
+  /** Returns an unmodifiable view of the recorded port bindings. */
+  portBindings() {
+    return this._portBindings;
+  }
+  /** Returns an unmodifiable view of the recorded channel bindings. */
+  channelBindings() {
+    return this._channelBindings;
+  }
+};
+function __createComposeBindings() {
+  return new ComposeBindings(COMPOSE_BINDINGS_KEY);
+}
+
+// src/core/internal/subnet-rewriter.ts
+function renamePlace(orig, prefix) {
+  return place(prefix + "/" + orig.name);
+}
+function renameNet(body, prefix, placeRemap, transitionRemap) {
+  placeRemap.clear();
+  transitionRemap.clear();
+  for (const orig of body.places) {
+    placeRemap.set(orig.name, renamePlace(orig, prefix));
+  }
+  const builder = PetriNet.builder(prefix + "/" + body.name);
+  for (const renamedPlace of placeRemap.values()) {
+    builder.place(renamedPlace);
+  }
+  for (const t of body.transitions) {
+    const renamed = rewriteTransition(t, prefix, placeRemap);
+    transitionRemap.set(t.name, renamed);
+    builder.transition(renamed);
+  }
+  return builder.build();
+}
+function rewriteTransition(t, prefix, placeRemap) {
+  return rebuildWithName(t, prefix + "/" + t.name, placeRemap);
+}
+function substitutePlaces(t, remap) {
+  return rebuildWithName(t, t.name, remap);
+}
+function rebuildWithName(t, name, remap) {
+  const builder = Transition.builder(name).timing(t.timing).priority(t.priority).action(t.action);
+  if (t.inputSpecs.length > 0) {
+    const rewrittenInputs = new Array(t.inputSpecs.length);
+    for (let i = 0; i < t.inputSpecs.length; i++) {
+      rewrittenInputs[i] = rewriteIn(t.inputSpecs[i], remap);
+    }
+    builder.inputs(...rewrittenInputs);
+  }
+  if (t.outputSpec !== null) {
+    builder.outputs(rewriteOut(t.outputSpec, remap));
+  }
+  for (let i = 0; i < t.inhibitors.length; i++) {
+    builder.inhibitor(rewriteInhibitor(t.inhibitors[i], remap).place);
+  }
+  for (let i = 0; i < t.reads.length; i++) {
+    builder.read(rewriteRead(t.reads[i], remap).place);
+  }
+  for (let i = 0; i < t.resets.length; i++) {
+    builder.reset(rewriteReset(t.resets[i], remap).place);
+  }
+  return builder.build();
+}
+function rewriteIn(spec, remap) {
+  switch (spec.type) {
+    case "one":
+      return one(resolve(spec.place, remap), spec.guard);
+    case "exactly":
+      return exactly(spec.count, resolve(spec.place, remap), spec.guard);
+    case "all":
+      return all(resolve(spec.place, remap), spec.guard);
+    case "at-least":
+      return atLeast(spec.minimum, resolve(spec.place, remap), spec.guard);
+  }
+}
+function rewriteOut(out, remap) {
+  switch (out.type) {
+    case "place":
+      return outPlace(resolve(out.place, remap));
+    case "forward-input":
+      return forwardInput(resolve(out.from, remap), resolve(out.to, remap));
+    case "and": {
+      const children = out.children;
+      const rewritten = new Array(children.length);
+      for (let i = 0; i < children.length; i++) {
+        rewritten[i] = rewriteOut(children[i], remap);
+      }
+      return { type: "and", children: rewritten };
+    }
+    case "xor": {
+      const children = out.children;
+      const rewritten = new Array(children.length);
+      for (let i = 0; i < children.length; i++) {
+        rewritten[i] = rewriteOut(children[i], remap);
+      }
+      return { type: "xor", children: rewritten };
+    }
+    case "timeout":
+      return timeout(out.afterMs, rewriteOut(out.child, remap));
+  }
+}
+function rewriteInhibitor(inh, remap) {
+  return { type: "inhibitor", place: resolve(inh.place, remap) };
+}
+function rewriteRead(rd, remap) {
+  return { type: "read", place: resolve(rd.place, remap) };
+}
+function rewriteReset(rs, remap) {
+  return { type: "reset", place: resolve(rs.place, remap) };
+}
+function resolve(p, remap) {
+  const replaced = remap.get(p.name);
+  return replaced !== void 0 ? replaced : p;
+}
+function mergeTransitions(caller, instance, mergedName) {
+  if (mergedName === void 0 || mergedName === null || mergedName.length === 0) {
+    throw new Error("mergeTransitions: mergedName must be a non-empty string");
+  }
+  const mergedTiming = mergeTimings(caller.timing, instance.timing, mergedName);
+  const mergedPriority = pickPriority(caller.priority, instance.priority);
+  const mergedAction = composeActions(caller.action, instance.action);
+  const builder = Transition.builder(mergedName).timing(mergedTiming).priority(mergedPriority);
+  if (mergedAction !== void 0) {
+    builder.action(mergedAction);
+  }
+  const unionedInputs = unionArcs(caller.inputSpecs, instance.inputSpecs, keyOfIn);
+  if (unionedInputs.length > 0) {
+    builder.inputs(...unionedInputs);
+  }
+  const mergedOutput = mergeOutputs(caller.outputSpec, instance.outputSpec);
+  if (mergedOutput !== null) {
+    builder.outputs(mergedOutput);
+  }
+  for (const inh of unionArcs(
+    caller.inhibitors,
+    instance.inhibitors,
+    keyOfInhibitor
+  )) {
+    builder.inhibitor(inh.place);
+  }
+  for (const rd of unionArcs(caller.reads, instance.reads, keyOfRead)) {
+    builder.read(rd.place);
+  }
+  for (const rs of unionArcs(caller.resets, instance.resets, keyOfReset)) {
+    builder.reset(rs.place);
+  }
+  return builder.build();
+}
+function mergeTimings(caller, instance, channelName) {
+  if (caller.type === "immediate" && instance.type === "immediate") {
+    return { type: "immediate" };
+  }
+  if (caller.type === "immediate") return instance;
+  if (instance.type === "immediate") return caller;
+  if (timingsEqual(caller, instance)) return caller;
+  throw new Error(
+    `Channel composition '${channelName}': conflicting non-Immediate timings \u2014 caller-side ${describeTiming(caller)} vs instance-side ${describeTiming(instance)}. Resolve explicitly by aligning the timings on either side (MOD-021).`
+  );
+}
+function pickPriority(callerPriority, _instancePriority) {
+  return callerPriority;
+}
+function composeActions(caller, instance) {
+  const callerIsPassthrough = caller === void 0 || isPassthrough(caller);
+  const instanceIsPassthrough = instance === void 0 || isPassthrough(instance);
+  if (callerIsPassthrough && instanceIsPassthrough) return void 0;
+  if (callerIsPassthrough) return instance;
+  if (instanceIsPassthrough) return caller;
+  return async (ctx) => {
+    await caller(ctx);
+    await instance(ctx);
+  };
+}
+function mergeOutputs(caller, instance) {
+  if (caller === null && instance === null) return null;
+  if (caller === null) return instance;
+  if (instance === null) return caller;
+  return and(caller, instance);
+}
+function unionArcs(caller, instance, keyOf) {
+  if (caller.length === 0 && instance.length === 0) return [];
+  const seen = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < caller.length; i2++) {
+    const arc = caller[i2];
+    const key = keyOf(arc);
+    if (!seen.has(key)) seen.set(key, arc);
+  }
+  for (let i2 = 0; i2 < instance.length; i2++) {
+    const arc = instance[i2];
+    const key = keyOf(arc);
+    if (!seen.has(key)) seen.set(key, arc);
+  }
+  const result = new Array(seen.size);
+  let i = 0;
+  for (const arc of seen.values()) result[i++] = arc;
+  return result;
+}
+function timingsEqual(a, b) {
+  if (a.type !== b.type) return false;
+  switch (a.type) {
+    case "immediate":
+      return true;
+    case "deadline":
+      return a.byMs === b.byMs;
+    case "delayed":
+      return a.afterMs === b.afterMs;
+    case "window": {
+      const w = b;
+      return a.earliestMs === w.earliestMs && a.latestMs === w.latestMs;
+    }
+    case "exact":
+      return a.atMs === b.atMs;
+  }
+}
+function describeTiming(t) {
+  switch (t.type) {
+    case "immediate":
+      return "Immediate";
+    case "deadline":
+      return `Deadline(byMs=${t.byMs})`;
+    case "delayed":
+      return `Delayed(afterMs=${t.afterMs})`;
+    case "window":
+      return `Window(earliestMs=${t.earliestMs}, latestMs=${t.latestMs})`;
+    case "exact":
+      return `Exact(atMs=${t.atMs})`;
+  }
+}
+var PASSTHROUGH_REF = passthrough();
+function isPassthrough(action) {
+  return action === PASSTHROUGH_REF;
+}
+function keyOfIn(arc) {
+  switch (arc.type) {
+    case "one":
+      return arc.guard === void 0 ? `one|${arc.place.name}` : `one|${arc.place.name}|g:${guardKey(arc.guard)}`;
+    case "exactly":
+      return arc.guard === void 0 ? `exactly|${arc.place.name}|${arc.count}` : `exactly|${arc.place.name}|${arc.count}|g:${guardKey(arc.guard)}`;
+    case "all":
+      return arc.guard === void 0 ? `all|${arc.place.name}` : `all|${arc.place.name}|g:${guardKey(arc.guard)}`;
+    case "at-least":
+      return arc.guard === void 0 ? `atLeast|${arc.place.name}|${arc.minimum}` : `atLeast|${arc.place.name}|${arc.minimum}|g:${guardKey(arc.guard)}`;
+  }
+}
+function keyOfInhibitor(arc) {
+  return `inh|${arc.place.name}`;
+}
+function keyOfRead(arc) {
+  return `read|${arc.place.name}`;
+}
+function keyOfReset(arc) {
+  return `reset|${arc.place.name}`;
+}
+var GUARD_KEYS = /* @__PURE__ */ new WeakMap();
+var guardKeyCounter = 0;
+function guardKey(g) {
+  let k = GUARD_KEYS.get(g);
+  if (k === void 0) {
+    k = String(++guardKeyCounter);
+    GUARD_KEYS.set(g, k);
+  }
+  return k;
+}
+function applyFusion(transitions, fusionMap) {
+  const rewritten = /* @__PURE__ */ new Set();
+  for (const t of transitions) {
+    rewritten.add(substitutePlaces(t, fusionMap));
+  }
+  return rewritten;
+}
+
+// src/core/fusion-set.ts
+var FUSION_SET_KEY = /* @__PURE__ */ Symbol("FusionSet.internal");
+var FusionSet = class _FusionSet {
+  name;
+  members;
+  /** @internal Use {@link FusionSet.builder} or {@link FusionSet.of} to create instances. */
+  constructor(key, name, members) {
+    if (key !== FUSION_SET_KEY) {
+      throw new Error("Use FusionSet.builder() or FusionSet.of() to create instances");
+    }
+    this.name = name;
+    this.members = members;
+  }
+  /**
+   * Returns the canonical member — by convention, the first declared member.
+   * The canonical place's identity survives into the resulting flat net.
+   */
+  get canonical() {
+    return this.members[0];
+  }
+  /**
+   * Returns all members **except** the canonical member, in declaration order.
+   * These are the places that get substituted away at
+   * {@link import('./petri-net.js').PetriNetBuilder.build} time.
+   *
+   * For a single-member (degenerate) set, returns an empty array.
+   */
+  nonCanonical() {
+    if (this.members.length <= 1) return [];
+    return this.members.slice(1);
+  }
+  toString() {
+    return `FusionSet[${this.name}, canonical=${this.canonical.name}, members=${this.members.length}]`;
+  }
+  // ============================================================
+  //  Static factories
+  // ============================================================
+  /** Returns a fresh {@link FusionSetBuilder} with the given human-readable name. */
+  static builder(name) {
+    return new FusionSetBuilder(name);
+  }
+  /**
+   * Convenience factory: builds a fusion set whose first member is `first`
+   * (the canonical) and whose remaining members are `rest`, all sharing the
+   * type `<T>`.
+   *
+   * The varargs form ensures static-type homogeneity at the call site (the
+   * TypeScript compiler checks every `rest` entry is a `Place<T>`).
+   */
+  static of(name, first, ...rest) {
+    const members = [first];
+    for (const p of rest) members.push(p);
+    return new _FusionSet(FUSION_SET_KEY, name, Object.freeze(members));
+  }
+};
+var FusionSetBuilder = class {
+  _name;
+  _members = [];
+  constructor(name) {
+    if (typeof name !== "string" || name.length === 0) {
+      throw new Error("FusionSet.builder: name must be a non-empty string");
+    }
+    this._name = name;
+  }
+  /**
+   * Appends a member to the fusion set. The first member becomes the canonical
+   * place per the convention documented on {@link FusionSet}.
+   *
+   * The `<T>` parameter is for compile-time guidance only: callers writing
+   * typed code at the same call site benefit from the compiler checking
+   * `Place<T>` at each member.
+   */
+  member(place2) {
+    if (place2 === void 0 || place2 === null) {
+      throw new Error(`FusionSet '${this._name}': member place must not be null`);
+    }
+    this._members.push(place2);
+    return this;
+  }
+  /**
+   * Builds the immutable {@link FusionSet}. Validates that the set has at
+   * least one member; the empty set is rejected as malformed per **MOD-060**.
+   * Single-member sets are accepted as a structurally degenerate no-op.
+   */
+  build() {
+    if (this._members.length === 0) {
+      throw new Error(
+        `FusionSet '${this._name}': must have at least one member (MOD-060)`
+      );
+    }
+    return new FusionSet(FUSION_SET_KEY, this._name, Object.freeze(this._members.slice()));
+  }
+};
+
 // src/core/petri-net.ts
 var PETRI_NET_KEY = /* @__PURE__ */ Symbol("PetriNet.internal");
 var PetriNet = class _PetriNet {
@@ -673,6 +1098,7 @@ var PetriNetBuilder = class {
   _name;
   _places = /* @__PURE__ */ new Set();
   _transitions = /* @__PURE__ */ new Set();
+  _fusionSets = [];
   constructor(name) {
     this._name = name;
   }
@@ -711,8 +1137,182 @@ var PetriNetBuilder = class {
     for (const t of transitions) this.transition(t);
     return this;
   }
+  compose(instance, arg) {
+    if (typeof arg === "function") {
+      const bindings = __createComposeBindings();
+      arg(bindings);
+      return this.composeInternal(instance, bindings.portBindings(), bindings.channelBindings());
+    }
+    const portMappings = arg instanceof Map ? arg : new Map(Object.entries(arg));
+    return this.composeInternal(instance, portMappings, /* @__PURE__ */ new Map());
+  }
+  /**
+   * @internal Shared compose implementation: validates port and channel
+   * bindings, builds the place-substitution map, walks every renamed-body
+   * transition through {@link substitutePlaces}, applies channel merges per
+   * [MOD-021], and adds the resulting transitions to this builder.
+   *
+   * ## Channel-merge flow ([MOD-021])
+   *
+   * 1. Collect rewritten instance transitions into a working `Map<string,
+   *    Transition>` keyed by prefixed transition name (deferred — not yet
+   *    added to the builder's transition set).
+   * 2. For each channel binding, resolve the renamed instance-side
+   *    transition through `instance.channel(channelName)`, then look up its
+   *    rewritten counterpart in the working map by name.
+   * 3. Replace the working-map entry with a {@link mergeTransitions} result
+   *    that fuses caller-side + instance-side; remove the rewritten
+   *    instance-side entry. Also replace (or add) the caller-side
+   *    transition in this builder's transition set with the same merged
+   *    result, indexed under the caller's name slot.
+   * 4. Add the surviving (un-merged) entries to this builder.
+   *
+   * The deferral matters: writing the rewritten instance transitions to the
+   * builder eagerly would force a second "remove-then-replace" pass to
+   * apply the channel merges, complicating the place-collection invariants.
+   * Collecting first and merging second keeps the builder's transition set
+   * finalized exactly once.
+   *
+   * Keying the working map by prefixed transition name (rather than by
+   * Transition reference) is also robust against a prior
+   * {@link Instance.bindActions} call that may have rebuilt the renamed-body
+   * transitions, breaking identity equality between the body and the
+   * channel-handle map — but the prefixed names remain stable.
+   */
+  composeInternal(instance, portMappings, channelBindings) {
+    const iface = instance.def.iface;
+    const mergeMap = /* @__PURE__ */ new Map();
+    for (const [portName, callerPlace] of portMappings) {
+      const port = iface.port(portName);
+      if (port === void 0) {
+        const knownPorts = [];
+        for (const p of iface.ports.values()) knownPorts.push(p.name);
+        throw new Error(
+          `compose: no port named '${portName}' on subnet '${instance.def.name}' (instance prefix '${instance.prefix}'). Known ports: [${knownPorts.join(", ")}]`
+        );
+      }
+      const ifacePlace = instance.port(portName);
+      mergeMap.set(ifacePlace.name, callerPlace);
+    }
+    const rewrittenByName = /* @__PURE__ */ new Map();
+    for (const t of instance.renamedBody.transitions) {
+      rewrittenByName.set(t.name, substitutePlaces(t, mergeMap));
+    }
+    for (const [channelName, callerTrans] of channelBindings) {
+      let instanceRenamedChannel;
+      try {
+        instanceRenamedChannel = instance.channel(channelName);
+      } catch (cause) {
+        const knownChannels = [];
+        for (const c of iface.channels.values()) knownChannels.push(c.name);
+        const err = new Error(
+          `compose: no channel named '${channelName}' on subnet '${instance.def.name}' (instance prefix '${instance.prefix}'). Known channels: [${knownChannels.join(", ")}]`
+        );
+        err.cause = cause;
+        throw err;
+      }
+      const rewrittenInstanceChannel = rewrittenByName.get(instanceRenamedChannel.name);
+      if (rewrittenInstanceChannel === void 0) {
+        throw new Error(
+          `compose: channel '${channelName}' resolved to a transition '${instanceRenamedChannel.name}' that is not present in the renamed body. This indicates a SubnetDef invariant violation.`
+        );
+      }
+      const merged = mergeTransitions(callerTrans, rewrittenInstanceChannel, callerTrans.name);
+      rewrittenByName.delete(instanceRenamedChannel.name);
+      this._transitions.delete(callerTrans);
+      this.transition(merged);
+    }
+    for (const rewritten of rewrittenByName.values()) {
+      this.transition(rewritten);
+    }
+    return this;
+  }
+  fuse(...args) {
+    if (args.length === 1 && typeof args[0] === "function") {
+      const declarer = args[0];
+      const fb = FusionSet.builder(this._name + "-fusion");
+      declarer(fb);
+      this._fusionSets.push(fb.build());
+      return this;
+    }
+    for (const s of args) {
+      if (s === void 0 || s === null) {
+        throw new Error("fuse: fusion set must not be null");
+      }
+      this._fusionSets.push(s);
+    }
+    return this;
+  }
+  /**
+   * Builds the immutable {@link PetriNet}, applying fusion resolution (per
+   * **MOD-061**) AFTER all transition/composition accumulation:
+   *
+   * 1. Detect overlapping fusion sets — a single place declared in two sets
+   *    is rejected with an `Error`.
+   * 2. Build the `non-canonical → canonical` substitution map across all
+   *    sets, keyed by non-canonical place name (matching the rewriter's
+   *    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.
+   * 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
+   *    members are also dropped.
+   *
+   * If no fusion sets were registered, the build is the trivial
+   * `new PetriNet(...)` — the fusion machinery has no per-build cost when
+   * unused.
+   *
+   * @throws when two fusion sets share a place
+   */
   build() {
-    return new PetriNet(PETRI_NET_KEY, this._name, this._places, this._transitions);
+    if (this._fusionSets.length === 0) {
+      return new PetriNet(PETRI_NET_KEY, this._name, this._places, this._transitions);
+    }
+    return this.buildWithFusion();
+  }
+  /**
+   * @internal Fusion-resolution pass per **MOD-061**. Split out from
+   * {@link build} so the no-fusion fast path stays trivial.
+   */
+  buildWithFusion() {
+    const ownership = /* @__PURE__ */ new Map();
+    for (const set of this._fusionSets) {
+      for (const member of set.members) {
+        const prior = ownership.get(member.name);
+        if (prior !== void 0 && prior !== set) {
+          throw new Error(
+            `Fusion overlap: place '${member.name}' appears in two fusion sets ('${prior.name}' and '${set.name}'). A place may appear in at most one fusion set (MOD-060).`
+          );
+        }
+        ownership.set(member.name, set);
+      }
+    }
+    const fusionMap = /* @__PURE__ */ new Map();
+    const nonCanonicalNames = /* @__PURE__ */ new Set();
+    for (const set of this._fusionSets) {
+      const canonical = set.canonical;
+      for (const nc of set.nonCanonical()) {
+        fusionMap.set(nc.name, canonical);
+        nonCanonicalNames.add(nc.name);
+      }
+    }
+    const rewrittenTransitions = applyFusion(this._transitions, fusionMap);
+    const rebuiltPlaces = /* @__PURE__ */ new Set();
+    for (const p of this._places) {
+      if (!nonCanonicalNames.has(p.name)) {
+        rebuiltPlaces.add(p);
+      }
+    }
+    for (const t of rewrittenTransitions) {
+      for (const spec of t.inputSpecs) rebuiltPlaces.add(spec.place);
+      for (const p of t.outputPlaces()) rebuiltPlaces.add(p);
+      for (const inh of t.inhibitors) rebuiltPlaces.add(inh.place);
+      for (const r of t.reads) rebuiltPlaces.add(r.place);
+      for (const r of t.resets) rebuiltPlaces.add(r.place);
+    }
+    return new PetriNet(PETRI_NET_KEY, this._name, rebuiltPlaces, rewrittenTransitions);
   }
 };
 function rebuildWithAction(t, action) {
@@ -735,6 +1335,602 @@ function rebuildWithAction(t, action) {
   return builder.build();
 }
 
+// src/core/subnet.ts
+function closedSubnet(net) {
+  return { kind: "closed", net };
+}
+function openSubnet(def) {
+  return { kind: "open", def };
+}
+
+// src/core/interface.ts
+var INTERFACE_KEY = /* @__PURE__ */ Symbol("Interface.internal");
+var Interface = class {
+  ports;
+  channels;
+  /** @internal Use {@link Interface.builder} to create instances. */
+  constructor(key, ports, channels) {
+    if (key !== INTERFACE_KEY) throw new Error("Use Interface.builder() to create instances");
+    this.ports = ports;
+    this.channels = channels;
+  }
+  /** Looks up a port by name. Returns undefined when absent. */
+  port(name) {
+    return this.ports.get(name);
+  }
+  /** Looks up a channel by name. Returns undefined when absent. */
+  channel(name) {
+    return this.channels.get(name);
+  }
+  /**
+   * Looks up a port by name and returns its underlying place, narrowed to
+   * `Place<T>`. Returns undefined when the port does not exist.
+   *
+   * Note: TypeScript erases generics at runtime, so unlike Java's
+   * `portPlaceAs(name, Class<T>)` this method cannot verify the token type at
+   * runtime — the caller is trusted to supply the correct `T`. Per **MOD-022**,
+   * type compatibility is enforced at compile time only in TypeScript.
+   */
+  placeAs(name) {
+    const p = this.ports.get(name);
+    if (p === void 0) return void 0;
+    return p.place;
+  }
+  static builder() {
+    return new InterfaceBuilder();
+  }
+};
+var InterfaceBuilder = class {
+  _ports = /* @__PURE__ */ new Map();
+  _channels = /* @__PURE__ */ new Map();
+  /** Add a pre-built port (rejects duplicate names). */
+  port(port) {
+    if (this._ports.has(port.name)) {
+      throw new Error(`Duplicate port name: '${port.name}'`);
+    }
+    this._ports.set(port.name, port);
+    return this;
+  }
+  /** Add an input port (advisory direction). */
+  inputPort(name, place2) {
+    return this.port({ name, direction: "input", place: place2 });
+  }
+  /** Add an output port (advisory direction). */
+  outputPort(name, place2) {
+    return this.port({ name, direction: "output", place: place2 });
+  }
+  /** Add an in-out port (advisory direction). */
+  inoutPort(name, place2) {
+    return this.port({ name, direction: "inout", place: place2 });
+  }
+  channel(channelOrName, transition) {
+    const ch = typeof channelOrName === "string" ? { name: channelOrName, transition } : channelOrName;
+    if (this._channels.has(ch.name)) {
+      throw new Error(`Duplicate channel name: '${ch.name}'`);
+    }
+    this._channels.set(ch.name, ch);
+    return this;
+  }
+  /** @internal Bulk-add ports already validated by the caller. */
+  portsAll(ports) {
+    for (const p of ports) this.port(p);
+    return this;
+  }
+  /** @internal Bulk-add channels already validated by the caller. */
+  channelsAll(channels) {
+    for (const c of channels) this.channel(c);
+    return this;
+  }
+  build() {
+    return new Interface(
+      INTERFACE_KEY,
+      new Map(this._ports),
+      new Map(this._channels)
+    );
+  }
+};
+
+// src/core/instance.ts
+var INSTANCE_KEY = /* @__PURE__ */ Symbol("Instance.internal");
+var Instance = class {
+  prefix;
+  def;
+  renamedBody;
+  portHandles;
+  channelHandles;
+  params;
+  /**
+   * @internal Use {@link SubnetDef.instantiate} (or the internal factory
+   * {@link __createInstance}) to create instances.
+   */
+  constructor(key, prefix, def, renamedBody, portHandles, channelHandles, params) {
+    if (key !== INSTANCE_KEY) {
+      throw new Error("Use SubnetDef.instantiate() to create Instance values");
+    }
+    this.prefix = prefix;
+    this.def = def;
+    this.renamedBody = renamedBody;
+    this.portHandles = portHandles;
+    this.channelHandles = channelHandles;
+    this.params = params;
+  }
+  /**
+   * Returns the renamed {@link Place} corresponding to the named port.
+   *
+   * The port name is the **original** (pre-prefix) name as declared in the
+   * subnet's `Interface`. Per **MOD-022**, TypeScript enforces token-type
+   * compatibility at compile time only; this method does not validate `T`
+   * at runtime. A missing name raises an `Error`.
+   *
+   * @throws when the port name is unknown
+   */
+  port(name) {
+    const p = this.portHandles.get(name);
+    if (p === void 0) {
+      throw new Error(`No port named '${name}' in instance '${this.prefix}'`);
+    }
+    return p;
+  }
+  /**
+   * Returns the renamed {@link Transition} corresponding to the named channel.
+   *
+   * @throws when the channel name is unknown
+   */
+  channel(name) {
+    const t = this.channelHandles.get(name);
+    if (t === void 0) {
+      throw new Error(`No channel named '${name}' in instance '${this.prefix}'`);
+    }
+    return t;
+  }
+  /**
+   * Returns the debug-UI descriptor for this instance per **MOD-041**.
+   */
+  descriptor() {
+    const transitions = [];
+    for (const t of this.renamedBody.transitions) transitions.push(t.name);
+    const exposedPlaces = [];
+    for (const p of this.portHandles.values()) exposedPlaces.push(p.name);
+    return {
+      prefix: this.prefix,
+      defName: this.def.name,
+      transitions,
+      exposedPlaces,
+      params: this.params,
+      parentPrefix: null
+    };
+  }
+  /**
+   * Produces a derived instance whose specified transitions (named by their
+   * **original**, pre-prefix names) carry the supplied actions per **MOD-030**.
+   *
+   * For each entry `[originalName, action]`, the renamed body is searched for
+   * the transition whose name equals `prefix + "/" + originalName`. The
+   * resulting instance shares the original `def`, `prefix`, `params`, and
+   * port/channel handle topology — only the renamed body is rebuilt with new
+   * actions. Per **MOD-030**, calling `bindActions` on one instance does NOT
+   * affect the actions held by other instances of the same `def`.
+   *
+   * Unrecognised original names raise an `Error` so typos surface eagerly.
+   */
+  bindActions(actionsByOriginalName) {
+    const prefixedByName = /* @__PURE__ */ new Map();
+    const renamedNames = /* @__PURE__ */ new Set();
+    for (const t of this.renamedBody.transitions) {
+      renamedNames.add(t.name);
+    }
+    for (const originalName of Object.keys(actionsByOriginalName)) {
+      const prefixed = this.prefix + "/" + originalName;
+      if (!renamedNames.has(prefixed)) {
+        throw new Error(
+          `Instance.bindActions: no transition '${originalName}' (resolved as '${prefixed}') in instance '${this.prefix}' of subnet '${this.def.name}'`
+        );
+      }
+      prefixedByName.set(prefixed, actionsByOriginalName[originalName]);
+    }
+    const reboundBody = this.renamedBody.bindActionsWithResolver((name) => {
+      const action = prefixedByName.get(name);
+      if (action !== void 0) return action;
+      for (const t of this.renamedBody.transitions) {
+        if (t.name === name) return t.action;
+      }
+      throw new Error(`Instance.bindActions: resolver invoked with unknown name '${name}'`);
+    });
+    const reboundChannelHandles = /* @__PURE__ */ new Map();
+    if (this.channelHandles.size > 0) {
+      const byName = /* @__PURE__ */ new Map();
+      for (const t of reboundBody.transitions) {
+        byName.set(t.name, t);
+      }
+      for (const [name, oldT] of this.channelHandles) {
+        const refreshed = byName.get(oldT.name);
+        if (refreshed === void 0) {
+          throw new Error(
+            `Instance.bindActions: channel '${name}' transition '${oldT.name}' not found in rebound body`
+          );
+        }
+        reboundChannelHandles.set(name, refreshed);
+      }
+    }
+    return __createInstance(
+      this.prefix,
+      this.def,
+      reboundBody,
+      this.portHandles,
+      reboundChannelHandles,
+      this.params
+    );
+  }
+};
+function __createInstance(prefix, def, renamedBody, portHandles, channelHandles, params) {
+  return new Instance(
+    INSTANCE_KEY,
+    prefix,
+    def,
+    renamedBody,
+    portHandles,
+    channelHandles,
+    params
+  );
+}
+
+// src/verification/verification-harness.ts
+function buildVerificationResult(syntheticNet, perProperty) {
+  const frozen = new Map(perProperty);
+  return {
+    syntheticNet,
+    perProperty: frozen,
+    allProven() {
+      for (const r of frozen.values()) {
+        if (!isProven(r)) return false;
+      }
+      return true;
+    },
+    anyViolated() {
+      for (const r of frozen.values()) {
+        if (isViolated(r)) return true;
+      }
+      return false;
+    }
+  };
+}
+function normaliseGenerators(generators) {
+  if (generators instanceof Map) return new Map(generators);
+  return new Map(Object.entries(generators));
+}
+function normaliseProperties(properties) {
+  if (Array.isArray(properties)) return [...properties];
+  return [...properties];
+}
+
+// src/core/subnet-def.ts
+var SUBNET_DEF_KEY = /* @__PURE__ */ Symbol("SubnetDef.internal");
+var SubnetDef = class _SubnetDef {
+  name;
+  body;
+  iface;
+  /** @internal Use {@link SubnetDef.builder} or {@link SubnetDef.fromNet} to create instances. */
+  constructor(key, name, body, iface) {
+    if (key !== SUBNET_DEF_KEY) {
+      throw new Error("Use SubnetDef.builder() or SubnetDef.fromNet() to create instances");
+    }
+    this.name = name;
+    this.body = body;
+    this.iface = iface;
+  }
+  /**
+   * Produces a renamed module instance per **MOD-010**, **MOD-011**, **MOD-012**,
+   * and **MOD-030**.
+   *
+   * The rename pass walks every place and transition of the body net,
+   * substituting each name with `prefix + "/" + originalName`, and rebuilds
+   * every arc with rewritten place references. Transition timing, priority,
+   * and action are carried through by reference (action sharing per
+   * [MOD-030]). The renamed body is itself a structurally valid `PetriNet`
+   * per [CORE-040]; per-instance state isolation per [MOD-012] is a
+   * structural consequence of distinct prefixed names.
+   *
+   * ## Prefix validation
+   *
+   * The `"/"` character is reserved as the prefix separator (per [MOD-010]).
+   * User-supplied prefixes MUST NOT contain `"/"`; nested instantiation is
+   * performed by the future `PetriNetBuilder.compose(...)` mechanism (per
+   * [MOD-013]). A prefix containing `"/"` raises an `Error`.
+   *
+   * @param prefix the rename prefix (non-empty, must not contain `"/"`)
+   * @param params the parameter value carried through to `Instance.params`
+   *               (may be omitted when `P` is `void`)
+   * @throws when `prefix` is empty or contains `"/"`
+   */
+  instantiate(prefix, params) {
+    validatePrefix(prefix);
+    const placeRemap = /* @__PURE__ */ new Map();
+    const transitionRemap = /* @__PURE__ */ new Map();
+    const renamedBody = renameNet(this.body, prefix, placeRemap, transitionRemap);
+    const portHandles = /* @__PURE__ */ new Map();
+    for (const port of this.iface.ports.values()) {
+      const renamed = placeRemap.get(port.place.name);
+      if (renamed === void 0) {
+        throw new Error(
+          `Port '${port.name}' references place '${port.place.name}' that was not found in the renamed body. This indicates a SubnetDef invariant violation.`
+        );
+      }
+      portHandles.set(port.name, renamed);
+    }
+    const channelHandles = /* @__PURE__ */ new Map();
+    for (const channel of this.iface.channels.values()) {
+      const renamed = transitionRemap.get(channel.transition.name);
+      if (renamed === void 0) {
+        throw new Error(
+          `Channel '${channel.name}' references transition '${channel.transition.name}' that was not found in the renamed body. This indicates a SubnetDef invariant violation.`
+        );
+      }
+      channelHandles.set(channel.name, renamed);
+    }
+    return __createInstance(
+      prefix,
+      this,
+      renamedBody,
+      portHandles,
+      channelHandles,
+      params
+    );
+  }
+  /**
+   * Verifies safety properties of this subnet definition **in isolation** per
+   * **MOD-051**, by wrapping it in a synthetic enclosing net where each input
+   * port is fed by an {@link EnvironmentPlace} (token-source per the harness
+   * generator) and each output port is observed via a synthetic place. The
+   * standard {@link SmtVerifier} (per [MOD-050]) is invoked once per property
+   * declared in the harness; the resulting per-property outcomes are
+   * aggregated into a {@link VerificationResult}.
+   *
+   * ## Synthetic-net construction
+   *
+   * The synthetic enclosing net is built by:
+   * 1. Instantiating this `SubnetDef` with the prefix `"sut"` (system-under-test)
+   *    and `harness.params`.
+   * 2. For each input or in-out port on the interface, looking up the
+   *    harness generator by port name, allocating a synthetic
+   *    {@link Place}`<unknown>` of the same conceptual token type as the
+   *    port, wrapping it in an {@link EnvironmentPlace}, and binding the
+   *    port to that synthetic place via
+   *    {@link import('./petri-net.js').PetriNetBuilder.compose}. The supplier
+   *    is invoked once at construction time to materialize the seed token —
+   *    its presence is what bounds the input behavior under analysis. **If
+   *    the harness map is missing a generator for a required input or in-out
+   *    port, an `Error` is thrown.**
+   * 3. For each output or in-out port, allocating a synthetic observation
+   *    {@link Place}`<unknown>` and binding the port to it via the same
+   *    `compose(...)` call. The verifier inspects this place's reachability
+   *    / marking through the standard property APIs ({@link SmtProperty}).
+   * 4. Building the resulting flat {@link PetriNet} per [MOD-023] (the
+   *    verifier is composition-unaware per [MOD-050]).
+   *
+   * ## Per-property invocation
+   *
+   * Each {@link SmtProperty} in the harness is verified independently against
+   * the same synthetic net. The synthetic environment places are passed
+   * through to the verifier so that places driven by the harness generators
+   * are treated under the verifier's environment-analysis semantics rather
+   * than as ordinary sink places.
+   *
+   * @param harness the verification harness — supplies parameters, input-port
+   *                token generators, and the property set
+   * @returns a {@link VerificationResult} aggregating per-property
+   *          {@link SmtVerificationResult}s
+   * @throws when an input or in-out port is missing a harness generator
+   */
+  async verify(harness) {
+    if (harness === null || harness === void 0) {
+      throw new Error("SubnetDef.verify: harness must not be null/undefined");
+    }
+    const sut = this.instantiate("sut", harness.params);
+    const generators = normaliseGenerators(harness.portInputGenerators);
+    const properties = normaliseProperties(harness.properties);
+    const envPlaces = [];
+    const portMappings = /* @__PURE__ */ new Map();
+    for (const port of this.iface.ports.values()) {
+      const portName = port.name;
+      switch (port.direction) {
+        case "input": {
+          const generator = generators.get(portName);
+          if (generator === void 0) {
+            throw new Error(
+              `verify: harness is missing an input generator for port '${portName}' on subnet '${this.name}' (MOD-051)`
+            );
+          }
+          const seed = generator();
+          if (seed === null || seed === void 0) {
+            throw new Error(
+              `verify: input generator for port '${portName}' on subnet '${this.name}' produced null/undefined`
+            );
+          }
+          const synth = place(`harness_in_${portName}`);
+          envPlaces.push(environmentPlace(synth.name));
+          portMappings.set(portName, synth);
+          break;
+        }
+        case "output": {
+          const synth = place(`harness_out_${portName}`);
+          portMappings.set(portName, synth);
+          break;
+        }
+        case "inout": {
+          const generator = generators.get(portName);
+          if (generator === void 0) {
+            throw new Error(
+              `verify: harness is missing an input generator for in-out port '${portName}' on subnet '${this.name}' (MOD-051)`
+            );
+          }
+          const seed = generator();
+          if (seed === null || seed === void 0) {
+            throw new Error(
+              `verify: input generator for in-out port '${portName}' on subnet '${this.name}' produced null/undefined`
+            );
+          }
+          const synth = place(`harness_io_${portName}`);
+          envPlaces.push(environmentPlace(synth.name));
+          portMappings.set(portName, synth);
+          break;
+        }
+      }
+    }
+    const syntheticNet = PetriNet.builder("verify_" + this.name).compose(sut, portMappings).build();
+    const perProperty = /* @__PURE__ */ new Map();
+    for (const property of properties) {
+      const verifier = SmtVerifier.forNet(syntheticNet).property(property);
+      if (envPlaces.length > 0) {
+        verifier.environmentPlaces(...envPlaces);
+      }
+      const result = await verifier.verify();
+      perProperty.set(property, result);
+    }
+    return buildVerificationResult(syntheticNet, perProperty);
+  }
+  // ============================================================
+  //  Static factories
+  // ============================================================
+  static builder(name) {
+    return new SubnetDefBuilder(name);
+  }
+  /**
+   * Retrofit utility per **MOD-014**: wraps an existing closed {@link PetriNet}
+   * plus an {@link Interface} into an unparameterised `SubnetDef<void>`.
+   *
+   * Validation per **MOD-014** / **MOD-006** is enforced before the result is
+   * constructed:
+   * - Every port's underlying `Place` must be present in `net.places`.
+   * - Every channel's underlying `Transition` must be present in `net.transitions`.
+   * - Port and channel name uniqueness is re-validated defensively (the
+   *   `Interface` builder already enforces this; hand-built `Interface`
+   *   values bypass that path).
+   *
+   * The resulting subnet definition is unparameterised (parameter type is `void`).
+   *
+   * @throws when a port place is not in `net.places`, a channel transition is
+   *         not in `net.transitions`, or port/channel names are not unique.
+   */
+  static fromNet(net, iface) {
+    const bodyPlaces = net.places;
+    const bodyTransitions = net.transitions;
+    const seenPortNames = /* @__PURE__ */ new Set();
+    for (const port of iface.ports.values()) {
+      if (seenPortNames.has(port.name)) {
+        throw new Error(
+          `fromNet: duplicate port name '${port.name}' on interface for net '${net.name}' (MOD-006)`
+        );
+      }
+      seenPortNames.add(port.name);
+      if (!bodyPlaces.has(port.place)) {
+        throw new Error(
+          `fromNet: port '${port.name}' references place '${port.place.name}' which is not in net '${net.name}' (MOD-014/MOD-006)`
+        );
+      }
+    }
+    const seenChannelNames = /* @__PURE__ */ new Set();
+    for (const channel of iface.channels.values()) {
+      if (seenChannelNames.has(channel.name)) {
+        throw new Error(
+          `fromNet: duplicate channel name '${channel.name}' on interface for net '${net.name}' (MOD-006)`
+        );
+      }
+      seenChannelNames.add(channel.name);
+      if (!bodyTransitions.has(channel.transition)) {
+        throw new Error(
+          `fromNet: channel '${channel.name}' references transition '${channel.transition.name}' which is not in net '${net.name}' (MOD-014/MOD-006)`
+        );
+      }
+    }
+    return new _SubnetDef(SUBNET_DEF_KEY, net.name, net, iface);
+  }
+};
+var SubnetDefBuilder = class {
+  _name;
+  _bodyBuilder;
+  _ports = [];
+  _channels = [];
+  constructor(name) {
+    this._name = name;
+    this._bodyBuilder = PetriNet.builder(name);
+  }
+  // -------- body construction (delegates to PetriNet.Builder) --------
+  transition(transition) {
+    this._bodyBuilder.transition(transition);
+    return this;
+  }
+  transitions(...transitions) {
+    this._bodyBuilder.transitions(...transitions);
+    return this;
+  }
+  place(place2) {
+    this._bodyBuilder.place(place2);
+    return this;
+  }
+  // -------- interface declarations --------
+  inputPort(name, place2) {
+    this._ports.push({ name, direction: "input", place: place2 });
+    return this;
+  }
+  outputPort(name, place2) {
+    this._ports.push({ name, direction: "output", place: place2 });
+    return this;
+  }
+  inoutPort(name, place2) {
+    this._ports.push({ name, direction: "inout", place: place2 });
+    return this;
+  }
+  channel(name, transition) {
+    this._channels.push({ name, transition });
+    return this;
+  }
+  // -------- build & validate (MOD-006) --------
+  build() {
+    const built = this._bodyBuilder.build();
+    const bodyPlaces = built.places;
+    const bodyTransitions = built.transitions;
+    const portNames = /* @__PURE__ */ new Set();
+    for (const port of this._ports) {
+      if (portNames.has(port.name)) {
+        throw new Error(`Subnet '${this._name}': duplicate port name '${port.name}'`);
+      }
+      portNames.add(port.name);
+      if (!bodyPlaces.has(port.place)) {
+        throw new Error(
+          `Subnet '${this._name}': port '${port.name}' references place '${port.place.name}' which is not in the body`
+        );
+      }
+    }
+    const channelNames = /* @__PURE__ */ new Set();
+    for (const channel of this._channels) {
+      if (channelNames.has(channel.name)) {
+        throw new Error(`Subnet '${this._name}': duplicate channel name '${channel.name}'`);
+      }
+      channelNames.add(channel.name);
+      if (!bodyTransitions.has(channel.transition)) {
+        throw new Error(
+          `Subnet '${this._name}': channel '${channel.name}' references transition '${channel.transition.name}' which is not in the body`
+        );
+      }
+    }
+    const ifaceBuilder = Interface.builder();
+    ifaceBuilder.portsAll(this._ports);
+    ifaceBuilder.channelsAll(this._channels);
+    const iface = ifaceBuilder.build();
+    return new SubnetDef(SUBNET_DEF_KEY, this._name, built, iface);
+  }
+};
+function validatePrefix(prefix) {
+  if (typeof prefix !== "string" || prefix.length === 0) {
+    throw new Error("SubnetDef.instantiate: prefix must be a non-empty string");
+  }
+  if (prefix.indexOf("/") >= 0) {
+    throw new Error(
+      `SubnetDef.instantiate: prefix must not contain '/' (reserved as the prefix separator per MOD-010); use compose(...) for nested instantiation. Got: '${prefix}'`
+    );
+  }
+}
+
 // src/runtime/marking.ts
 var EMPTY_TOKENS = Object.freeze([]);
 var Marking = class _Marking {
@@ -1045,26 +2241,6 @@ function intersects(snapshot, mask) {
   return false;
 }
 
-// src/event/net-event.ts
-function eventTransitionName(event) {
-  switch (event.type) {
-    case "transition-enabled":
-    case "transition-clock-restarted":
-    case "transition-started":
-    case "transition-completed":
-    case "transition-failed":
-    case "transition-timed-out":
-    case "action-timed-out":
-    case "log-message":
-      return event.transitionName;
-    default:
-      return null;
-  }
-}
-function isFailureEvent(event) {
-  return event.type === "transition-failed" || event.type === "transition-timed-out" || event.type === "action-timed-out";
-}
-
 // src/event/event-store.ts
 function filterEvents(store, predicate) {
   return store.events().filter(predicate);
@@ -1346,11 +2522,11 @@ var BitmapNetExecutor = class {
       throw new Error(`Place ${envPlace.place.name} is not registered as an environment place`);
     }
     if (this.closed || this.draining) return false;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.externalQueue.push({
         place: envPlace.place,
         token,
-        resolve,
+        resolve: resolve2,
         reject
       });
       this.wakeUp();
@@ -1832,8 +3008,8 @@ var BitmapNetExecutor = class {
       promises.push(Promise.race(arr));
     }
     if (!this.closed) {
-      promises.push(new Promise((resolve) => {
-        this.wakeUpResolve = resolve;
+      promises.push(new Promise((resolve2) => {
+        this.wakeUpResolve = resolve2;
       }));
       const timerMs = this.millisUntilNextTimedTransition();
       if (timerMs > 0 && timerMs < Infinity) {
@@ -2442,11 +3618,11 @@ var PrecompiledNetExecutor = class {
       throw new Error(`Place ${envPlace.place.name} is not registered as an environment place`);
     }
     if (this.closed || this.draining) return false;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.externalQueue.push({
         place: envPlace.place,
         token,
-        resolve,
+        resolve: resolve2,
         reject
       });
       this.wakeUp();
@@ -3051,8 +4227,8 @@ var PrecompiledNetExecutor = class {
       }
     }
     if (!this.closed) {
-      promises.push(new Promise((resolve) => {
-        this.wakeUpResolve = resolve;
+      promises.push(new Promise((resolve2) => {
+        this.wakeUpResolve = resolve2;
       }));
       const timerMs = this.millisUntilNextTimedTransition();
       if (timerMs > 0 && timerMs < Infinity) {
@@ -3156,7 +4332,13 @@ var TimeoutSentinel2 = class extends Error {
 export {
   BitmapNetExecutor,
   CompiledNet,
+  ComposeBindings,
+  FusionSet,
+  FusionSetBuilder,
   InMemoryEventStore,
+  Instance,
+  Interface,
+  InterfaceBuilder,
   MAX_DURATION_MS,
   Marking,
   OutViolationError,
@@ -3164,6 +4346,8 @@ export {
   PetriNetBuilder,
   PrecompiledNet,
   PrecompiledNetExecutor,
+  SubnetDef,
+  SubnetDefBuilder,
   TokenInput,
   TokenOutput,
   Transition,
@@ -3176,6 +4360,7 @@ export {
   arcPlace,
   atLeast,
   clearBit,
+  closedSubnet,
   consumptionCount,
   containsAll,
   deadline,
@@ -3204,6 +4389,7 @@ export {
   matchesGuard,
   noopEventStore,
   one,
+  openSubnet,
   outPlace,
   outputArc,
   passthrough,