@greenbytehq/cpn.js 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+# Licensing Termsm
+
+This project is dual-licensed under the MIT License and the GNU General Public License v3.0 (GPLv3). You may choose to use this project under the terms of either license.
+
+* For the MIT License terms, see the `LICENSE-MIT` file.
+* For the GPLv3 License terms, see the `LICENSE-GPL` file.
+
+Please note: If you choose the MIT License, but utilize this project alongside its optional peer dependency `@sosml/interpreter`, your combined work will become subject to the copyleft terms of the GPLv3.
+

package/README.md

@@ -0,0 +1,206 @@
+# @greenByteHQ/cpn-semantics
+
+[![npm](https://img.shields.io/npm/v/@greenByteHQ/cpn-semantics)](https://www.npmjs.com/package/@greenByteHQ/cpn-semantics)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Pure **Coloured Petri Net (CPN)** simulation engine. Computes enabled bindings, fires transitions, and manages multiset token flow — with no UI, no app-specific types, and no side effects.
+
+```bash
+npm install @greenByteHQ/cpn-semantics
+```
+
+---
+
+## Core Types
+
+```ts
+import type { Place, Transition, Arc, NetLike, Marking, Binding, Multiset } from '@greenByteHQ/cpn-semantics';
+```
+
+`NetLike` is intentionally structural and map-based:
+
+```ts
+type NetLike = {
+  places: ReadonlyMap<string, Place>;
+  transitions: ReadonlyMap<string, Transition>;
+  arcs: ReadonlyMap<string, Arc>;
+};
+
+type Marking = ReadonlyMap<string, Multiset>; // placeId -> token multiset
+type Binding = ReadonlyMap<string, string>;   // variable -> serialized token key
+type Multiset = Map<string, number>;          // token key -> count
+```
+
+---
+
+## Multiset Operations
+
+```ts
+import { msAdd, msSubtract, msScale, msContains, msIsEmpty, msEquals, EMPTY_MULTISET } from '@greenByteHQ/cpn-semantics';
+
+const a: Multiset = new Map([['red', 2], ['blue', 1]]);
+const b: Multiset = new Map([['red', 1]]);
+
+msAdd(a, b);         // Map { red→3, blue→1 }
+msSubtract(a, b);    // Map { red→1, blue→1 }
+msScale(a, 2);       // Map { red→4, blue→2 }
+msContains(a, b);    // true
+msIsEmpty(a);        // false
+msEquals(a, a);      // true
+EMPTY_MULTISET;      // Map {}
+```
+
+---
+
+## Simulation API
+
+### `findEnabledBindings`
+
+```ts
+import { findEnabledBindings } from '@greenByteHQ/cpn-semantics';
+
+const bindings: Binding[] = findEnabledBindings(
+  net,         // NetLike
+  marking,     // Marking
+  transitionId, // string
+  evalExpr,    // optional EvalExprFn
+  evalGuard,   // optional EvalGuardFn
+);
+```
+
+Returns all variable bindings under which the given transition is enabled.
+
+### `computeEnabledSet`
+
+```ts
+import { computeEnabledSet } from '@greenByteHQ/cpn-semantics';
+
+const enabled: ReadonlySet<string> =
+  computeEnabledSet(net, marking, evalExpr, evalGuard);
+```
+
+Returns all transition IDs that are currently fireable.
+
+### `fire`
+
+```ts
+import { fire } from '@greenByteHQ/cpn-semantics';
+
+const newMarking: Marking = await fire(
+  net,               // NetLike
+  marking,           // Marking (immutable — returns new copy)
+  transitionId,      // string
+  binding,           // Binding
+  evalExpr,          // optional EvalExprFn
+  callbacks,         // optional FireCallbacks
+);
+```
+
+Fires the given transition and returns the updated marking.
+
+---
+
+## SML Evaluation
+
+SML expression and guard evaluation defaults to `@sosml/interpreter`.
+`evalExprWithSosml` supports CPN multiset inscriptions such as `1\`x ++ 2\`(x + 1)` by evaluating the SML sub-expressions with SOSML.
+
+```ts
+import { evalExprWithSosml, evalGuardWithSosml } from '@greenByteHQ/cpn-semantics';
+
+await evalExprWithSosml('1`x ++ 2`(x + 1)', 'sml', new Map([['x', '3']]));
+await evalGuardWithSosml('x + 1 = 4', 'sml', new Map([['x', '3']]));
+```
+
+Python or other non-SML languages are still supplied by the host app through `EvalExprFn` and `EvalGuardFn`.
+
+---
+
+## Fire Callbacks
+
+Use callbacks to observe or customize firing. The semantics package does not
+interpret application-specific transition classes or arc extensions; layer those
+behaviors in callbacks.
+
+```ts
+import type { FireCallbacks } from '@greenByteHQ/cpn-semantics';
+
+const callbacks: FireCallbacks = {
+  beforeFire: ({ transition, binding, marking, net }) => {
+    // called before input tokens are consumed
+  },
+  midFire: async ({ transition, binding, marking, markingAfterConsume, net }) => {
+    if (transition.id !== 'special-transition') return null;
+
+    // Return Map<placeId, Multiset> to own output-side token placement.
+    // null/undefined falls through to standard TP inscription evaluation.
+    return new Map([['p_out', new Map([['done', 1]])]]);
+  },
+  afterFire: ({ transition, binding, markingAfterConsume, markingAfterFire, net }) => {
+    // called after output tokens are added
+  },
+};
+
+await fire(net, marking, transitionId, binding, evalExpr, callbacks);
+```
+
+---
+
+## Classical Examples
+
+The package includes executable examples under `examples/`. They are intentionally
+not exported from the package API; they show how to build and run nets with the
+public primitives.
+
+Run all examples:
+
+```bash
+pnpm --filter @greenByteHQ/cpn-semantics run examples
+```
+
+Or build once and run an individual example:
+
+```bash
+pnpm --filter @greenByteHQ/cpn-semantics run build
+node packages/cpn-semantics/examples/traffic-light.mjs
+node packages/cpn-semantics/examples/producer-consumer.mjs
+node packages/cpn-semantics/examples/sml-integration.mjs
+```
+
+### Traffic Light
+
+One coloured token represents the current light state. Firing `advance` cycles
+`red -> green -> yellow -> red`.
+
+```bash
+node packages/cpn-semantics/examples/traffic-light.mjs
+```
+
+### Bounded Producer-Consumer
+
+This net models a bounded buffer with `slots`, `buffer`, and `consumed` places.
+`produce` consumes one free slot and creates an `item`; `consume` consumes one
+`item`, restores one slot, and records the consumed item.
+
+```bash
+node packages/cpn-semantics/examples/producer-consumer.mjs
+```
+
+### SML Guard + Expression
+
+This net starts with integer tokens `2`, `3`, and `8`. The transition has an
+SML guard `n mod 2 = 0`, so only even tokens are enabled. Its output inscription
+is `1\`(n div 2)`, so firing computes the half of each even token.
+
+```bash
+node packages/cpn-semantics/examples/sml-integration.mjs
+```
+
+Each script prints JSON step output containing the fired transition, binding,
+and marking snapshot after each firing.
+
+---
+
+## License
+
+MIT © kentis — see [LICENSE](LICENSE)

package/dist/cjs/index.cjs

@@ -0,0 +1,483 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EMPTY_MULTISET: () => EMPTY_MULTISET,
+  SmlEvaluationError: () => SmlEvaluationError,
+  computeEnabledSet: () => computeEnabledSet,
+  evalExprWithSosml: () => evalExprWithSosml,
+  evalGuardWithSosml: () => evalGuardWithSosml,
+  evalSmlExpression: () => evalSmlExpression,
+  evalSmlGuard: () => evalSmlGuard,
+  findEnabledBindings: () => findEnabledBindings,
+  fire: () => fire,
+  msAdd: () => msAdd,
+  msContains: () => msContains,
+  msEquals: () => msEquals,
+  msIsEmpty: () => msIsEmpty,
+  msScale: () => msScale,
+  msSubtract: () => msSubtract
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/multiset.ts
+var EMPTY_MULTISET = /* @__PURE__ */ new Map();
+function msAdd(a, b) {
+  const result = new Map(a);
+  for (const [k, v] of b) {
+    result.set(k, (result.get(k) ?? 0) + v);
+  }
+  return result;
+}
+function msSubtract(a, b) {
+  const result = new Map(a);
+  for (const [k, v] of b) {
+    const have = result.get(k) ?? 0;
+    const count = have - v;
+    if (count < 0) {
+      throw new Error(`Multiset underflow for token "${k}": need ${v}, have ${have}`);
+    }
+    if (count === 0) {
+      result.delete(k);
+    } else {
+      result.set(k, count);
+    }
+  }
+  return result;
+}
+function msScale(ms, n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new RangeError(`msScale: n must be a non-negative integer, got ${n}`);
+  }
+  if (n === 0) return EMPTY_MULTISET;
+  const result = /* @__PURE__ */ new Map();
+  for (const [k, v] of ms) {
+    result.set(k, v * n);
+  }
+  return result;
+}
+function msContains(a, b) {
+  for (const [k, v] of b) {
+    if ((a.get(k) ?? 0) < v) return false;
+  }
+  return true;
+}
+function msIsEmpty(ms) {
+  return ms.size === 0;
+}
+function msEquals(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [k, v] of a) {
+    if (b.get(k) !== v) return false;
+  }
+  return true;
+}
+
+// src/sml.ts
+var import_interpreter = __toESM(require("@sosml/interpreter"), 1);
+var { getFirstState, interpret } = import_interpreter.default;
+var SmlEvaluationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SmlEvaluationError";
+  }
+};
+var RESULT_NAME = "cpnResult";
+function escapeSmlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+}
+function tokenKeyToSmlLiteral(value) {
+  if (value === "true" || value === "false") return value;
+  if (value === "()") return "()";
+  if (/^-?\d+$/.test(value)) return value.replace(/^-/, "~");
+  if (/^\(.*\)$/.test(value)) {
+    return value.replace(/(^|[(,])-?\d+/g, (match) => match.replace("-", "~"));
+  }
+  return escapeSmlString(value);
+}
+function bindingPrelude(binding) {
+  return [...binding].map(([name, value]) => `val ${name} = ${tokenKeyToSmlLiteral(value)};`).join("\n");
+}
+function evaluateValue(expr, binding) {
+  const source = `${bindingPrelude(binding)}
+val ${RESULT_NAME} = ${expr};`;
+  const result = interpret(source, getFirstState(), { allowSuccessorML: true, allowVector: true });
+  if (result.evaluationErrored) {
+    throw new SmlEvaluationError(String(result.error ?? "SML evaluation failed"));
+  }
+  const bindingValue = result.state.getDynamicValue(RESULT_NAME)?.[0];
+  if (!bindingValue) {
+    throw new SmlEvaluationError("SML evaluation did not produce a result");
+  }
+  return { value: bindingValue, state: result.state };
+}
+function unquoteSmlString(value) {
+  return value.slice(1, -1).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+function valueToTokenKey(value, state) {
+  const typed = value;
+  switch (value.typeName()) {
+    case "Integer":
+      return String(typed.value);
+    case "BoolValue":
+      return String(typed.value);
+    case "StringValue":
+      return typeof typed.value === "string" ? typed.value : unquoteSmlString(value.toString(state));
+    case "RecordValue": {
+      const entries = typed.entries;
+      if (!entries || entries.size === 0) return "()";
+      const tupleItems = [];
+      for (let i = 1; i <= entries.size; i += 1) {
+        const item = entries.get(String(i));
+        if (!item) break;
+        tupleItems.push(valueToTokenKey(item, state));
+      }
+      if (tupleItems.length === entries.size && tupleItems.length > 0) {
+        return `(${tupleItems.join(",")})`;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return value.toString(state);
+}
+function valueToBoolean(value) {
+  if (value.typeName() !== "BoolValue") {
+    throw new SmlEvaluationError(`Guard must evaluate to bool, got ${value.typeName()}`);
+  }
+  return Boolean(value.value);
+}
+function addToken(result, key, count) {
+  if (!Number.isInteger(count) || count < 0) {
+    throw new SmlEvaluationError(`Multiset count must be a non-negative integer, got ${count}`);
+  }
+  if (count === 0) return;
+  result.set(key, (result.get(key) ?? 0) + count);
+}
+function splitTopLevelUnion(expr) {
+  const parts = [];
+  let start = 0;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < expr.length; i += 1) {
+    const ch = expr[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth += 1;
+    else if (ch === ")" || ch === "]" || ch === "}") depth -= 1;
+    else if (ch === "+" && expr[i + 1] === "+" && depth === 0) {
+      parts.push(expr.slice(start, i).trim());
+      start = i + 2;
+      i += 1;
+    }
+  }
+  parts.push(expr.slice(start).trim());
+  return parts.filter(Boolean);
+}
+function splitMultisetTerm(term) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < term.length; i += 1) {
+    const ch = term[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth += 1;
+    else if (ch === ")" || ch === "]" || ch === "}") depth -= 1;
+    else if (ch === "`" && depth === 0) {
+      return { countExpr: term.slice(0, i).trim(), valueExpr: term.slice(i + 1).trim() };
+    }
+  }
+  return null;
+}
+async function evalSmlExpression(expr, binding) {
+  const trimmed = expr.trim();
+  if (!trimmed || trimmed === "empty") return /* @__PURE__ */ new Map();
+  const result = /* @__PURE__ */ new Map();
+  for (const part of splitTopLevelUnion(trimmed)) {
+    const term = splitMultisetTerm(part);
+    if (!term) {
+      const { value, state } = evaluateValue(part, binding);
+      addToken(result, valueToTokenKey(value, state), 1);
+      continue;
+    }
+    const countResult = evaluateValue(term.countExpr, binding);
+    if (countResult.value.typeName() !== "Integer") {
+      throw new SmlEvaluationError(`Multiset count must evaluate to int, got ${countResult.value.typeName()}`);
+    }
+    const valueResult = evaluateValue(term.valueExpr, binding);
+    addToken(
+      result,
+      valueToTokenKey(valueResult.value, valueResult.state),
+      Number(countResult.value.value)
+    );
+  }
+  return result;
+}
+async function evalSmlGuard(expr, binding) {
+  if (!expr.trim()) return true;
+  return valueToBoolean(evaluateValue(expr, binding).value);
+}
+
+// src/engine.ts
+var evalExprWithSosml = async (expr, lang, binding) => {
+  if (lang !== "sml") {
+    throw new Error(`No ${lang} expression evaluator is configured in @greenByteHQ/cpn-semantics`);
+  }
+  return evalSmlExpression(expr, binding);
+};
+var evalGuardWithSosml = async (expr, lang, binding) => {
+  switch (lang) {
+    case "sml":
+      return evalSmlGuard(expr, binding);
+    case "python":
+      throw new Error(`No ${lang} guard evaluator is configured in @greenByteHQ/cpn-semantics`);
+    case "js":
+      throw new Error(`No ${lang} guard evaluator is configured in @greenByteHQ/cpn-semantics`);
+    default:
+      throw new Error(`Unknown language ${lang} in guard expression`);
+  }
+};
+function extractVariables(expr) {
+  const KEYWORDS = /* @__PURE__ */ new Set([
+    "let",
+    "val",
+    "in",
+    "end",
+    "if",
+    "then",
+    "else",
+    "andalso",
+    "orelse",
+    "not",
+    "div",
+    "mod",
+    "true",
+    "false",
+    "empty"
+  ]);
+  const matches = expr.match(/[a-zA-Z_][a-zA-Z0-9_']*/g) ?? [];
+  return [...new Set(matches)].filter((m) => !KEYWORDS.has(m));
+}
+function buildArcCandidates(arc, marking) {
+  const sourceMarking = marking.get(arc.sourceId) ?? EMPTY_MULTISET;
+  const tokenKeys = [...sourceMarking.keys()];
+  if (arc.inscription.trim() === "") {
+    return [/* @__PURE__ */ new Map()];
+  }
+  const vars = extractVariables(arc.inscription);
+  if (vars.length === 0) {
+    return [/* @__PURE__ */ new Map()];
+  }
+  if (vars.length === 1) {
+    return tokenKeys.map((key) => /* @__PURE__ */ new Map([[vars[0], key]]));
+  }
+  let candidates = [/* @__PURE__ */ new Map()];
+  for (const varName of vars) {
+    const next = [];
+    for (const candidate of candidates) {
+      for (const key of tokenKeys) {
+        if (candidate.has(varName) && candidate.get(varName) !== key) continue;
+        const extended = new Map(candidate);
+        extended.set(varName, key);
+        next.push(extended);
+      }
+    }
+    candidates = next;
+  }
+  return candidates;
+}
+function mergeBindings(perArcCandidates) {
+  let combined = [/* @__PURE__ */ new Map()];
+  for (const arcCandidates of perArcCandidates) {
+    const next = [];
+    for (const existing of combined) {
+      for (const arcCandidate of arcCandidates) {
+        let consistent = true;
+        for (const [k, v] of arcCandidate) {
+          if (existing.has(k) && existing.get(k) !== v) {
+            consistent = false;
+            break;
+          }
+        }
+        if (!consistent) continue;
+        next.push(new Map([...existing, ...arcCandidate]));
+      }
+    }
+    combined = next;
+  }
+  return combined;
+}
+async function findEnabledBindings(net, marking, transitionId, evalExpr = evalExprWithSosml, evalGuard = evalGuardWithSosml) {
+  const transition = net.transitions.get(transitionId);
+  if (!transition) return [];
+  const ptArcs = [...net.arcs.values()].filter(
+    (a) => a.kind === "PT" && a.targetId === transitionId
+  );
+  if (ptArcs.length === 0) {
+    const b = /* @__PURE__ */ new Map();
+    if (transition.guard.trim()) {
+      const lang = transition.guardLang ?? "sml" /* SML */;
+      const guardOk = await evalGuard(transition.guard, lang, b);
+      return guardOk ? [b] : [];
+    }
+    return [b];
+  }
+  const perArcCandidates = ptArcs.map((arc) => buildArcCandidates(arc, marking));
+  const candidateBindings = mergeBindings(perArcCandidates);
+  const enabled = [];
+  await Promise.all(
+    candidateBindings.map(async (b) => {
+      const arcChecks = ptArcs.map(async (arc) => {
+        const lang = arc.inscriptionLang ?? "sml" /* SML */;
+        const inscription = arc.inscription.trim();
+        if (!inscription) return true;
+        const weight = await evalExpr(inscription, lang, b);
+        const available = marking.get(arc.sourceId) ?? EMPTY_MULTISET;
+        return msContains(available, weight);
+      });
+      const arcResults = await Promise.all(arcChecks);
+      if (arcResults.some((ok) => !ok)) return;
+      if (transition.guard.trim()) {
+        const lang = transition.guardLang ?? "sml" /* SML */;
+        const guardOk = await evalGuard(transition.guard, lang, b);
+        if (!guardOk) return;
+      }
+      enabled.push(b);
+    })
+  );
+  return enabled;
+}
+async function fire(net, marking, transitionId, binding, evalExpr = evalExprWithSosml, callbacks = {}) {
+  const newMarking = new Map(marking);
+  const transition = net.transitions.get(transitionId);
+  if (!transition) return newMarking;
+  await callbacks.beforeFire?.({ transition, binding, marking, net });
+  for (const arc of net.arcs.values()) {
+    if (arc.kind !== "PT" || arc.targetId !== transitionId) continue;
+    if (arc.readArcGroupId) continue;
+    const inscription = arc.inscription.trim();
+    if (!inscription) continue;
+    const lang = arc.inscriptionLang ?? "sml" /* SML */;
+    const weight = await evalExpr(inscription, lang, binding);
+    const current = newMarking.get(arc.sourceId) ?? EMPTY_MULTISET;
+    newMarking.set(arc.sourceId, msSubtract(current, weight));
+  }
+  const markingAfterConsume = new Map(newMarking);
+  const customResult = await callbacks.midFire?.({
+    transition,
+    binding,
+    marking,
+    markingAfterConsume,
+    net
+  });
+  if (customResult !== null && customResult !== void 0) {
+    for (const [placeId, tokens] of customResult) {
+      const current = newMarking.get(placeId) ?? EMPTY_MULTISET;
+      newMarking.set(placeId, msAdd(current, tokens));
+    }
+    await callbacks.afterFire?.({
+      transition,
+      binding,
+      marking,
+      markingAfterConsume,
+      markingAfterFire: newMarking,
+      net
+    });
+    return newMarking;
+  }
+  for (const arc of net.arcs.values()) {
+    if (arc.kind !== "TP" || arc.sourceId !== transitionId) continue;
+    if (arc.readArcGroupId) continue;
+    const inscription = arc.inscription.trim();
+    if (!inscription) continue;
+    const lang = arc.inscriptionLang ?? "sml" /* SML */;
+    const weight = await evalExpr(inscription, lang, binding);
+    const current = newMarking.get(arc.targetId) ?? EMPTY_MULTISET;
+    newMarking.set(arc.targetId, msAdd(current, weight));
+  }
+  await callbacks.afterFire?.({
+    transition,
+    binding,
+    marking,
+    markingAfterConsume,
+    markingAfterFire: newMarking,
+    net
+  });
+  return newMarking;
+}
+async function computeEnabledSet(net, marking, evalExpr = evalExprWithSosml, evalGuard = evalGuardWithSosml) {
+  const enabled = /* @__PURE__ */ new Set();
+  await Promise.all(
+    [...net.transitions.keys()].map(async (tId) => {
+      const bindings = await findEnabledBindings(net, marking, tId, evalExpr, evalGuard);
+      if (bindings.length > 0) enabled.add(tId);
+    })
+  );
+  return enabled;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMPTY_MULTISET,
+  SmlEvaluationError,
+  computeEnabledSet,
+  evalExprWithSosml,
+  evalGuardWithSosml,
+  evalSmlExpression,
+  evalSmlGuard,
+  findEnabledBindings,
+  fire,
+  msAdd,
+  msContains,
+  msEquals,
+  msIsEmpty,
+  msScale,
+  msSubtract
+});
+//# sourceMappingURL=index.cjs.map