libpetri 2.12.1 → 3.0.0

package/dist/index.js

@@ -1,18 +1,33 @@
 import {
   SmtVerifier,
+  all,
   allPlaces,
   and,
   andPlaces,
+  atLeast,
+  consumptionCount,
   enumerateBranches,
+  exactly,
+  fork,
   forwardInput,
+  isPassthrough,
   isProven,
   isViolated,
+  one,
   outPlace,
+  passthrough,
+  produce,
+  requireOutputProducingActions,
+  requiredCount,
   timeout,
   timeoutPlace,
+  transform,
+  transformAsync,
+  transformFrom,
+  withTimeout,
   xor,
   xorPlaces
-} from "./chunk-V3WTQRHC.js";
+} from "./chunk-5W6SVYPD.js";
 import {
   eventTransitionName,
   isFailureEvent
@@ -22,7 +37,7 @@ import {
   matchCorrelates,
   matchKey,
   matchSpec
-} from "./chunk-E3ZWB645.js";
+} from "./chunk-YVIPJ6KM.js";
 import {
   MAX_DURATION_MS,
   deadline,
@@ -62,8 +77,8 @@ function environmentPlace(name) {
 }
 
 // src/core/arc.ts
-function inputArc(place2, guard) {
-  return guard !== void 0 ? { type: "input", place: place2, guard } : { type: "input", place: place2 };
+function inputArc(place2) {
+  return { type: "input", place: place2 };
 }
 function outputArc(place2) {
   return { type: "output", place: place2 };
@@ -80,139 +95,12 @@ function resetArc(place2) {
 function arcPlace(arc) {
   return arc.place;
 }
-function hasGuard(arc) {
-  return arc.guard !== void 0;
-}
-function matchesGuard(arc, value) {
-  if (arc.guard === void 0) return true;
-  return arc.guard(value);
-}
-
-// src/core/in.ts
-function one(place2, guard) {
-  return guard !== void 0 ? { type: "one", place: place2, guard } : { type: "one", place: place2 };
-}
-function exactly(count, place2, guard) {
-  if (count < 1) {
-    throw new Error(`count must be >= 1, got: ${count}`);
-  }
-  return guard !== void 0 ? { type: "exactly", place: place2, count, guard } : { type: "exactly", place: place2, count };
-}
-function all(place2, guard) {
-  return guard !== void 0 ? { type: "all", place: place2, guard } : { type: "all", place: place2 };
-}
-function atLeast(minimum, place2, guard) {
-  if (minimum < 1) {
-    throw new Error(`minimum must be >= 1, got: ${minimum}`);
-  }
-  return guard !== void 0 ? { type: "at-least", place: place2, minimum, guard } : { type: "at-least", place: place2, minimum };
-}
-function requiredCount(spec) {
-  switch (spec.type) {
-    case "one":
-      return 1;
-    case "exactly":
-      return spec.count;
-    case "all":
-      return 1;
-    case "at-least":
-      return spec.minimum;
-  }
-}
-function consumptionCount(spec, available) {
-  if (available < requiredCount(spec)) {
-    throw new Error(
-      `Cannot consume from '${spec.place.name}': available=${available}, required=${requiredCount(spec)}`
-    );
-  }
-  switch (spec.type) {
-    case "one":
-      return 1;
-    case "exactly":
-      return spec.count;
-    case "all":
-      return available;
-    case "at-least":
-      return available;
-  }
-}
 
 // src/core/name.ts
 function nameId(value) {
   return value;
 }
 
-// src/core/transition-action.ts
-function passthrough() {
-  return PASSTHROUGH;
-}
-var PASSTHROUGH = async () => {
-};
-function transform(fn) {
-  return async (ctx) => {
-    const result = fn(ctx);
-    for (const outputPlace of ctx.outputPlaces()) {
-      ctx.output(outputPlace, result);
-    }
-  };
-}
-function fork() {
-  return transform((ctx) => {
-    const inputPlaces = ctx.inputPlaces();
-    if (inputPlaces.size !== 1) {
-      throw new Error(`Fork requires exactly 1 input place, found ${inputPlaces.size}`);
-    }
-    const inputPlace = inputPlaces.values().next().value;
-    return ctx.input(inputPlace);
-  });
-}
-function transformFrom(inputPlace, fn) {
-  return transform((ctx) => fn(ctx.input(inputPlace)));
-}
-function transformAsync(fn) {
-  return async (ctx) => {
-    const result = await fn(ctx);
-    for (const outputPlace of ctx.outputPlaces()) {
-      ctx.output(outputPlace, result);
-    }
-  };
-}
-function produce(place2, value) {
-  return async (ctx) => {
-    ctx.output(place2, value);
-  };
-}
-function withTimeout(action, timeoutMs, timeoutPlace2, timeoutValue) {
-  return (ctx) => {
-    return new Promise((resolve2, reject) => {
-      let completed = false;
-      const timer = setTimeout(() => {
-        if (!completed) {
-          completed = true;
-          ctx.output(timeoutPlace2, timeoutValue);
-          resolve2();
-        }
-      }, timeoutMs);
-      action(ctx).then(
-        () => {
-          if (!completed) {
-            completed = true;
-            clearTimeout(timer);
-            resolve2();
-          }
-        },
-        (err) => {
-          if (!completed) {
-            completed = true;
-            clearTimeout(timer);
-            reject(err);
-          }
-        }
-      );
-    });
-  };
-}
-
 // src/core/token-output.ts
 var TokenOutput = class {
   _entries = [];
@@ -1063,7 +951,7 @@ function rewriteTransition(t, prefix, placeRemap) {
 function substitutePlaces(t, remap) {
   return rebuildWithName(t, t.name, remap);
 }
-function rebuildWithName(t, name, remap) {
+function rebuildWithName(t, name, remap, normalizeInputs) {
   const builder = Transition.builder(name).timing(t.timing).priority(t.priority).action(t.action);
   const alias = buildPlaceAlias(t, remap);
   if (alias.size > 0) {
@@ -1074,7 +962,7 @@ function rebuildWithName(t, name, remap) {
     for (let i = 0; i < t.inputSpecs.length; i++) {
       rewrittenInputs[i] = rewriteIn(t.inputSpecs[i], remap);
     }
-    builder.inputs(...rewrittenInputs);
+    builder.inputs(...normalizeInputs !== void 0 ? normalizeInputs(rewrittenInputs) : rewrittenInputs);
   }
   if (t.outputSpec !== null) {
     builder.outputs(rewriteOut(t.outputSpec, remap));
@@ -1134,13 +1022,13 @@ var EMPTY_ALIAS2 = /* @__PURE__ */ new Map();
 function rewriteIn(spec, remap) {
   switch (spec.type) {
     case "one":
-      return one(resolve(spec.place, remap), spec.guard);
+      return one(resolve(spec.place, remap));
     case "exactly":
-      return exactly(spec.count, resolve(spec.place, remap), spec.guard);
+      return exactly(spec.count, resolve(spec.place, remap));
     case "all":
-      return all(resolve(spec.place, remap), spec.guard);
+      return all(resolve(spec.place, remap));
     case "at-least":
-      return atLeast(spec.minimum, resolve(spec.place, remap), spec.guard);
+      return atLeast(spec.minimum, resolve(spec.place, remap));
   }
 }
 function rewriteOut(out, remap) {
@@ -1195,7 +1083,11 @@ function mergeTransitions(caller, instance, mergedName) {
   if (mergedAction !== void 0) {
     builder.action(mergedAction);
   }
-  const unionedInputs = unionArcs(caller.inputSpecs, instance.inputSpecs, keyOfIn);
+  rejectCrossSideKindConflicts(caller, instance, mergedName);
+  const unionedInputs = normalizeInputArcs(
+    [...caller.inputSpecs, ...instance.inputSpecs],
+    () => `Channel composition '${mergedName}'`
+  );
   if (unionedInputs.length > 0) {
     builder.inputs(...unionedInputs);
   }
@@ -1326,48 +1218,128 @@ function describeTiming(t) {
       return `Exact(atMs=${t.atMs})`;
   }
 }
-var PASSTHROUGH_REF = passthrough();
-function isPassthrough(action) {
-  return action === PASSTHROUGH_REF;
+function keyOfInhibitor(arc) {
+  return `inh|${arc.place.name}`;
 }
-function keyOfIn(arc) {
+function keyOfRead(arc) {
+  return `read|${arc.place.name}`;
+}
+function keyOfReset(arc) {
+  return `reset|${arc.place.name}`;
+}
+function normalizeInputArcs(arcs, seamOf) {
+  if (arcs.length < 2) return arcs;
+  const byPlace = /* @__PURE__ */ new Map();
+  let collided = false;
+  for (let i2 = 0; i2 < arcs.length; i2++) {
+    const arc = arcs[i2];
+    const name = arc.place.name;
+    const prior = byPlace.get(name);
+    if (prior === void 0) {
+      byPlace.set(name, arc);
+    } else {
+      collided = true;
+      byPlace.set(name, mergeInPair(prior, arc, seamOf(name)));
+    }
+  }
+  if (!collided) return arcs;
+  const result = new Array(byPlace.size);
+  let i = 0;
+  for (const arc of byPlace.values()) result[i++] = arc;
+  return result;
+}
+function mergeInPair(a, b, seam) {
+  if (a.type === "all" && b.type === "all") return a;
+  if (a.type === "at-least" && b.type === "at-least") {
+    return a.minimum >= b.minimum ? a : b;
+  }
+  const countA = summableCount(a);
+  const countB = summableCount(b);
+  if (countA !== -1 && countB !== -1) {
+    return exactly(countA + countB, a.place);
+  }
+  throw new Error(
+    `${seam}: input arcs ${describeIn(a)} and ${describeIn(b)} collide on place '${a.place.name}' and have no additive merge (MOD-021 rule (c)). Use a single arc with exactly(n) / atLeast(n).`
+  );
+}
+function summableCount(arc) {
+  switch (arc.type) {
+    case "one":
+      return 1;
+    case "exactly":
+      return arc.count;
+    default:
+      return -1;
+  }
+}
+function describeIn(arc) {
   switch (arc.type) {
     case "one":
-      return arc.guard === void 0 ? `one|${arc.place.name}` : `one|${arc.place.name}|g:${guardKey(arc.guard)}`;
+      return "one()";
     case "exactly":
-      return arc.guard === void 0 ? `exactly|${arc.place.name}|${arc.count}` : `exactly|${arc.place.name}|${arc.count}|g:${guardKey(arc.guard)}`;
+      return `exactly(${arc.count})`;
     case "all":
-      return arc.guard === void 0 ? `all|${arc.place.name}` : `all|${arc.place.name}|g:${guardKey(arc.guard)}`;
+      return "all()";
     case "at-least":
-      return arc.guard === void 0 ? `atLeast|${arc.place.name}|${arc.minimum}` : `atLeast|${arc.place.name}|${arc.minimum}|g:${guardKey(arc.guard)}`;
+      return `atLeast(${arc.minimum})`;
   }
 }
-function keyOfInhibitor(arc) {
-  return `inh|${arc.place.name}`;
+function rejectCrossSideKindConflicts(caller, instance, mergedName) {
+  const callerKinds = arcKindsByPlace(caller);
+  if (callerKinds.size === 0) return;
+  for (const [place2, instanceSet] of arcKindsByPlace(instance)) {
+    const callerSet = callerKinds.get(place2);
+    if (callerSet !== void 0 && !sameKindSet(callerSet, instanceSet)) {
+      throw new Error(
+        `Channel composition '${mergedName}': conflicting arc kinds on place '${place2}' \u2014 caller-side ${describeKinds(callerSet)} vs instance-side ${describeKinds(instanceSet)}. Different arc types on one place cannot be merged (MOD-021 rule (d)). Resolve explicitly.`
+      );
+    }
+  }
 }
-function keyOfRead(arc) {
-  return `read|${arc.place.name}`;
+function arcKindsByPlace(t) {
+  const kinds = /* @__PURE__ */ new Map();
+  const add = (name, kind) => {
+    let set = kinds.get(name);
+    if (set === void 0) {
+      set = /* @__PURE__ */ new Set();
+      kinds.set(name, set);
+    }
+    set.add(kind);
+  };
+  for (const s of t.inputSpecs) add(s.place.name, "input");
+  for (const a of t.inhibitors) add(a.place.name, "inhibitor");
+  for (const a of t.reads) add(a.place.name, "read");
+  for (const a of t.resets) add(a.place.name, "reset");
+  return kinds;
 }
-function keyOfReset(arc) {
-  return `reset|${arc.place.name}`;
+function describeKinds(kinds) {
+  return `[${[...kinds].sort().join(", ")}]`;
 }
-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 sameKindSet(a, b) {
+  if (a.size !== b.size) return false;
+  for (const k of a) if (!b.has(k)) return false;
+  return true;
 }
-function applyFusion(transitions, fusionMap) {
+function applyFusion(transitions, fusionMap, seamOf) {
+  const normalizeInputs = (inputs) => normalizeInputArcs(inputs, seamOf);
   const rewritten = /* @__PURE__ */ new Set();
   for (const t of transitions) {
-    rewritten.add(substitutePlaces(t, fusionMap));
+    rewritten.add(rebuildWithName(
+      t,
+      t.name,
+      fusionMap,
+      fusionTouchesInputs(t, fusionMap) ? normalizeInputs : void 0
+    ));
   }
   return rewritten;
 }
+function fusionTouchesInputs(t, fusionMap) {
+  if (fusionMap.size === 0) return false;
+  for (let i = 0; i < t.inputSpecs.length; i++) {
+    if (fusionMap.has(t.inputSpecs[i].place.name)) return true;
+  }
+  return false;
+}
 
 // src/verification/verification-harness.ts
 function buildVerificationResult(syntheticNet, perProperty) {
@@ -1572,6 +1544,7 @@ var SubnetDef = class _SubnetDef {
       }
     }
     const syntheticNet = PetriNet.builder("verify_" + this.name).compose(sut, portMappings).build();
+    requireOutputProducingActions(syntheticNet);
     const perProperty = /* @__PURE__ */ new Map();
     for (const property of properties) {
       const verifier = SmtVerifier.forNet(syntheticNet).property(property);
@@ -1923,6 +1896,10 @@ var PetriNet = class _PetriNet {
   }
   /**
    * Creates a new PetriNet with actions bound via a resolver function.
+   *
+   * The resolver is called once per transition with its name. Returning `null`
+   * defers that transition — it keeps whatever action it already carries — which
+   * is what makes staged binding (**MOD-024** AC7) work.
    */
   bindActionsWithResolver(actionResolver) {
     const boundTransitions = /* @__PURE__ */ new Set();
@@ -2258,7 +2235,8 @@ var PetriNetBuilder = 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
@@ -2344,7 +2322,10 @@ var PetriNetBuilder = class _PetriNetBuilder {
         nonCanonicalNames.add(nc.name);
       }
     }
-    const rewrittenTransitions = applyFusion(this._transitions, fusionMap);
+    const rewrittenTransitions = applyFusion(this._transitions, fusionMap, (canonicalName) => {
+      const owner = ownership.get(canonicalName);
+      return `Fusion set '${owner !== void 0 ? owner.name : canonicalName}'`;
+    });
     const rebuiltPlaces = /* @__PURE__ */ new Set();
     for (const p of this._places) {
       if (!nonCanonicalNames.has(p.name)) {
@@ -2445,21 +2426,21 @@ var Marking = class _Marking {
     return result;
   }
   /**
-   * Removes and returns the first token whose value satisfies the guard predicate.
+   * Removes and returns the first token whose value satisfies the predicate.
    *
-   * Performs a linear scan of the place's FIFO queue. If no guard is provided,
-   * behaves like `removeFirst()`. If a guard is provided, skips non-matching
+   * Performs a linear scan of the place's FIFO queue. If no predicate is
+   * provided, behaves like `removeFirst()`. Otherwise skips non-matching
    * tokens and splices the first match out of the queue (O(n) worst case).
    */
   removeFirstMatching(spec) {
     const queue = this.tokens.get(spec.place.name);
     if (!queue || queue.length === 0) return null;
-    if (!spec.guard) {
+    if (!spec.predicate) {
       return queue.shift();
     }
     for (let i = 0; i < queue.length; i++) {
       const token = queue[i];
-      if (spec.guard(token.value)) {
+      if (spec.predicate(token.value)) {
         if (i === 0) queue.shift();
         else queue.splice(i, 1);
         return token;
@@ -2468,27 +2449,27 @@ var Marking = class _Marking {
     return null;
   }
   // ======================== Token Inspection ========================
-  /** Check if any token matches a guard predicate. */
+  /** Check if any token satisfies the predicate. */
   hasMatchingToken(spec) {
     const queue = this.tokens.get(spec.place.name);
     if (!queue || queue.length === 0) return false;
-    if (!spec.guard) return true;
-    return queue.some((t) => spec.guard(t.value));
+    if (!spec.predicate) return true;
+    return queue.some((t) => spec.predicate(t.value));
   }
   /**
-   * Counts tokens in a place whose values satisfy the guard predicate.
+   * Counts tokens in a place whose values satisfy the predicate.
    *
-   * If no guard is provided, returns the total token count (O(1)).
-   * With a guard, performs a linear scan over all tokens (O(n)).
-   * Used by the executor for enablement checks on guarded `all`/`at-least` inputs.
+   * If no predicate is provided, returns the total token count (O(1)).
+   * With a predicate, performs a linear scan over all tokens (O(n)).
+   * Used by the executor to size a ν-net correlated `all`/`at-least` consume.
    */
   countMatching(spec) {
     const queue = this.tokens.get(spec.place.name);
     if (!queue || queue.length === 0) return 0;
-    if (!spec.guard) return queue.length;
+    if (!spec.predicate) return queue.length;
     let count = 0;
     for (const t of queue) {
-      if (spec.guard(t.value)) count++;
+      if (spec.predicate(t.value)) count++;
     }
     return count;
   }
@@ -2547,15 +2528,15 @@ var CompiledNet = class _CompiledNet {
   _placeToTransitions;
   // Consumption place IDs per transition (input + reset places)
   _consumptionPlaceIds;
-  // Cardinality and guard flags
+  // Cardinality flags
   _cardinalityChecks;
-  _hasGuards;
   // ν-net join flag: the transition carries a MatchSpec (NU-020). Precomputed
   // so the hot enablement loop can skip the match check on non-ν transitions
-  // (zero-cost gating), mirroring `_hasGuards`.
+  // (zero-cost gating).
   _hasMatch;
   constructor(net) {
     this.net = net;
+    requireOutputProducingActions(net);
     const allPlacesSet = /* @__PURE__ */ new Map();
     for (const t of net.transitions) {
       for (const spec of t.inputSpecs) allPlacesSet.set(spec.place.name, spec.place);
@@ -2584,7 +2565,6 @@ var CompiledNet = class _CompiledNet {
     this._inhibitorMask = new Array(this.transitionCount);
     this._consumptionPlaceIds = new Array(this.transitionCount);
     this._cardinalityChecks = new Array(this.transitionCount).fill(null);
-    this._hasGuards = new Array(this.transitionCount).fill(false);
     this._hasMatch = new Array(this.transitionCount).fill(false);
     const placeToTransitionsList = new Array(this.placeCount);
     for (let i = 0; i < this.placeCount; i++) {
@@ -2596,16 +2576,20 @@ var CompiledNet = class _CompiledNet {
       const needs = new Uint32Array(this.wordCount);
       const inhibitors = new Uint32Array(this.wordCount);
       let needsCardinality = false;
+      const seenInputPlaces = /* @__PURE__ */ new Set();
       for (const inSpec of t.inputSpecs) {
+        if (seenInputPlaces.has(inSpec.place.name)) {
+          throw new Error(
+            `Transition '${t.name}' declares two input arcs on place '${inSpec.place.name}'. Duplicate input places have no coherent consumption semantics and are rejected at compile time (CORE-030). Use a single arc with exactly(n) / atLeast(n) instead.`
+          );
+        }
+        seenInputPlaces.add(inSpec.place.name);
         const pid = this._placeIndex.get(inSpec.place.name);
         setBit(needs, pid);
         placeToTransitionsList[pid].push(tid);
         if (inSpec.type !== "one") {
           needsCardinality = true;
         }
-        if (inSpec.guard) {
-          this._hasGuards[tid] = true;
-        }
       }
       if (needsCardinality) {
         const pids = [];
@@ -2657,6 +2641,14 @@ var CompiledNet = class _CompiledNet {
     if (id === void 0) throw new Error(`Unknown place: ${place2.name}`);
     return id;
   }
+  /**
+   * Non-throwing variant of {@link placeId}: `undefined` when the compiled net
+   * does not know the place. Lets callers retain tokens on undeclared places
+   * (CORE-072) instead of rejecting or dropping them.
+   */
+  tryPlaceId(place2) {
+    return this._placeIndex.get(place2.name);
+  }
   transitionId(t) {
     const id = this._transitionIndex.get(t);
     if (id === void 0) throw new Error(`Unknown transition: ${t.name}`);
@@ -2671,9 +2663,6 @@ var CompiledNet = class _CompiledNet {
   cardinalityCheck(tid) {
     return this._cardinalityChecks[tid];
   }
-  hasGuards(tid) {
-    return this._hasGuards[tid];
-  }
   hasMatch(tid) {
     return this._hasMatch[tid];
   }
@@ -2685,8 +2674,9 @@ var CompiledNet = class _CompiledNet {
    * 2. **Inhibitor check**: verifies no inhibitor places have tokens
    *    via `!intersects(snapshot, inhibitorMask)`.
    *
-   * This is a necessary but not sufficient condition — cardinality and guard checks
-   * are performed separately by the executor for transitions that pass this fast path.
+   * This is a necessary but not sufficient condition — cardinality and ν-net match
+   * checks are performed separately by the executor for transitions that pass this
+   * fast path.
    */
   canEnableBitmap(tid, markingSnapshot) {
     if (!containsAll(markingSnapshot, this._needsMask[tid])) return false;
@@ -2811,10 +2801,9 @@ function selectMatchName(perPlace, requireds) {
   }
   return bestName;
 }
-function buildNameIndex(tokens, key, guard) {
+function buildNameIndex(tokens, key) {
   const index = /* @__PURE__ */ new Map();
   for (const token of tokens) {
-    if (guard && !guard(token.value)) continue;
     const name = key(token.value);
     if (name === void 0 || name === null) continue;
     const ts = token.createdAt;
@@ -2844,17 +2833,11 @@ function findBinding(t, getTokens) {
   const perPlace = [];
   const requireds = [];
   for (const k of ms.keys) {
-    perPlace.push(buildNameIndex(getTokens(k.place), k.key, guardFor(t, k.place.name)));
+    perPlace.push(buildNameIndex(getTokens(k.place), k.key));
     requireds.push(requiredFor(t, k.place.name));
   }
   return selectMatchName(perPlace, requireds);
 }
-function guardFor(t, placeName) {
-  for (const inSpec of t.inputSpecs) {
-    if (inSpec.place.name === placeName) return inSpec.guard;
-  }
-  return void 0;
-}
 var MinQueue = class {
   inStack = [];
   inMin = [];
@@ -2950,7 +2933,7 @@ var IncrementalMatcher = class {
   heaped = false;
   heap = new ReadyHeap();
   ready = /* @__PURE__ */ new Map();
-  /** Add one (already guard-passing) token carrying `name` at `createdAt` to input `i`. */
+  /** Add one token carrying `name` at `createdAt` to input `i`. */
   add(i, name, createdAt) {
     let q = this.ts[i].get(name);
     if (!q) {
@@ -3112,9 +3095,7 @@ function validateOutSpec(tName, spec, producedPlaceNames) {
         );
       }
       if (satisfied.length > 1) {
-        throw new OutViolationError(
-          `'${tName}': XOR violation - multiple branches produced`
-        );
+        return resolveXorAmbiguity(tName, satisfied);
       }
       return satisfied[0];
     }
@@ -3122,14 +3103,26 @@ function validateOutSpec(tName, spec, producedPlaceNames) {
       return validateOutSpec(tName, spec.child, producedPlaceNames);
   }
 }
+function resolveXorAmbiguity(tName, satisfied) {
+  const subsuming = satisfied.filter(
+    (candidate) => satisfied.every(
+      (other) => other === candidate || [...other].every((p) => candidate.has(p))
+    )
+  );
+  if (subsuming.length === 1) return subsuming[0];
+  throw new OutViolationError(
+    `'${tName}': XOR violation - multiple branches produced`
+  );
+}
 function produceTimeoutOutput(context, timeoutChild) {
   switch (timeoutChild.type) {
     case "place":
       context.outputToHarvest(timeoutChild.place, null);
       break;
     case "forward-input": {
-      const value = context.input(timeoutChild.from);
-      context.outputToHarvest(timeoutChild.to, value);
+      for (const value of context.inputs(timeoutChild.from)) {
+        context.outputToHarvest(timeoutChild.to, value);
+      }
       break;
     }
     case "and":
@@ -3170,7 +3163,7 @@ var BitmapNetExecutor = class {
   allSamePriority;
   eventStoreEnabled;
   // Bitmaps (Uint32Array, direct writes)
-  markedPlaces;
+  markingBitmap;
   dirtySet;
   markingSnapBuffer;
   dirtySnapBuffer;
@@ -3199,6 +3192,11 @@ var BitmapNetExecutor = class {
   readyBuffer = [];
   // Pending reset places for clock-restart detection
   pendingResetPlaces = /* @__PURE__ */ new Set();
+  /**
+   * Undeclared place names already reported (CORE-072 AC4). Keyed by name — TS
+   * Place identity is name-based — so a hot loop warns once, not per token.
+   */
+  warnedUnknownPlaces = /* @__PURE__ */ new Set();
   transitionInputPlaceNames;
   running = false;
   draining = false;
@@ -3218,7 +3216,7 @@ var BitmapNetExecutor = class {
     }
     this.startMs = performance.now();
     const wordCount = this.compiled.wordCount;
-    this.markedPlaces = new Uint32Array(wordCount);
+    this.markingBitmap = new Uint32Array(wordCount);
     this.markingSnapBuffer = new Uint32Array(wordCount);
     this.firingSnapBuffer = new Uint32Array(wordCount);
     const dirtyWords = this.compiled.transitionCount + BIT_MASK >>> WORD_SHIFT;
@@ -3254,6 +3252,11 @@ var BitmapNetExecutor = class {
       for (const spec of t.inputSpecs) names.add(spec.place.name);
       this.transitionInputPlaceNames.set(t, names);
     }
+    for (const [place2, tokens] of initialTokens) {
+      if (tokens.length > 0 && this.compiled.tryPlaceId(place2) === void 0) {
+        this.warnUnknownPlace(place2, "");
+      }
+    }
     this.initMatchCaches();
   }
   /**
@@ -3312,9 +3315,7 @@ var BitmapNetExecutor = class {
       for (let keyIdx = 0; keyIdx < ms.keys.length; keyIdx++) {
         const mk = ms.keys[keyIdx];
         const pid = compiled.placeId(mk.place);
-        const guard = t.inputSpecs.find((s) => s.place.name === mk.place.name)?.guard;
         for (const token of this.marking.peekTokens(mk.place)) {
-          if (guard && !guard(token.value)) continue;
           const name = mk.key(token.value);
           if (name !== void 0 && name !== null) matcher.add(keyIdx, name, token.createdAt);
         }
@@ -3333,8 +3334,6 @@ var BitmapNetExecutor = class {
       if (cache == null) continue;
       const t = compiled.transition(tid);
       const mk = t.matchSpec.keys[keyIdx];
-      const guard = t.inputSpecs.find((s) => s.place.name === mk.place.name)?.guard;
-      if (guard && !guard(token.value)) continue;
       const name = mk.key(token.value);
       if (name !== void 0 && name !== null) cache.add(keyIdx, name, token.createdAt);
     }
@@ -3362,7 +3361,7 @@ var BitmapNetExecutor = class {
       netName: this.compiled.net.name,
       executionId: this.executionId()
     });
-    this.initializeMarkedBitmap();
+    this.initializeMarkingBitmap();
     this.markAllDirty();
     this.emitEvent({
       type: "marking-snapshot",
@@ -3417,11 +3416,11 @@ var BitmapNetExecutor = class {
     return this.inject(envPlace, tokenOf(value));
   }
   // ======================== Initialize ========================
-  initializeMarkedBitmap() {
+  initializeMarkingBitmap() {
     for (let pid = 0; pid < this.compiled.placeCount; pid++) {
       const place2 = this.compiled.place(pid);
       if (this.marking.hasTokens(place2)) {
-        setBit(this.markedPlaces, pid);
+        setBit(this.markingBitmap, pid);
       }
     }
   }
@@ -3449,7 +3448,7 @@ var BitmapNetExecutor = class {
   updateDirtyTransitions() {
     const nowMs = performance.now();
     const markingSnap = this.markingSnapBuffer;
-    markingSnap.set(this.markedPlaces);
+    markingSnap.set(this.markingBitmap);
     const dirtyWords = this.dirtySet.length;
     const dirtySnap = this.dirtySnapBuffer;
     for (let w = 0; w < dirtyWords; w++) {
@@ -3534,17 +3533,6 @@ var BitmapNetExecutor = class {
         if (this.marking.tokenCount(place2) < required) return false;
       }
     }
-    if (this.compiled.hasGuards(tid)) {
-      const t = this.compiled.transition(tid);
-      const cache = this.matchCaches[tid];
-      const ms = t.matchSpec;
-      for (const spec of t.inputSpecs) {
-        if (!spec.guard) continue;
-        if (cache != null && ms && keyForPlace(ms, spec.place.name) !== void 0) continue;
-        const requiredCount2 = spec.type === "one" ? 1 : spec.type === "exactly" ? spec.count : spec.type === "at-least" ? spec.minimum : 1;
-        if (this.marking.countMatching(spec) < requiredCount2) return false;
-      }
-    }
     if (this.compiled.hasMatch(tid)) {
       const cache = this.matchCaches[tid];
       const noBinding = cache != null ? cache.best() === null : findBinding(this.compiled.transition(tid), (p) => this.marking.peekTokens(p)) === null;
@@ -3575,7 +3563,7 @@ var BitmapNetExecutor = class {
    * Fast path for nets where all transitions are immediate and same priority.
    * Skips timing checks, sorting, and snapshot buffer — just scan and fire.
    *
-   * Uses live `markedPlaces` instead of a snapshot. Safe because
+   * Uses live `markingBitmap` instead of a snapshot. Safe because
    * `updateBitmapAfterConsumption()` synchronously updates the bitmap before the next
    * iteration. For equal-priority immediate transitions, tid scan order satisfies
    * FIFO-by-enablement-time (all enabled in the same cycle).
@@ -3583,7 +3571,7 @@ var BitmapNetExecutor = class {
   fireReadyImmediate() {
     for (let tid = 0; tid < this.compiled.transitionCount; tid++) {
       if (!this.enabledFlags[tid] || this.inFlightFlags[tid]) continue;
-      if (this.canEnable(tid, this.markedPlaces)) {
+      if (this.canEnable(tid, this.markingBitmap)) {
         this.fireTransitionContained(tid);
       } else {
         this.enabledFlags[tid] = 0;
@@ -3612,12 +3600,12 @@ var BitmapNetExecutor = class {
       return a.enabledAtMs - b.enabledAtMs;
     });
     const freshSnap = this.firingSnapBuffer;
-    freshSnap.set(this.markedPlaces);
+    freshSnap.set(this.markingBitmap);
     for (const entry of ready) {
       const { tid } = entry;
       if (this.enabledFlags[tid] && this.canEnable(tid, freshSnap)) {
         this.fireTransitionContained(tid);
-        freshSnap.set(this.markedPlaces);
+        freshSnap.set(this.markingBitmap);
       } else {
         this.enabledFlags[tid] = 0;
         this.enabledTransitionCount--;
@@ -3633,7 +3621,7 @@ var BitmapNetExecutor = class {
    * EventStore.append on a token-removed or transition-started emit, or an error thrown while
    * consuming the matched tokens — unwinds out of the orchestrator loop and kills the executor.
    * The transition is instead failed and marked dirty for re-evaluation, the same treatment an
-   * asynchronously-reported failure gets. Enablement-phase throws (a guard or key function that
+   * asynchronously-reported failure gets. Enablement-phase throws (a key function that
    * throws inside canEnable, before the firing) run outside this boundary and are not contained
    * here.
    *
@@ -3684,10 +3672,9 @@ var BitmapNetExecutor = class {
       const keyFn = ms ? keyForPlace(ms, inSpec.place.name) : void 0;
       let spec;
       if (keyFn && chosen !== null) {
-        const baseGuard = inSpec.guard;
         spec = {
           place: inSpec.place,
-          guard: (v) => (baseGuard ? baseGuard(v) : true) && keyFn(v) === chosen
+          predicate: (v) => keyFn(v) === chosen
         };
       } else {
         spec = inSpec;
@@ -3702,11 +3689,11 @@ var BitmapNetExecutor = class {
           break;
         case "all":
         case "at-least":
-          toConsume = spec.guard ? this.marking.countMatching(spec) : this.marking.tokenCount(inSpec.place);
+          toConsume = spec.predicate ? this.marking.countMatching(spec) : this.marking.tokenCount(inSpec.place);
           break;
       }
       for (let i = 0; i < toConsume; i++) {
-        const token = spec.guard ? this.marking.removeFirstMatching(spec) : this.marking.removeFirst(inSpec.place);
+        const token = spec.predicate ? this.marking.removeFirstMatching(spec) : this.marking.removeFirst(inSpec.place);
         if (token === null) break;
         consumed.push(token);
         inputs.add(inSpec.place, token);
@@ -3830,7 +3817,7 @@ var BitmapNetExecutor = class {
     for (const pid of pids) {
       const place2 = this.compiled.place(pid);
       if (!this.marking.hasTokens(place2)) {
-        clearBit(this.markedPlaces, pid);
+        clearBit(this.markingBitmap, pid);
       }
       this.markDirty(pid);
     }
@@ -3872,12 +3859,16 @@ var BitmapNetExecutor = class {
         }
         const produced = [];
         for (const entry of outputs.entries()) {
-          const pid = this.compiled.placeId(entry.place);
-          this.cacheAddToken(pid, entry.token);
+          const pid = this.compiled.tryPlaceId(entry.place);
           this.marking.addToken(entry.place, entry.token);
           produced.push(entry.token);
-          setBit(this.markedPlaces, pid);
-          this.markDirty(pid);
+          if (pid !== void 0) {
+            this.cacheAddToken(pid, entry.token);
+            setBit(this.markingBitmap, pid);
+            this.markDirty(pid);
+          } else {
+            this.warnUnknownPlace(entry.place, t.name);
+          }
           this.emitEvent({
             type: "token-added",
             timestamp: Date.now(),
@@ -3916,11 +3907,15 @@ var BitmapNetExecutor = class {
     for (let i = 0; i < len; i++) {
       const event = this.externalQueue[i];
       try {
-        const pid = this.compiled.placeId(event.place);
-        this.cacheAddToken(pid, event.token);
+        const pid = this.compiled.tryPlaceId(event.place);
         this.marking.addToken(event.place, event.token);
-        setBit(this.markedPlaces, pid);
-        this.markDirty(pid);
+        if (pid !== void 0) {
+          this.cacheAddToken(pid, event.token);
+          setBit(this.markingBitmap, pid);
+          this.markDirty(pid);
+        } else {
+          this.warnUnknownPlace(event.place, "");
+        }
         this.emitEvent({
           type: "token-added",
           timestamp: Date.now(),
@@ -4051,6 +4046,25 @@ var BitmapNetExecutor = class {
     this.wakeUp();
   }
   // ======================== Event Emission ========================
+  /**
+   * Reports an undeclared place once (CORE-072 AC4, emitted as the EVT-013
+   * log-message event). `transitionName` is the producer, empty at the
+   * initial-marking and injection seams. Retention never depends on this.
+   */
+  warnUnknownPlace(place2, transitionName) {
+    if (this.warnedUnknownPlaces.has(place2.name)) return;
+    this.warnedUnknownPlaces.add(place2.name);
+    this.emitEvent({
+      type: "log-message",
+      timestamp: Date.now(),
+      transitionName,
+      logger: "libpetri.runtime",
+      level: "WARN",
+      message: `unknown place '${place2.name}': tokens are retained in the marking but inert (the net declares no arc on it)`,
+      error: null,
+      errorMessage: null
+    });
+  }
   emitEvent(event) {
     if (this.eventStoreEnabled) {
       try {
@@ -4088,6 +4102,12 @@ var PrecompiledNet = class _PrecompiledNet {
   // ==================== Opcode Programs ====================
   /** Per-transition consume opcode sequences. */
   consumeOps;
+  /**
+   * Per-transition index into {@link consumeOps} where the RESET tail begins; the
+   * executor peeks read arcs at this boundary so reads observe the post-input,
+   * pre-reset marking (EXEC-013 AC4).
+   */
+  resetOpsStart;
   /** Per-transition read-arc place IDs. */
   readOps;
   // ==================== Enablement Masks ====================
@@ -4126,11 +4146,10 @@ var PrecompiledNet = class _PrecompiledNet {
   // ==================== Reverse Index ====================
   placeToTransitions;
   consumptionPlaceIds;
-  // ==================== Cardinality & Guards ====================
+  // ==================== Cardinality ====================
   cardinalityChecks;
-  hasGuards;
   // ν-net join flag (NU-020): gates the match-binding check off the hot
-  // enablement path for non-ν transitions, mirroring `hasGuards`.
+  // enablement path for non-ν transitions.
   hasMatch;
   // ==================== Global Flags ====================
   allImmediate;
@@ -4207,9 +4226,12 @@ var PrecompiledNet = class _PrecompiledNet {
     this.inhibitorSparseMasks = inhibitorSparseMasks;
     const consumeOps = new Array(tc);
     const readOps = new Array(tc);
+    this.resetOpsStart = new Uint32Array(tc);
     for (let tid = 0; tid < tc; tid++) {
       const t = compiled.transition(tid);
-      consumeOps[tid] = compileConsumeProgram(t, compiled);
+      const program = compileConsumeProgram(t, compiled);
+      consumeOps[tid] = program.ops;
+      this.resetOpsStart[tid] = program.resetOpsStart;
       readOps[tid] = compileReadProgram(t, compiled);
     }
     this.consumeOps = consumeOps;
@@ -4225,15 +4247,12 @@ var PrecompiledNet = class _PrecompiledNet {
     this.placeToTransitions = placeToTransitions;
     this.consumptionPlaceIds = consumptionPlaceIds;
     const cardinalityChecks = new Array(tc);
-    const hasGuards = new Array(tc);
     const hasMatch = new Array(tc);
     for (let tid = 0; tid < tc; tid++) {
       cardinalityChecks[tid] = compiled.cardinalityCheck(tid);
-      hasGuards[tid] = compiled.hasGuards(tid);
       hasMatch[tid] = compiled.hasMatch(tid);
     }
     this.cardinalityChecks = cardinalityChecks;
-    this.hasGuards = hasGuards;
     this.hasMatch = hasMatch;
     this.earliestMs = new Float64Array(tc);
     this.latestMs = new Float64Array(tc);
@@ -4396,11 +4415,12 @@ function compileConsumeProgram(t, compiled) {
         break;
     }
   }
+  const resetOpsStart = ops.length;
   for (const arc of t.resets) {
     const pid = compiled.placeId(arc.place);
     ops.push(RESET, pid);
   }
-  return ops;
+  return { ops, resetOpsStart };
 }
 function compileReadProgram(t, compiled) {
   const pids = [];
@@ -4430,6 +4450,14 @@ var PrecompiledNetExecutor = class {
   // ==================== Token Storage ====================
   /** Per-place token arrays, indexed by pid. */
   tokenQueues;
+  /**
+   * Tokens on places the compiled net does not know (CORE-072 AC3). Retained —
+   * never dropped — and merged into the materialized marking, matching the
+   * BitmapNetExecutor reference, whose Marking keeps them naturally. Keyed by
+   * place NAME (TS Place identity is name-based), carrying the Place so
+   * materializing a Marking has one to hand.
+   */
+  unknownPlaceTokens = /* @__PURE__ */ new Map();
   /** Monotonic source for ν-name minting (ctx.freshName(), NU-010). */
   freshNameCounter = 0;
   /**
@@ -4515,7 +4543,13 @@ var PrecompiledNetExecutor = class {
       this.tokenQueues[pid] = [];
     }
     for (const [place2, tokens] of initialTokens) {
-      const pid = prog.compiled.placeId(place2);
+      const pid = prog.compiled.tryPlaceId(place2);
+      if (pid === void 0) {
+        for (let i = 0; i < tokens.length; i++) {
+          this.retainUnknownToken(place2, tokens[i], "");
+        }
+        continue;
+      }
       const q = this.tokenQueues[pid];
       for (const token of tokens) {
         q.push(token);
@@ -4598,9 +4632,7 @@ var PrecompiledNetExecutor = class {
       for (let keyIdx = 0; keyIdx < ms.keys.length; keyIdx++) {
         const mk = ms.keys[keyIdx];
         const pid = prog.compiled.placeId(mk.place);
-        const guard = t.inputSpecs.find((s) => s.place.name === mk.place.name)?.guard;
         for (const token of this.tokenQueues[pid]) {
-          if (guard && !guard(token.value)) continue;
           const name = mk.key(token.value);
           if (name !== void 0 && name !== null) matcher.add(keyIdx, name, token.createdAt);
         }
@@ -4619,8 +4651,6 @@ var PrecompiledNetExecutor = class {
       if (cache == null) continue;
       const t = prog.compiled.transition(tid);
       const mk = t.matchSpec.keys[keyIdx];
-      const guard = t.inputSpecs.find((s) => s.place.name === mk.place.name)?.guard;
-      if (guard && !guard(token.value)) continue;
       const name = mk.key(token.value);
       if (name !== void 0 && name !== null) cache.add(keyIdx, name, token.createdAt);
     }
@@ -4832,17 +4862,6 @@ var PrecompiledNetExecutor = class {
         if (this.tokenQueues[pid].length < cardCheck.requiredCounts[i]) return false;
       }
     }
-    if (prog.hasGuards[tid]) {
-      const t = prog.compiled.transition(tid);
-      const cache = this.matchCaches[tid];
-      const ms = t.matchSpec;
-      for (const spec of t.inputSpecs) {
-        if (!spec.guard) continue;
-        if (cache != null && ms && keyForPlace(ms, spec.place.name) !== void 0) continue;
-        const required = spec.type === "one" ? 1 : spec.type === "exactly" ? spec.count : spec.type === "at-least" ? spec.minimum : 1;
-        if (this.countMatching(prog.compiled.placeId(spec.place), spec.guard) < required) return false;
-      }
-    }
     if (prog.hasMatch[tid]) {
       const cache = this.matchCaches[tid];
       const noBinding = cache != null ? cache.best() === null : findBinding(prog.compiled.transition(tid), (p) => this.tokenQueues[prog.compiled.placeId(p)]) === null;
@@ -4852,18 +4871,18 @@ var PrecompiledNetExecutor = class {
     }
     return true;
   }
-  countMatching(pid, guard) {
+  countMatching(pid, predicate) {
     const q = this.tokenQueues[pid];
     let matching = 0;
     for (let i = 0; i < q.length; i++) {
-      if (guard(q[i].value)) matching++;
+      if (predicate(q[i].value)) matching++;
     }
     return matching;
   }
-  removeFirstMatching(pid, guard) {
+  removeFirstMatching(pid, predicate) {
     const q = this.tokenQueues[pid];
     for (let i = 0; i < q.length; i++) {
-      if (guard(q[i].value)) {
+      if (predicate(q[i].value)) {
         return i === 0 ? q.shift() : q.splice(i, 1)[0];
       }
     }
@@ -4942,7 +4961,7 @@ var PrecompiledNetExecutor = class {
    * EventStore.append on a token-removed or transition-started emit, or an error thrown while
    * consuming the matched tokens — unwinds out of the orchestrator loop and kills the executor.
    * The transition is instead failed and marked dirty for re-evaluation, the same treatment an
-   * asynchronously-reported failure gets. Enablement-phase throws (a guard or key function that
+   * asynchronously-reported failure gets. Enablement-phase throws (a key function that
    * throws inside canEnable, before the firing) run outside this boundary and are not contained
    * here.
    *
@@ -4950,10 +4969,9 @@ var PrecompiledNetExecutor = class {
    * so a throw inside that window would leave bits asserting tokens that are gone; the
    * recovery re-runs updateBitmapAfterConsumption against the true queue lengths.
    *
-   * Named to avoid colliding with the pre-existing {@link fireTransitionGuarded}
-   * guard-consume helper. Unlike the Java runtime there is no VirtualMachineError/
-   * LinkageError analogue on the JS side, so every throw is contained here — there is
-   * deliberately no fatal-rethrow escape hatch.
+   * Unlike the Java runtime there is no VirtualMachineError/LinkageError analogue on
+   * the JS side, so every throw is contained here — there is deliberately no
+   * fatal-rethrow escape hatch.
    */
   fireTransitionContained(tid) {
     try {
@@ -4995,12 +5013,11 @@ var PrecompiledNetExecutor = class {
     const inputs = new TokenInput();
     if (t.matchSpec) {
       this.fireTransitionMatched(tid, t, inputs, consumed);
-    } else if (prog.hasGuards[tid]) {
-      this.fireTransitionGuarded(tid, t, inputs, consumed);
     } else {
       const ops = prog.consumeOps[tid];
+      const resetOpsStart = prog.resetOpsStart[tid];
       let pc = 0;
-      while (pc < ops.length) {
+      while (pc < resetOpsStart) {
         const opcode = ops[pc++];
         switch (opcode) {
           case CONSUME_ONE: {
@@ -5070,32 +5087,30 @@ var PrecompiledNetExecutor = class {
             }
             break;
           }
-          case RESET: {
-            const pid = ops[pc++];
-            const place2 = prog.places[pid];
-            const tokens = this.tokenQueues[pid].splice(0);
-            this.pendingResetWords[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
-            this.hasPendingResets = true;
-            for (const token of tokens) {
-              consumed.push(token);
-              this.emitEvent({
-                type: "token-removed",
-                timestamp: Date.now(),
-                placeName: place2.name,
-                token
-              });
-            }
-            break;
-          }
+          default:
+            throw new Error(`Unknown opcode: ${opcode}`);
         }
       }
-    }
-    const readPids = prog.readOps[tid];
-    for (let i = 0; i < readPids.length; i++) {
-      const pid = readPids[i];
-      const q = this.tokenQueues[pid];
-      if (q.length > 0) {
-        inputs.add(prog.places[pid], q[0]);
+      this.peekReadArcs(tid, inputs);
+      while (pc < ops.length) {
+        const opcode = ops[pc++];
+        if (opcode !== RESET) {
+          throw new Error(`Unknown opcode: ${opcode} (expected RESET past resetOpsStart)`);
+        }
+        const pid = ops[pc++];
+        const place2 = prog.places[pid];
+        const tokens = this.tokenQueues[pid].splice(0);
+        this.pendingResetWords[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
+        this.hasPendingResets = true;
+        for (const token of tokens) {
+          consumed.push(token);
+          this.emitEvent({
+            type: "token-removed",
+            timestamp: Date.now(),
+            placeName: place2.name,
+            token
+          });
+        }
       }
     }
     this.updateBitmapAfterConsumption(tid);
@@ -5192,9 +5207,8 @@ var PrecompiledNetExecutor = class {
   }
   /**
    * Consumes the name-matched tokens for a ν-net join (NU-020): correlated
-   * inputs take tokens whose projected name equals the chosen binding (guard
-   * first, then name equality — NU-021); other inputs consume FIFO. Reset arcs
-   * are honoured as on the opcode path. Mirrors {@link fireTransitionGuarded}.
+   * inputs take tokens whose projected name equals the chosen binding (NU-021);
+   * other inputs consume FIFO. Reset arcs are honoured as on the opcode path.
    */
   fireTransitionMatched(tid, t, inputs, consumed) {
     const prog = this.program;
@@ -5205,8 +5219,7 @@ var PrecompiledNetExecutor = class {
     for (const inSpec of t.inputSpecs) {
       const pid = prog.compiled.placeId(inSpec.place);
       const keyFn = keyForPlace(ms, inSpec.place.name);
-      const baseGuard = inSpec.guard;
-      const pred = keyFn && chosen !== null ? (v) => (baseGuard ? baseGuard(v) : true) && keyFn(v) === chosen : baseGuard;
+      const pred = keyFn && chosen !== null ? (v) => keyFn(v) === chosen : void 0;
       let toConsume;
       switch (inSpec.type) {
         case "one":
@@ -5233,6 +5246,7 @@ var PrecompiledNetExecutor = class {
         });
       }
     }
+    this.peekReadArcs(tid, inputs);
     for (const arc of t.resets) {
       const pid = prog.compiled.placeId(arc.place);
       const tokens = this.tokenQueues[pid].splice(0);
@@ -5249,52 +5263,19 @@ var PrecompiledNetExecutor = class {
       }
     }
   }
-  fireTransitionGuarded(_tid, t, inputs, consumed) {
+  /**
+   * Peeks each read-arc place's front token into the context inputs. Called at
+   * the input/reset boundary of a firing (EXEC-013): after input consumption,
+   * before reset draining — so read(p)+reset(p) observes the pre-reset token.
+   */
+  peekReadArcs(tid, inputs) {
     const prog = this.program;
-    for (const inSpec of t.inputSpecs) {
-      const pid = prog.compiled.placeId(inSpec.place);
-      let toConsume;
-      switch (inSpec.type) {
-        case "one":
-          toConsume = 1;
-          break;
-        case "exactly":
-          toConsume = inSpec.count;
-          break;
-        case "all":
-          toConsume = inSpec.guard ? this.countMatching(pid, inSpec.guard) : this.tokenQueues[pid].length;
-          break;
-        case "at-least":
-          toConsume = inSpec.guard ? this.countMatching(pid, inSpec.guard) : this.tokenQueues[pid].length;
-          break;
-      }
-      const guardFn = inSpec.guard;
-      for (let i = 0; i < toConsume; i++) {
-        const token = guardFn ? this.removeFirstMatching(pid, guardFn) : this.tokenQueues[pid].shift() ?? null;
-        if (token === null) break;
-        consumed.push(token);
-        inputs.add(inSpec.place, token);
-        this.emitEvent({
-          type: "token-removed",
-          timestamp: Date.now(),
-          placeName: inSpec.place.name,
-          token
-        });
-      }
-    }
-    for (const arc of t.resets) {
-      const pid = prog.compiled.placeId(arc.place);
-      const tokens = this.tokenQueues[pid].splice(0);
-      this.pendingResetWords[pid >>> WORD_SHIFT] |= 1 << (pid & BIT_MASK);
-      this.hasPendingResets = true;
-      for (const token of tokens) {
-        consumed.push(token);
-        this.emitEvent({
-          type: "token-removed",
-          timestamp: Date.now(),
-          placeName: arc.place.name,
-          token
-        });
+    const readPids = prog.readOps[tid];
+    for (let i = 0; i < readPids.length; i++) {
+      const pid = readPids[i];
+      const q = this.tokenQueues[pid];
+      if (q.length > 0) {
+        inputs.add(prog.places[pid], q[0]);
       }
     }
   }
@@ -5362,12 +5343,8 @@ var PrecompiledNetExecutor = class {
         }
         const produced = [];
         for (const entry of outputs.entries()) {
-          const pid = prog.compiled.placeId(entry.place);
-          this.cacheAddToken(pid, entry.token);
-          this.tokenQueues[pid].push(entry.token);
+          this.produceToken(entry.place, entry.token, t.name);
           produced.push(entry.token);
-          this.setMarkingBit(pid);
-          this.markDirty(pid);
           this.emitEvent({
             type: "token-added",
             timestamp: Date.now(),
@@ -5402,16 +5379,11 @@ var PrecompiledNetExecutor = class {
   processExternalEvents() {
     if (this.externalQueue.length === 0) return;
     if (this.closed) return;
-    const prog = this.program;
     const len = this.externalQueue.length;
     for (let i = 0; i < len; i++) {
       const event = this.externalQueue[i];
       try {
-        const pid = prog.compiled.placeId(event.place);
-        this.cacheAddToken(pid, event.token);
-        this.tokenQueues[pid].push(event.token);
-        this.setMarkingBit(pid);
-        this.markDirty(pid);
+        this.produceToken(event.place, event.token, "");
         this.emitEvent({
           type: "token-added",
           timestamp: Date.now(),
@@ -5425,6 +5397,45 @@ var PrecompiledNetExecutor = class {
     }
     this.externalQueue.length = 0;
   }
+  /**
+   * Adds a produced or injected token: queue/bitmap/dirty for compiled places,
+   * or the retention side map when the program does not know it (CORE-072 AC3).
+   * `transitionName` is the producer, empty at the injection seam.
+   */
+  produceToken(place2, token, transitionName) {
+    const pid = this.program.compiled.tryPlaceId(place2);
+    if (pid === void 0) {
+      this.retainUnknownToken(place2, token, transitionName);
+      return;
+    }
+    this.cacheAddToken(pid, token);
+    this.tokenQueues[pid].push(token);
+    this.setMarkingBit(pid);
+    this.markDirty(pid);
+  }
+  /**
+   * Retains a token on an undeclared place (CORE-072 AC3) and reports the place
+   * once — the first insert is the only one that creates a map entry, so a hot
+   * loop cannot flood (AC4, emitted as the EVT-013 log-message event).
+   */
+  retainUnknownToken(place2, token, transitionName) {
+    const retained = this.unknownPlaceTokens.get(place2.name);
+    if (retained !== void 0) {
+      retained.tokens.push(token);
+      return;
+    }
+    this.unknownPlaceTokens.set(place2.name, { place: place2, tokens: [token] });
+    this.emitEvent({
+      type: "log-message",
+      timestamp: Date.now(),
+      transitionName,
+      logger: "libpetri.runtime",
+      level: "WARN",
+      message: `unknown place '${place2.name}': tokens are retained in the marking but inert (the net declares no arc on it)`,
+      error: null,
+      errorMessage: null
+    });
+  }
   drainPendingExternalEvents() {
     while (this.externalQueue.length > 0) {
       this.externalQueue.shift().resolve(false);
@@ -5508,6 +5519,11 @@ var PrecompiledNetExecutor = class {
         m.addToken(place2, q[i]);
       }
     }
+    for (const { place: place2, tokens } of this.unknownPlaceTokens.values()) {
+      for (const token of tokens) {
+        m.addToken(place2, token);
+      }
+    }
     this.marking = m;
     return m;
   }
@@ -5605,20 +5621,19 @@ export {
   fork,
   forwardInput,
   hasDeadline,
-  hasGuard,
   immediate,
   inMemoryEventStore,
   inhibitorArc,
   inputArc,
   intersects,
   isFailureEvent,
+  isPassthrough,
   isUnit,
   keyForPlace,
   latest,
   matchCorrelates,
   matchKey,
   matchSpec,
-  matchesGuard,
   nameId,
   noopEventStore,
   one,