@stateforward/hsm.ts 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3015 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target2, all) => {
+  for (var name2 in all)
+    __defProp(target2, name2, { get: all[name2], 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Activity: () => Activity,
+  After: () => After,
+  At: () => At,
+  Attribute: () => Attribute,
+  AttributeKind: () => AttributeKind,
+  BehaviorKind: () => BehaviorKind,
+  Call: () => Call,
+  CallEventKind: () => CallEventKind,
+  ChangeEventKind: () => ChangeEventKind,
+  Choice: () => Choice,
+  ChoiceKind: () => ChoiceKind,
+  Clock: () => Clock,
+  CompletionEventKind: () => CompletionEventKind,
+  ConcurrentKind: () => ConcurrentKind,
+  ConstraintKind: () => ConstraintKind,
+  Context: () => Context,
+  DeepHistory: () => DeepHistory,
+  DeepHistoryKind: () => DeepHistoryKind,
+  DefaultClock: () => DefaultClock,
+  Defer: () => Defer,
+  Define: () => Define,
+  DispatchAll: () => DispatchAll,
+  DispatchTo: () => DispatchTo,
+  Effect: () => Effect,
+  ElementKind: () => ElementKind,
+  Entry: () => Entry,
+  ErrorEvent: () => ErrorEvent,
+  ErrorEventKind: () => ErrorEventKind,
+  Event: () => Event,
+  EventKind: () => EventKind,
+  Every: () => Every,
+  Exit: () => Exit,
+  ExternalKind: () => ExternalKind,
+  Final: () => Final,
+  FinalEvent: () => FinalEvent,
+  FinalStateKind: () => FinalStateKind,
+  Generator: () => Generator,
+  Get: () => Get,
+  Group: () => Group,
+  Guard: () => Guard,
+  ID: () => ID,
+  Initial: () => Initial,
+  InitialEvent: () => InitialEvent,
+  InitialKind: () => InitialKind,
+  Instance: () => Instance,
+  InternalKind: () => InternalKind,
+  IsAncestor: () => IsAncestor,
+  IsKind: () => isKind,
+  JunctionKind: () => JunctionKind,
+  Kinds: () => kinds,
+  LCA: () => LCA,
+  LocalKind: () => LocalKind,
+  MUID: () => MUID,
+  MakeGroup: () => MakeGroup,
+  MakeKind: () => makeKind,
+  ModelKind: () => ModelKind,
+  Name: () => Name,
+  NamespaceKind: () => NamespaceKind,
+  NullKind: () => NullKind,
+  On: () => On,
+  OnCall: () => OnCall,
+  OnSet: () => OnSet,
+  Operation: () => Operation,
+  PartialKind: () => PartialKind,
+  PseudostateKind: () => PseudostateKind,
+  QualifiedName: () => QualifiedName,
+  Queue: () => Queue,
+  Restart: () => Restart,
+  SelfKind: () => SelfKind,
+  SequentialKind: () => SequentialKind,
+  Set: () => Set,
+  ShallowHistory: () => ShallowHistory,
+  ShallowHistoryKind: () => ShallowHistoryKind,
+  ShardedGenerators: () => ShardedGenerators,
+  Source: () => Source,
+  State: () => State,
+  StateKind: () => StateKind,
+  StateMachineKind: () => StateMachineKind,
+  TakeSnapshot: () => TakeSnapshot,
+  Target: () => Target,
+  TimeEventKind: () => TimeEventKind,
+  Transition: () => Transition,
+  TransitionKind: () => TransitionKind,
+  VertexKind: () => VertexKind,
+  When: () => When,
+  activity: () => activity,
+  add64: () => add64,
+  after: () => after,
+  afterDispatch: () => afterDispatch,
+  afterEntry: () => afterEntry,
+  afterExecuted: () => afterExecuted,
+  afterExit: () => afterExit,
+  afterProcess: () => afterProcess,
+  and64: () => and64,
+  apply: () => apply,
+  at: () => at,
+  attribute: () => attribute,
+  call: () => call,
+  choice: () => choice,
+  clock: () => clock,
+  cmp64: () => cmp64,
+  deepHistory: () => deepHistory,
+  defer: () => defer,
+  define: () => define,
+  dirname: () => dirname,
+  dispatchAll: () => dispatchAll,
+  dispatchTo: () => dispatchTo,
+  effect: () => effect,
+  entry: () => entry,
+  event: () => event,
+  every: () => every,
+  exit: () => exit,
+  final: () => final,
+  find: () => find,
+  from32: () => from32,
+  get: () => get,
+  getDefaultConfig: () => getDefaultConfig,
+  guard: () => guard,
+  id: () => id,
+  initial: () => initial,
+  isAbsolute: () => isAbsolute,
+  isAncestor: () => isAncestor,
+  isKind: () => isKind,
+  join: () => join,
+  kinds: () => kinds,
+  lca: () => lca,
+  make: () => make,
+  make64: () => make64,
+  makeGroup: () => makeGroup,
+  makeKind: () => makeKind,
+  makeMuid: () => makeMuid,
+  name: () => name,
+  newGenerator: () => newGenerator,
+  on: () => on,
+  onCall: () => onCall,
+  onSet: () => onSet,
+  operation: () => operation,
+  or64: () => or64,
+  qualifiedName: () => qualifiedName,
+  restart: () => restart,
+  set: () => set,
+  shallowHistory: () => shallowHistory,
+  shl64: () => shl64,
+  shr64: () => shr64,
+  source: () => source,
+  start: () => start,
+  state: () => state,
+  stop: () => stop,
+  sub64: () => sub64,
+  takeSnapshot: () => takeSnapshot,
+  target: () => target,
+  transition: () => transition,
+  when: () => when
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/kind.ts
+var length = 48;
+var idLength = 8;
+var depthMax = length / idLength;
+var idMask = (1 << idLength) - 1;
+var counter = 0;
+var nextId = () => {
+  const id2 = counter & idMask;
+  counter += 1;
+  return id2;
+};
+var extractId = (kindValue, depth) => Math.floor(kindValue / Math.pow(2, idLength * depth)) & idMask;
+function kind(...baseKinds) {
+  let result = nextId();
+  const used = {};
+  let usedCount = 0;
+  for (const base of baseKinds) {
+    for (let depth = 0; depth < depthMax; depth += 1) {
+      const baseId = extractId(base, depth);
+      if (baseId === 0) {
+        break;
+      }
+      if (used[baseId]) {
+        continue;
+      }
+      used[baseId] = true;
+      usedCount += 1;
+      result += baseId * Math.pow(2, usedCount * idLength);
+    }
+  }
+  return result;
+}
+function isKind(kindValue, ...baseKinds) {
+  for (const base of baseKinds) {
+    const baseId = base & idMask;
+    if (kindValue === baseId) {
+      return true;
+    }
+    for (let depth = 0; depth < depthMax; depth += 1) {
+      const currentId = extractId(kindValue, depth);
+      if (currentId === baseId) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var makeKind = (...baseKinds) => kind(...baseKinds);
+var kinds = {
+  Null: makeKind(),
+  Element: makeKind(),
+  Partial: 0,
+  Vertex: 0,
+  Constraint: 0,
+  Behavior: 0,
+  Namespace: 0,
+  Concurrent: 0,
+  Sequential: 0,
+  StateMachine: 0,
+  Attribute: 0,
+  State: 0,
+  Model: 0,
+  Transition: 0,
+  Internal: 0,
+  External: 0,
+  Local: 0,
+  Self: 0,
+  Event: 0,
+  CompletionEvent: 0,
+  ChangeEvent: 0,
+  ErrorEvent: 0,
+  TimeEvent: 0,
+  CallEvent: 0,
+  Pseudostate: 0,
+  Initial: 0,
+  FinalState: 0,
+  Choice: 0,
+  Junction: 0,
+  DeepHistory: 0,
+  ShallowHistory: 0
+};
+kinds.Partial = makeKind(kinds.Element);
+kinds.Vertex = makeKind(kinds.Element);
+kinds.Constraint = makeKind(kinds.Element);
+kinds.Behavior = makeKind(kinds.Element);
+kinds.Namespace = makeKind(kinds.Element);
+kinds.Concurrent = makeKind(kinds.Behavior);
+kinds.Sequential = makeKind(kinds.Behavior);
+kinds.StateMachine = makeKind(kinds.Concurrent, kinds.Namespace);
+kinds.Attribute = makeKind(kinds.Element);
+kinds.State = makeKind(kinds.Vertex, kinds.Namespace);
+kinds.Model = makeKind(kinds.State);
+kinds.Transition = makeKind(kinds.Element);
+kinds.Internal = makeKind(kinds.Transition);
+kinds.External = makeKind(kinds.Transition);
+kinds.Local = makeKind(kinds.Transition);
+kinds.Self = makeKind(kinds.Transition);
+kinds.Event = makeKind(kinds.Element);
+kinds.CompletionEvent = makeKind(kinds.Event);
+kinds.ChangeEvent = makeKind(kinds.Event);
+kinds.ErrorEvent = makeKind(kinds.CompletionEvent);
+kinds.TimeEvent = makeKind(kinds.Event);
+kinds.CallEvent = makeKind(kinds.Event);
+kinds.Pseudostate = makeKind(kinds.Vertex);
+kinds.Initial = makeKind(kinds.Pseudostate);
+kinds.FinalState = makeKind(kinds.State);
+kinds.Choice = makeKind(kinds.Pseudostate);
+kinds.Junction = makeKind(kinds.Pseudostate);
+kinds.DeepHistory = makeKind(kinds.Pseudostate);
+kinds.ShallowHistory = makeKind(kinds.Pseudostate);
+
+// src/hsm.ts
+function attachSpec(builder, spec) {
+  return Object.assign(builder, {
+    __hsmSpec: spec
+  });
+}
+var runtimeByInstance = /* @__PURE__ */ new WeakMap();
+function bindRuntime(instance, runtime) {
+  runtimeByInstance.set(instance, runtime);
+}
+function runtimeFor(instance) {
+  if (!instance || typeof instance !== "object") {
+    return void 0;
+  }
+  return runtimeByInstance.get(instance);
+}
+function join(...segments) {
+  var parts = [];
+  var currentIsAbsolute = false;
+  for (var i = 0; i < segments.length; i++) {
+    var segment = segments[i];
+    if (segment === null || segment === void 0 || segment.length === 0) {
+      continue;
+    }
+    if (segment[0] === "/") {
+      parts = [];
+      currentIsAbsolute = true;
+    }
+    var startIndex = 0;
+    var currentPartEnd = 0;
+    var part = "";
+    while (currentPartEnd < segment.length) {
+      if (segment[currentPartEnd] === "/") {
+        if (currentPartEnd > startIndex) {
+          part = segment.substring(startIndex, currentPartEnd);
+          if (part === "..") {
+            if (currentIsAbsolute && parts.length === 0) {
+            } else if (parts.length > 0 && parts[parts.length - 1] !== "..") {
+              parts.pop();
+            } else {
+              parts.push(part);
+            }
+          } else if (part !== ".") {
+            parts.push(part);
+          }
+        }
+        startIndex = currentPartEnd + 1;
+      }
+      currentPartEnd++;
+    }
+    if (currentPartEnd > startIndex) {
+      part = segment.substring(startIndex, currentPartEnd);
+      if (part === "..") {
+        if (currentIsAbsolute && parts.length === 0) {
+        } else if (parts.length > 0 && parts[parts.length - 1] !== "..") {
+          parts.pop();
+        } else {
+          parts.push(part);
+        }
+      } else if (part !== ".") {
+        parts.push(part);
+      }
+    }
+  }
+  var joinedPath = parts.join("/");
+  if (currentIsAbsolute) {
+    joinedPath = "/" + joinedPath;
+  }
+  var hasTrailingSlash = false;
+  if (segments.length > 0) {
+    var lastInputSegment = segments[segments.length - 1];
+    if (lastInputSegment && lastInputSegment.length > 0 && lastInputSegment[lastInputSegment.length - 1] === "/") {
+      hasTrailingSlash = true;
+    }
+  }
+  if (joinedPath.length === 0) {
+    return currentIsAbsolute ? "/" : ".";
+  } else if (hasTrailingSlash && joinedPath !== "/") {
+    return joinedPath + "/";
+  }
+  return joinedPath;
+}
+function slice(args, start2 = 0) {
+  var result = [];
+  for (var i = start2; i < args.length; i++) {
+    result.push(args[i]);
+  }
+  return result;
+}
+function dirname(path) {
+  if (path === void 0 || path === null || path.length === 0) {
+    return ".";
+  }
+  var originalPathWasAbsolute = path[0] === "/";
+  var i = path.length - 1;
+  while (i >= 0 && path[i] === "/") {
+    i--;
+  }
+  var p = path.substring(0, i + 1);
+  if (p.length === 0) {
+    return originalPathWasAbsolute ? "/" : ".";
+  }
+  var lastSeparatorIndex = p.lastIndexOf("/");
+  if (lastSeparatorIndex < 0) {
+    return originalPathWasAbsolute ? "/" : ".";
+  }
+  var result = p.substring(0, lastSeparatorIndex);
+  if (result.length === 0) {
+    return originalPathWasAbsolute ? "/" : ".";
+  }
+  return result;
+}
+function isAbsolute(path) {
+  var c = path.charAt(0);
+  if (c === "/") return true;
+  return path.length > 2 && path.charAt(1) === ":" && path.charAt(2) === "/";
+}
+var Context = class {
+  listeners;
+  instances;
+  done;
+  constructor() {
+    this.listeners = [];
+    this.instances = {};
+    this.done = false;
+  }
+  addEventListener(_type, listener) {
+    this.listeners.push(listener);
+  }
+  removeEventListener(_type, listener) {
+    var index = this.listeners.indexOf(listener);
+    if (index !== -1) {
+      this.listeners.splice(index, 1);
+    }
+  }
+};
+var InitialEvent = {
+  kind: kinds.CompletionEvent,
+  qualifiedName: "hsm_initial",
+  name: "hsm_initial"
+};
+var FinalEvent = {
+  name: "hsm_final",
+  kind: kinds.CompletionEvent
+};
+var ErrorEvent = {
+  name: "hsm_error",
+  kind: kinds.ErrorEvent
+};
+var DefaultClock = {
+  setTimeout: typeof setTimeout === "function" ? ((callback, timeout, ...args) => setTimeout(callback, timeout || 0, ...args)) : function(_callback, _timeout, ..._args) {
+    return 0;
+  },
+  clearTimeout: typeof clearTimeout === "function" ? ((id2) => {
+    if (id2 !== void 0) {
+      clearTimeout(id2);
+    }
+  }) : function() {
+  },
+  now: typeof Date !== "undefined" && typeof Date.now === "function" ? Date.now : function() {
+    return 0;
+  }
+};
+function event(name2, schema) {
+  return {
+    kind: kinds.Event,
+    name: name2,
+    schema
+  };
+}
+function apply(model, stack, partials) {
+  for (var i = 0; i < partials.length; i++) {
+    var partial = partials[i];
+    if (typeof partial === "function") {
+      partial(model, stack);
+    }
+  }
+}
+function qualifyModelName(model, name2) {
+  if (isAbsolute(name2)) {
+    return isAncestor(model.qualifiedName, name2) || model.qualifiedName === name2 ? name2 : join(model.qualifiedName, name2.slice(1));
+  }
+  return join(model.qualifiedName, name2);
+}
+function registerEvent(model, event2) {
+  if (!model.events) {
+    model.events = {};
+  }
+  var existing = model.events[event2.name];
+  if (!existing) {
+    model.events[event2.name] = event2;
+    return event2;
+  }
+  return existing;
+}
+function resolveOperation(model, value) {
+  return function(ctx, instance, event2) {
+    var runtime = runtimeFor(instance);
+    if (!runtime) {
+      return false;
+    }
+    var name2 = qualifyModelName(model, value);
+    return !!runtime.invoke(name2, ctx, [event2]);
+  };
+}
+function hasThen(value) {
+  return !!value && typeof value.then === "function";
+}
+function hasAddEventListener(value) {
+  return !!value && typeof value.addEventListener === "function";
+}
+function hasOn(value) {
+  return !!value && typeof value.on === "function";
+}
+function toSignalLike(value) {
+  if (hasThen(value)) {
+    return value;
+  }
+  if (hasAddEventListener(value) || hasOn(value)) {
+    return value;
+  }
+  return void 0;
+}
+function coerceDuration(value) {
+  var numericValue = Number(value);
+  return isNaN(numericValue) ? 0 : numericValue;
+}
+function coerceTimepoint(value) {
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  return coerceDuration(value);
+}
+function withThenable(value, callback) {
+  if (hasThen(value)) {
+    return Promise.resolve(value).then(callback);
+  }
+  return callback(value);
+}
+function getState(model, path) {
+  if (!path) {
+    return void 0;
+  }
+  var member = model.members[path];
+  return isStateElement(member) ? member : void 0;
+}
+function getVertex(model, path) {
+  if (!path) {
+    return void 0;
+  }
+  var member = model.members[path];
+  return isVertex(member) ? member : void 0;
+}
+function getTransition(model, path) {
+  if (!path) {
+    return void 0;
+  }
+  var member = model.members[path];
+  return isTransitionElement(member) ? member : void 0;
+}
+function getBehavior(model, path) {
+  if (!path) {
+    return void 0;
+  }
+  var member = model.members[path];
+  return isBehaviorElement(member) ? member : void 0;
+}
+function getConstraint(model, path) {
+  if (!path) {
+    return void 0;
+  }
+  var member = model.members[path];
+  return isConstraintElement(member) ? member : void 0;
+}
+function isAncestor(ancestor, descendant) {
+  if (ancestor === descendant) return false;
+  if (ancestor === "/") return isAbsolute(descendant);
+  return descendant.startsWith(ancestor + "/");
+}
+function lca(a, b) {
+  if (a === b) return dirname(a);
+  if (!a) return b;
+  if (!b) return a;
+  if (dirname(a) === dirname(b)) return dirname(a);
+  if (isAncestor(a, b)) return a;
+  if (isAncestor(b, a)) return b;
+  return lca(dirname(a), dirname(b));
+}
+function isStateElement(element) {
+  return !!element && isKind(element.kind, kinds.State);
+}
+function isModelElement(element) {
+  return !!element && isKind(element.kind, kinds.Model);
+}
+function isTransitionElement(element) {
+  return !!element && isKind(element.kind, kinds.Transition);
+}
+function isConstraintElement(element) {
+  return !!element && isKind(element.kind, kinds.Constraint);
+}
+function isBehaviorElement(element) {
+  return !!element && isKind(element.kind, kinds.Behavior);
+}
+function isVertex(element) {
+  return !!element && isKind(element.kind, kinds.Vertex);
+}
+function findState(stack) {
+  return find(stack, kinds.State);
+}
+function findTransition(stack) {
+  return find(stack, kinds.Transition);
+}
+function findModel(stack) {
+  return find(stack, kinds.Model);
+}
+function findVertex(stack) {
+  return find(stack, kinds.Vertex);
+}
+var Queue = class {
+  front = [];
+  back = [];
+  backHead = 0;
+  len() {
+    return this.front.length + (this.back.length - this.backHead);
+  }
+  pop() {
+    var event2;
+    if (this.front.length > 0) {
+      event2 = this.front.pop();
+    } else if (this.backHead < this.back.length) {
+      event2 = this.back[this.backHead];
+      this.back[this.backHead] = void 0;
+      this.backHead++;
+      if (this.backHead === this.back.length) {
+        this.back = [];
+        this.backHead = 0;
+      }
+    }
+    return event2;
+  }
+  push(...events) {
+    for (var i = 0; i < events.length; i++) {
+      var event2 = events[i];
+      if (isKind(event2.kind, kinds.CompletionEvent)) {
+        this.front.push(event2);
+      } else {
+        this.back.push(event2);
+      }
+    }
+  }
+};
+function buildTransitionTable(model) {
+  for (var stateName in model.members) {
+    var state2 = model.members[stateName];
+    if (!isStateElement(state2) && !isModelElement(state2)) continue;
+    model.transitionMap[stateName] = {};
+    var transitionsByEvent = {};
+    var currentPath = stateName;
+    var depth = 0;
+    while (currentPath) {
+      var currentState = model.members[currentPath];
+      if (currentState && (isStateElement(currentState) || isModelElement(currentState))) {
+        var stateOrModel = currentState;
+        for (var i = 0; i < stateOrModel.transitions.length; i++) {
+          var transitionName = stateOrModel.transitions[i];
+          var transition2 = model.members[transitionName];
+          if (isTransitionElement(transition2) && transition2.events) {
+            for (var j = 0; j < transition2.events.length; j++) {
+              var transitionEventName = transition2.events[j];
+              if (transitionEventName.indexOf("*") !== -1) {
+                continue;
+              }
+              if (!transitionsByEvent[transitionEventName]) {
+                transitionsByEvent[transitionEventName] = [];
+              }
+              transitionsByEvent[transitionEventName].push({
+                transition: transition2,
+                priority: depth
+              });
+            }
+          }
+        }
+      }
+      if (currentPath === "/" || !currentPath) break;
+      var parentPath = dirname(currentPath);
+      if (parentPath === currentPath) break;
+      currentPath = parentPath;
+      depth++;
+    }
+    for (var eventName in transitionsByEvent) {
+      var transitions = transitionsByEvent[eventName];
+      transitions.sort(function(a, b) {
+        return a.priority - b.priority;
+      });
+      model.transitionMap[stateName][eventName] = transitions.map(function(t) {
+        return t.transition;
+      });
+    }
+  }
+}
+function buildDeferredTable(model) {
+  for (var stateName in model.members) {
+    var state2 = model.members[stateName];
+    if (!isStateElement(state2) && !isModelElement(state2)) continue;
+    model.deferredMap[stateName] = {};
+    var currentPath = stateName;
+    while (currentPath) {
+      var currentState = model.members[currentPath];
+      if (currentState && (isStateElement(currentState) || isModelElement(currentState))) {
+        var stateOrModel = currentState;
+        if (stateOrModel.deferred) {
+          for (var i = 0; i < stateOrModel.deferred.length; i++) {
+            var deferredEvent = stateOrModel.deferred[i];
+            var transitions = model.transitionMap[stateName][deferredEvent];
+            if (transitions && transitions.some((t) => t.source === stateName)) {
+              continue;
+            }
+            if (deferredEvent.indexOf("*") === -1) {
+              model.deferredMap[stateName][deferredEvent] = true;
+            }
+          }
+        }
+      }
+      if (currentPath === "/" || !currentPath) break;
+      var parentPath = dirname(currentPath);
+      if (parentPath === currentPath) break;
+      currentPath = parentPath;
+    }
+  }
+}
+var EMPTY_PATH = {
+  enter: [],
+  exit: []
+};
+var InstanceImpl = class {
+  dispatch(event2) {
+    var runtime = runtimeFor(this);
+    if (!runtime) {
+      return;
+    }
+    runtime.dispatch(event2);
+  }
+  state() {
+    var runtime = runtimeFor(this);
+    return runtime ? runtime.state() : "";
+  }
+  context() {
+    var runtime = runtimeFor(this);
+    return runtime ? runtime.context() : new Context();
+  }
+  clock() {
+    var runtime = runtimeFor(this);
+    return runtime ? runtime.clock : DefaultClock;
+  }
+  get(name2) {
+    var runtime = runtimeFor(this);
+    return runtime ? runtime.get(name2) : void 0;
+  }
+  set(name2, value) {
+    var runtime = runtimeFor(this);
+    if (runtime) {
+      runtime.set(name2, value);
+    }
+  }
+  call(name2, ...args) {
+    var runtime = runtimeFor(this);
+    if (!runtime) {
+      return void 0;
+    }
+    return runtime.call(name2, ...args);
+  }
+  restart(data) {
+    var runtime = runtimeFor(this);
+    if (runtime) {
+      runtime.restart(data);
+    }
+  }
+  takeSnapshot() {
+    var runtime = runtimeFor(this);
+    return runtime ? runtime.takeSnapshot() : {
+      id: "",
+      qualifiedName: "",
+      state: "",
+      attributes: {},
+      queueLen: 0,
+      events: []
+    };
+  }
+};
+var Instance = (function() {
+  if (this && typeof this === "object") {
+    this._hsm = null;
+  }
+});
+Instance.prototype = InstanceImpl.prototype;
+var HSM = class _HSM {
+  static id = 0;
+  runtime;
+  instance;
+  ctx;
+  model;
+  currentState;
+  queue;
+  active;
+  processing;
+  id;
+  name;
+  attributes;
+  historyShallow;
+  historyDeep;
+  after;
+  clock;
+  startData;
+  constructor(ctxOrInstance, instanceOrModel, maybeModelOrConfig, maybeConfig) {
+    if (!(ctxOrInstance instanceof Context)) {
+      maybeConfig = maybeModelOrConfig;
+      maybeModelOrConfig = instanceOrModel;
+      instanceOrModel = ctxOrInstance;
+      ctxOrInstance = new Context();
+    }
+    const id2 = ((maybeConfig ? maybeConfig.id : "") || _HSM.id++).toString();
+    const name2 = (maybeConfig ? maybeConfig.name : "") || maybeModelOrConfig.qualifiedName;
+    this.instance = instanceOrModel;
+    this.ctx = ctxOrInstance;
+    this.model = maybeModelOrConfig;
+    this.currentState = this.model;
+    this.queue = new Queue();
+    this.active = {};
+    this.processing = false;
+    this.id = id2;
+    this.name = name2;
+    this.attributes = {};
+    this.historyShallow = {};
+    this.historyDeep = {};
+    this.after = {
+      entered: {},
+      exited: {},
+      processed: {},
+      dispatched: {},
+      executed: {}
+    };
+    this.clock = {
+      setTimeout: maybeConfig?.clock?.setTimeout || DefaultClock.setTimeout,
+      clearTimeout: maybeConfig?.clock?.clearTimeout || DefaultClock.clearTimeout,
+      now: maybeConfig?.clock?.now || DefaultClock.now
+    };
+    this.startData = maybeConfig ? maybeConfig.data : void 0;
+    this.runtime = {
+      dispatch: (event2) => {
+        this.dispatch(event2);
+      },
+      state: () => {
+        return this.state();
+      },
+      context: () => {
+        return this.ctx;
+      },
+      clock: this.clock,
+      get: (name3) => {
+        return this.get(name3);
+      },
+      set: (name3, value) => {
+        this.set(name3, value);
+      },
+      invoke: (name3, ctx, args) => {
+        return this.invoke(name3, ctx, args);
+      },
+      call: (name3, ...args) => {
+        return this.call(name3, ...args);
+      },
+      restart: (data) => {
+        this.restart(data);
+      },
+      takeSnapshot: () => {
+        return this.takeSnapshot();
+      },
+      onAfter: (bucket, key, listener) => {
+        this.onAfter(bucket, key, listener);
+      },
+      stop: () => {
+        this.stop();
+      },
+      id: this.id,
+      model: this.model,
+      name: this.name,
+      queue: this.queue,
+      processing: this.processing
+    };
+  }
+  start() {
+    this.processing = true;
+    this.ctx.done = false;
+    bindRuntime(this.instance, this.runtime);
+    this.resetAttributes();
+    var initialEvent = Object.create(InitialEvent);
+    initialEvent.data = this.startData;
+    var newState = this.enter(this.model, initialEvent, true);
+    this.ctx.instances[this.id] = this.instance;
+    this.currentState = newState;
+    this.process();
+    return this;
+  }
+  state() {
+    return this.currentState ? this.currentState.qualifiedName : "";
+  }
+  resetAttributes() {
+    this.attributes = {};
+    if (!this.model.attributes) {
+      return;
+    }
+    for (var qualifiedName2 in this.model.attributes) {
+      var attribute2 = this.model.attributes[qualifiedName2];
+      if (attribute2 && attribute2.hasDefault) {
+        this.attributes[qualifiedName2] = attribute2.defaultValue;
+      }
+    }
+  }
+  notify(bucket, key) {
+    var listeners = this.after[bucket][key];
+    if (!listeners || listeners.length === 0) {
+      return;
+    }
+    delete this.after[bucket][key];
+    for (var i = 0; i < listeners.length; i++) {
+      listeners[i]();
+    }
+  }
+  onAfter(bucket, key, listener) {
+    if (!this.after[bucket][key]) {
+      this.after[bucket][key] = [];
+    }
+    this.after[bucket][key].push(listener);
+  }
+  get(name2) {
+    return this.attributes[qualifyModelName(this.model, name2)];
+  }
+  set(name2, value) {
+    var qualifiedName2 = qualifyModelName(this.model, name2);
+    var hadValue = Object.prototype.hasOwnProperty.call(this.attributes, qualifiedName2);
+    var old = this.attributes[qualifiedName2];
+    this.attributes[qualifiedName2] = value;
+    if (hadValue && old === value) {
+      return;
+    }
+    var event2 = {
+      kind: kinds.ChangeEvent,
+      name: qualifiedName2,
+      source: qualifiedName2,
+      data: {
+        name: qualifiedName2,
+        old,
+        new: value
+      }
+    };
+    this.dispatch(event2);
+  }
+  call(name2, ...args) {
+    var argsList = args;
+    var qualifiedName2 = qualifyModelName(this.model, name2);
+    var event2 = {
+      kind: kinds.CallEvent,
+      name: qualifiedName2,
+      source: qualifiedName2,
+      data: {
+        name: qualifiedName2,
+        args: argsList
+      }
+    };
+    this.dispatch(event2);
+    return this.invoke(name2, this.ctx, argsList);
+  }
+  invoke(name2, ctx, args) {
+    var qualifiedName2 = qualifyModelName(this.model, name2);
+    var operation2 = this.model.operations && this.model.operations[qualifiedName2];
+    if (!operation2) {
+      throw new Error('missing operation "' + qualifiedName2 + '"');
+    }
+    var fn = operation2.implementation;
+    if (typeof fn !== "function") {
+      throw new Error('invalid operation "' + qualifiedName2 + '"');
+    }
+    var candidates = [
+      [ctx, this.instance, ...args],
+      [ctx, ...args],
+      [this.instance, ...args],
+      args
+    ];
+    for (var i = 0; i < candidates.length; i++) {
+      var candidate = candidates[i];
+      if (fn.length === candidate.length || fn.length <= candidate.length && fn.length >= 0) {
+        return fn.apply(this.instance, candidate);
+      }
+    }
+    return fn.apply(this.instance, args);
+  }
+  restart(data) {
+    this.stop();
+    this.startData = data;
+    this.ctx.done = false;
+    this.currentState = this.model;
+    this.start();
+  }
+  takeSnapshot() {
+    var events = [];
+    var currentStateName = this.currentState ? this.currentState.qualifiedName : this.model.qualifiedName;
+    var transitionsByEvent = this.model.transitionMap[currentStateName] || {};
+    for (var eventName in transitionsByEvent) {
+      var transitionList = transitionsByEvent[eventName];
+      for (var i = 0; i < transitionList.length; i++) {
+        events.push({
+          event: eventName,
+          target: transitionList[i].target,
+          guard: !!transitionList[i].guard,
+          schema: this.model.events[eventName] ? this.model.events[eventName].schema : void 0
+        });
+      }
+    }
+    return {
+      id: this.id,
+      qualifiedName: this.model.qualifiedName,
+      state: currentStateName,
+      attributes: Object.assign({}, this.attributes),
+      queueLen: this.queue.len(),
+      events
+    };
+  }
+  recordHistory(stateName) {
+    if (!stateName) {
+      return;
+    }
+    var child = stateName;
+    var parent = dirname(child);
+    while (parent && parent !== "." && parent !== "/") {
+      var element = this.model.members[parent];
+      if (element && isKind(element.kind, kinds.State)) {
+        this.historyDeep[parent] = stateName;
+        this.historyShallow[parent] = child;
+      }
+      if (parent === this.model.qualifiedName) {
+        break;
+      }
+      child = parent;
+      parent = dirname(parent);
+    }
+  }
+  followHistoryDefault(vertex, event2) {
+    for (var i = 0; i < vertex.transitions.length; i++) {
+      var transitionName = vertex.transitions[i];
+      var transitionCandidate = getTransition(this.model, transitionName);
+      if (!transitionCandidate) {
+        continue;
+      }
+      if (transitionCandidate.guard) {
+        var guard2 = getConstraint(this.model, transitionCandidate.guard);
+        if (guard2 && !guard2.expression(this.ctx, this.instance, event2)) {
+          continue;
+        }
+      }
+      return this.transition(vertex, transitionCandidate, event2);
+    }
+    return void 0;
+  }
+  dispatch(event2) {
+    if (!event2.kind) {
+      event2.kind = kinds.Event;
+    }
+    this.queue.push(event2);
+    this.notify("dispatched", event2.name);
+    if (this.processing) {
+      return;
+    }
+    if (this.currentState.qualifiedName === this.model.qualifiedName && this.ctx.done) {
+      return;
+    }
+    this.processing = true;
+    this.process();
+  }
+  process() {
+    var deferred = new Array(this.queue.len() + 1);
+    var deferredCount = 0;
+    var event2 = this.queue.pop();
+    while (event2) {
+      var currentStateName = this.currentState.qualifiedName;
+      var eventName = event2.name;
+      var deferredLookup = this.model.deferredMap[currentStateName];
+      var isDeferred = deferredLookup && deferredLookup[eventName] === true;
+      if (isDeferred) {
+        deferred[deferredCount++] = event2;
+        event2 = this.queue.pop();
+        continue;
+      }
+      var transitions = this.model.transitionMap[currentStateName][eventName];
+      if (transitions && transitions.length > 0) {
+        for (var i = 0; i < transitions.length; i++) {
+          var transition2 = transitions[i];
+          if (transition2.guard) {
+            var guard2 = getConstraint(this.model, transition2.guard);
+            if (guard2) {
+              try {
+                var guardResult = guard2.expression(
+                  this.ctx,
+                  this.instance,
+                  event2
+                );
+                if (!guardResult) {
+                  continue;
+                }
+              } catch (error) {
+                this.dispatch(
+                  Object.create(ErrorEvent, {
+                    data: { value: error }
+                  })
+                );
+                continue;
+              }
+            }
+          }
+          var nextState = this.transition(this.currentState, transition2, event2);
+          if (nextState.qualifiedName !== this.currentState.qualifiedName) {
+            this.currentState = nextState;
+            for (var j = 0; j < deferredCount; j++) {
+              this.queue.push(deferred[j]);
+            }
+            deferredCount = 0;
+          }
+          break;
+        }
+      }
+      this.notify("processed", event2.name);
+      event2 = this.queue.pop();
+    }
+    for (var i = 0; i < deferredCount; i++) {
+      this.queue.push(deferred[i]);
+    }
+    this.processing = false;
+    this.notify("processed", "__next__");
+  }
+  transition(current, transition2, event2) {
+    var path = transition2.paths[current.qualifiedName];
+    if (!path) {
+      path = EMPTY_PATH;
+    }
+    for (var i = 0; i < path.exit.length; i++) {
+      var exitingName = path.exit[i];
+      var exiting = this.model.members[exitingName];
+      if (exiting && isStateElement(exiting)) {
+        this.exit(exiting, event2);
+        this.notify("exited", exitingName);
+      }
+    }
+    for (var i = 0; i < transition2.effect.length; i++) {
+      var effectName = transition2.effect[i];
+      var behavior = getBehavior(this.model, effectName);
+      if (behavior) {
+        this.execute(behavior, event2);
+      }
+    }
+    var enteredState;
+    for (var i = 0; i < path.enter.length; i++) {
+      var enteringName = path.enter[i];
+      var entering = getVertex(this.model, enteringName);
+      if (entering) {
+        var defaultEntry = entering.qualifiedName === transition2.target && transition2.kind !== kinds.Self;
+        enteredState = this.enter(entering, event2, defaultEntry);
+      }
+    }
+    var finalState = enteredState || getVertex(this.model, transition2.target);
+    return finalState || current;
+  }
+  enter(vertex, event2, defaultEntry) {
+    if (isStateElement(vertex)) {
+      var state2 = vertex;
+      this.recordHistory(state2.qualifiedName);
+      for (var i = 0; i < state2.entry.length; i++) {
+        var entryName = state2.entry[i];
+        var behavior = getBehavior(this.model, entryName);
+        if (behavior) {
+          this.execute(behavior, event2);
+        }
+      }
+      this.notify("entered", state2.qualifiedName);
+      for (var i = 0; i < state2.activities.length; i++) {
+        var activityName = state2.activities[i];
+        var behavior = getBehavior(this.model, activityName);
+        if (behavior) {
+          this.execute(behavior, event2);
+        }
+      }
+      if (defaultEntry && state2.initial) {
+        var initial2 = getVertex(this.model, state2.initial);
+        if (!initial2) {
+          return state2;
+        }
+        var initialTransition = getTransition(
+          this.model,
+          initial2.transitions[0]
+        );
+        if (initialTransition) {
+          return this.transition(state2, initialTransition, event2);
+        }
+      }
+      return state2;
+    }
+    if (isKind(vertex.kind, kinds.Choice) || isKind(vertex.kind, kinds.Junction)) {
+      var choiceVertex = vertex;
+      var chosenTransition = void 0;
+      for (var i = 0; i < choiceVertex.transitions.length; i++) {
+        var transitionName = choiceVertex.transitions[i];
+        var choiceTransition = getTransition(this.model, transitionName);
+        if (!choiceTransition) {
+          continue;
+        }
+        if (choiceTransition.guard) {
+          var guard2 = getConstraint(this.model, choiceTransition.guard);
+          if (guard2 && guard2.expression(this.ctx, this.instance, event2)) {
+            chosenTransition = choiceTransition;
+            break;
+          }
+        } else {
+          chosenTransition = choiceTransition;
+          break;
+        }
+      }
+      if (chosenTransition) {
+        return this.transition(choiceVertex, chosenTransition, event2);
+      }
+      throw new Error("No transition found for choice vertex " + choiceVertex.qualifiedName);
+    }
+    if (isKind(vertex.kind, kinds.ShallowHistory) || isKind(vertex.kind, kinds.DeepHistory)) {
+      var parent = dirname(vertex.qualifiedName);
+      var isShallowHistory = isKind(vertex.kind, kinds.ShallowHistory);
+      var resolved = isShallowHistory ? this.historyShallow[parent] : this.historyDeep[parent];
+      if (!resolved) {
+        var historyResult = this.followHistoryDefault(vertex, event2);
+        if (historyResult) {
+          return historyResult;
+        }
+        var parentState = getState(this.model, parent);
+        if (parentState && parentState.initial) {
+          var initialVertex = getVertex(this.model, parentState.initial);
+          if (initialVertex && initialVertex.transitions.length > 0) {
+            var initialTransition = getTransition(
+              this.model,
+              initialVertex.transitions[0]
+            );
+            if (initialTransition) {
+              return this.transition(
+                parentState,
+                initialTransition,
+                event2
+              );
+            }
+          }
+        }
+        return vertex;
+      }
+      var enterPath = [];
+      var currentPath = resolved;
+      while (currentPath && currentPath !== parent && currentPath !== ".") {
+        enterPath.unshift(currentPath);
+        currentPath = dirname(currentPath);
+      }
+      var currentVertex = vertex;
+      for (var i = 0; i < enterPath.length; i++) {
+        var entering = getVertex(this.model, enterPath[i]);
+        if (!entering) {
+          break;
+        }
+        currentVertex = this.enter(
+          entering,
+          event2,
+          isShallowHistory && i === enterPath.length - 1
+        );
+      }
+      return currentVertex;
+    }
+    if (isKind(vertex.kind, kinds.FinalState)) {
+      this.notify("entered", vertex.qualifiedName);
+      if (dirname(vertex.qualifiedName) === this.model.qualifiedName) {
+        this.stop();
+      }
+      return vertex;
+    }
+    return vertex;
+  }
+  exit(state2, event2) {
+    for (var i = 0; i < state2.activities.length; i++) {
+      var activityName = state2.activities[i];
+      var activity2 = getBehavior(this.model, activityName);
+      if (activity2) {
+        this.terminate(activity2);
+      }
+    }
+    for (var i = 0; i < state2.exit.length; i++) {
+      var exitName = state2.exit[i];
+      var behavior = getBehavior(this.model, exitName);
+      if (behavior) {
+        this.execute(behavior, event2);
+      }
+    }
+  }
+  execute(behavior, event2) {
+    var error = void 0;
+    var operation2 = behavior.operation;
+    var self = this;
+    if (!operation2 && behavior.operationName) {
+      operation2 = function(ctx, instance, evt) {
+        self.invoke(behavior.operationName, ctx, [evt]);
+      };
+    }
+    if (!operation2) {
+      return;
+    }
+    if (isKind(behavior.kind, kinds.Concurrent)) {
+      var controller = new Context();
+      try {
+        var asyncOperationPromise = Promise.resolve(
+          operation2(controller, this.instance, event2)
+        );
+        this.active[behavior.qualifiedName] = {
+          context: controller,
+          promise: asyncOperationPromise.catch(function(error2) {
+            self.dispatch(
+              Object.create(ErrorEvent, {
+                data: { value: error2 }
+              })
+            );
+          }).then(function() {
+            self.notify("executed", behavior.qualifiedName);
+            self.notify(
+              "executed",
+              behavior.Owner ? behavior.Owner() : dirname(behavior.qualifiedName)
+            );
+          })
+        };
+      } catch (err) {
+        error = err;
+      }
+    } else {
+      try {
+        operation2(this.ctx, this.instance, event2);
+        this.notify("executed", behavior.qualifiedName);
+        this.notify("executed", dirname(behavior.qualifiedName));
+      } catch (err) {
+        error = err;
+      }
+    }
+    if (error) {
+      this.dispatch(
+        Object.create(ErrorEvent, {
+          data: { value: error }
+        })
+      );
+    }
+  }
+  terminate(activity2) {
+    var active = this.active[activity2.qualifiedName];
+    if (active) {
+      active.context.done = true;
+      for (var i = 0; i < active.context.listeners.length; i++) {
+        active.context.listeners[i]();
+      }
+      delete this.active[activity2.qualifiedName];
+    }
+  }
+  stop() {
+    this.processing = true;
+    while (this.currentState && this.currentState.qualifiedName !== this.model.qualifiedName) {
+      var currentState = getState(this.model, this.currentState.qualifiedName);
+      if (!currentState) {
+        break;
+      }
+      this.exit(currentState, FinalEvent);
+      var parentState = getState(
+        this.model,
+        dirname(this.currentState.qualifiedName)
+      );
+      if (!parentState) {
+        break;
+      }
+      this.currentState = parentState;
+    }
+    this.processing = false;
+    this.ctx.done = true;
+    for (var i = 0; i < this.ctx.listeners.length; i++) {
+      this.ctx.listeners[i]();
+    }
+    delete this.ctx.instances[this.id];
+  }
+};
+function find(stack, ...kindsToMatch) {
+  for (var i = stack.length - 1; i >= 0; i--) {
+    var element = stack[i];
+    for (var j = 0; j < kindsToMatch.length; j++) {
+      if (isKind(element.kind, kindsToMatch[j])) {
+        return element;
+      }
+    }
+  }
+  return void 0;
+}
+function start(ctxOrInstance, instance, model, maybeConfig) {
+  var context = ctxOrInstance;
+  var runtimeModel = model;
+  var runtimeInstance = instance;
+  if (!(context instanceof Context)) {
+    maybeConfig = model;
+    runtimeModel = instance;
+    runtimeInstance = ctxOrInstance;
+    context = new Context();
+  }
+  var sm = new HSM(
+    context,
+    runtimeInstance,
+    runtimeModel,
+    maybeConfig
+  );
+  sm.start();
+  return runtimeInstance;
+}
+function stop(instance) {
+  var runtime = runtimeFor(instance);
+  if (runtime) {
+    runtime.stop();
+  }
+}
+function state(name2, ...partials) {
+  return attachSpec(
+    function(model, stack) {
+      var namespace = find(stack, kinds.State, kinds.Model);
+      var qualifiedName2 = join(namespace.qualifiedName, name2);
+      var stateObj = {
+        qualifiedName: qualifiedName2,
+        kind: kinds.State,
+        transitions: [],
+        entry: [],
+        exit: [],
+        activities: [],
+        deferred: []
+      };
+      model.members[stateObj.qualifiedName] = stateObj;
+      stack.push(stateObj);
+      apply(model, stack, partials);
+      stack.pop();
+      return stateObj;
+    },
+    {
+      kind: "state",
+      name: name2,
+      parts: partials
+    }
+  );
+}
+function initial(nameOrPartial, ...partials) {
+  var name2 = ".initial";
+  if (typeof nameOrPartial === "string") {
+    name2 = nameOrPartial;
+  } else if (typeof nameOrPartial === "function") {
+    partials = [nameOrPartial, ...partials];
+  }
+  return attachSpec(
+    function(model, stack) {
+      var state2 = findState(stack);
+      if (!state2) {
+        throw new Error("initial must be declared inside a state");
+      }
+      var initialName = join(state2.qualifiedName, name2);
+      var initialObj = {
+        qualifiedName: initialName,
+        kind: kinds.Initial,
+        transitions: []
+      };
+      model.members[initialName] = initialObj;
+      state2.initial = initialName;
+      var resolvedPartials = [source(initialObj.qualifiedName), on(InitialEvent), ...partials];
+      stack.push(initialObj);
+      var transitionObj = transition(...resolvedPartials)(model, stack);
+      stack.pop();
+      return transitionObj;
+    },
+    {
+      kind: "initial",
+      name: name2,
+      parts: partials
+    }
+  );
+}
+function transition(...partials) {
+  return attachSpec(
+    function(model, stack) {
+      var vertex = findVertex(stack);
+      if (!vertex) {
+        throw new Error("transition must be declared inside a vertex");
+      }
+      var name2 = "transition_" + Object.keys(model.members).length;
+      var transitionObj = {
+        qualifiedName: join(vertex.qualifiedName, name2),
+        kind: kinds.Transition,
+        // Will be updated later
+        source: ".",
+        guard: "",
+        effect: [],
+        events: [],
+        paths: {},
+        target: void 0
+      };
+      model.members[transitionObj.qualifiedName] = transitionObj;
+      stack.push(transitionObj);
+      apply(model, stack, partials);
+      stack.pop();
+      if (transitionObj.source == "." || !transitionObj.source) {
+        transitionObj.source = vertex.qualifiedName;
+      }
+      var sourceElement = getVertex(model, transitionObj.source);
+      if (!sourceElement) {
+        throw new Error("invalid transition source " + transitionObj.source);
+      }
+      sourceElement.transitions.push(transitionObj.qualifiedName);
+      model.partials.push(function() {
+        if (transitionObj.target === transitionObj.source) {
+          transitionObj.kind = kinds.Self;
+        } else if (!transitionObj.target) {
+          transitionObj.kind = kinds.Internal;
+        } else if (isAncestor(transitionObj.source, transitionObj.target)) {
+          transitionObj.kind = kinds.Local;
+        } else {
+          transitionObj.kind = kinds.External;
+        }
+        var lcaPath = lca(transitionObj.source, transitionObj.target);
+        var enter = [];
+        if (transitionObj.kind === kinds.Self) {
+          enter.push(sourceElement.qualifiedName);
+        } else {
+          var entering = transitionObj.target;
+          while (entering && entering !== lcaPath && entering !== "/") {
+            enter.unshift(entering);
+            entering = dirname(entering);
+          }
+        }
+        if (sourceElement.kind === kinds.Initial) {
+          transitionObj.paths[dirname(sourceElement.qualifiedName)] = {
+            enter,
+            exit: [sourceElement.qualifiedName]
+          };
+          return transitionObj;
+        }
+        model.partials.push(function() {
+          if (transitionObj.kind === kinds.Internal) {
+            return;
+          }
+          for (var qualifiedName2 in model.members) {
+            var element = getVertex(model, qualifiedName2);
+            if (!element) {
+              continue;
+            }
+            if (transitionObj.source !== qualifiedName2 && !isAncestor(transitionObj.source, qualifiedName2)) {
+              continue;
+            }
+            var exit2 = [];
+            var exiting = element.qualifiedName;
+            while (exiting !== lcaPath && exiting) {
+              exit2.push(exiting);
+              exiting = dirname(exiting);
+              if (exiting === "/") {
+                break;
+              }
+            }
+            transitionObj.paths[element.qualifiedName] = {
+              enter,
+              exit: exit2
+            };
+          }
+        });
+      });
+      return transitionObj;
+    },
+    {
+      kind: "transition",
+      parts: partials
+    }
+  );
+}
+function source(name2) {
+  return attachSpec(
+    function(model, stack) {
+      var transition2 = findTransition(stack);
+      if (!transition2) {
+        return void 0;
+      }
+      var resolvedName = name2;
+      if (!isAbsolute(resolvedName)) {
+        var ancestor = findState(stack);
+        if (ancestor) {
+          resolvedName = join(ancestor.qualifiedName, resolvedName);
+        }
+      } else if (!isAncestor(model.qualifiedName, resolvedName)) {
+        resolvedName = join(model.qualifiedName, resolvedName.slice(1));
+      }
+      transition2.source = resolvedName;
+      return transition2;
+    },
+    {
+      kind: "source",
+      name: name2
+    }
+  );
+}
+function target(name2) {
+  return attachSpec(
+    function(model, stack) {
+      var transition2 = findTransition(stack);
+      if (!transition2) {
+        return void 0;
+      }
+      var resolvedName = name2;
+      if (!isAbsolute(resolvedName)) {
+        var ancestor = findState(stack) || findModel(stack);
+        if (ancestor) {
+          resolvedName = join(ancestor.qualifiedName, resolvedName);
+        }
+      } else if (!isAncestor(model.qualifiedName, resolvedName)) {
+        resolvedName = join(model.qualifiedName, resolvedName.slice(1));
+      }
+      transition2.target = resolvedName;
+      return transition2;
+    },
+    {
+      kind: "target",
+      name: name2
+    }
+  );
+}
+function on(eventOrRecord) {
+  const event2 = eventOrRecord;
+  return attachSpec(
+    function(model, stack) {
+      var transition2 = findTransition(stack);
+      if (!transition2) {
+        return void 0;
+      }
+      var eventName = typeof event2 === "string" ? event2 : event2.name;
+      transition2.events.push(eventName);
+      if (typeof event2 !== "string") {
+        registerEvent(model, event2);
+      }
+      return transition2;
+    },
+    {
+      kind: "on",
+      name: typeof eventOrRecord === "string" ? eventOrRecord : eventOrRecord.name,
+      schema: typeof eventOrRecord === "string" ? void 0 : eventOrRecord.schema
+    }
+  );
+}
+function onSet(name2) {
+  return attachSpec(
+    function(model, stack) {
+      var transition2 = findTransition(stack);
+      if (!transition2) {
+        return void 0;
+      }
+      var qualifiedName2 = qualifyModelName(model, name2);
+      transition2.events.push(qualifiedName2);
+      registerEvent(model, {
+        kind: kinds.ChangeEvent,
+        name: qualifiedName2,
+        source: qualifiedName2
+      });
+      if (!model.attributes[qualifiedName2]) {
+        model.attributes[qualifiedName2] = {
+          name: name2,
+          qualifiedName: qualifiedName2,
+          hasDefault: false
+        };
+      }
+      return transition2;
+    },
+    {
+      kind: "onSet",
+      name: name2
+    }
+  );
+}
+function onCall(name2) {
+  return attachSpec(
+    function(model, stack) {
+      var transition2 = findTransition(stack);
+      if (!transition2) {
+        return void 0;
+      }
+      var qualifiedName2 = qualifyModelName(model, name2);
+      transition2.events.push(qualifiedName2);
+      registerEvent(model, {
+        kind: kinds.CallEvent,
+        name: qualifiedName2,
+        source: qualifiedName2
+      });
+      model.partials.push(function() {
+        if (!model.operations[qualifiedName2]) {
+          throw new Error('missing operation "' + qualifiedName2 + '" for OnCall()');
+        }
+      });
+      return transition2;
+    },
+    {
+      kind: "onCall",
+      name: name2
+    }
+  );
+}
+function when(expr) {
+  if (typeof expr === "string") {
+    return onSet(expr);
+  }
+  return function(model, stack) {
+    var transition2 = findTransition(stack);
+    if (!transition2) {
+      return void 0;
+    }
+    var eventName = join(transition2.qualifiedName, "when_" + Object.keys(model.members).length);
+    var event2 = {
+      kind: kinds.TimeEvent,
+      name: eventName
+    };
+    transition2.events.push(eventName);
+    registerEvent(model, event2);
+    model.partials.push(function() {
+      var source2 = getState(model, transition2.source);
+      if (!source2) {
+        return;
+      }
+      pushBehaviors(
+        join(source2.qualifiedName, "activity_when_" + source2.activities.length),
+        kinds.Concurrent,
+        source2.activities,
+        model,
+        [function(ctx, instance, evt) {
+          var signal = expr(ctx, instance, evt);
+          var signalLike = toSignalLike(signal);
+          if (!signalLike) {
+            return;
+          }
+          return new Promise(function(resolve) {
+            var once = function() {
+              if (!ctx.done) {
+                instance.dispatch(event2);
+              }
+              resolve();
+            };
+            if (hasThen(signalLike)) {
+              signalLike.then(once);
+            } else if (hasAddEventListener(signalLike)) {
+              signalLike.addEventListener("done", once);
+            } else if (hasOn(signalLike)) {
+              signalLike.on("ready", once);
+              signalLike.on("done", once);
+            }
+            ctx.addEventListener("done", resolve);
+          });
+        }]
+      );
+    });
+  };
+}
+function pushBehaviors(namePrefix, kind2, namesList, model, operations) {
+  for (var i = 0; i < operations.length; i++) {
+    var operation2 = operations[i];
+    var qualifiedName2 = namePrefix + "_" + namesList.length;
+    var behavior = {
+      qualifiedName: qualifiedName2,
+      kind: kind2,
+      operation: typeof operation2 === "function" ? operation2 : null,
+      operationName: typeof operation2 === "string" ? qualifyModelName(model, operation2) : void 0
+    };
+    model.members[qualifiedName2] = behavior;
+    namesList.push(qualifiedName2);
+  }
+}
+function entry(...operations) {
+  return attachSpec(
+    function(model, stack) {
+      var state2 = findState(stack);
+      if (!state2) {
+        return void 0;
+      }
+      pushBehaviors(join(state2.qualifiedName, "entry"), kinds.Sequential, state2.entry, model, operations);
+      return state2;
+    },
+    {
+      kind: "entry",
+      value: operations
+    }
+  );
+}
+function exit(...operations) {
+  return attachSpec(
+    function(model, stack) {
+      var state2 = findState(stack);
+      if (!state2) {
+        return void 0;
+      }
+      pushBehaviors(join(state2.qualifiedName, "exit"), kinds.Sequential, state2.exit, model, operations);
+      return state2;
+    },
+    {
+      kind: "exit",
+      value: operations
+    }
+  );
+}
+function activity(...operations) {
+  return attachSpec(
+    function(model, stack) {
+      var state2 = findState(stack);
+      if (!state2) {
+        return void 0;
+      }
+      pushBehaviors(join(state2.qualifiedName, "activity"), kinds.Concurrent, state2.activities, model, operations);
+      return state2;
+    },
+    {
+      kind: "activity",
+      value: operations
+    }
+  );
+}
+function effect(...operations) {
+  return attachSpec(
+    function(model, stack) {
+      var transition2 = findTransition(stack);
+      if (!transition2) {
+        return void 0;
+      }
+      pushBehaviors(join(transition2.qualifiedName, "effect"), kinds.Sequential, transition2.effect, model, operations);
+      return transition2;
+    },
+    {
+      kind: "effect",
+      value: operations
+    }
+  );
+}
+function guard(expression) {
+  return attachSpec(
+    function(model, stack) {
+      var transition2 = findTransition(stack);
+      if (!transition2) {
+        return void 0;
+      }
+      var name2 = join(transition2.qualifiedName, "guard");
+      var constraint = {
+        qualifiedName: name2,
+        kind: kinds.Constraint,
+        expression: typeof expression === "function" ? expression : resolveOperation(model, expression)
+      };
+      model.members[name2] = constraint;
+      transition2.guard = name2;
+    },
+    {
+      kind: "guard",
+      value: expression
+    }
+  );
+}
+function attribute(name2, maybeDefault) {
+  var hasDefault = arguments.length > 1;
+  return attachSpec(
+    function(model) {
+      var qualifiedName2 = qualifyModelName(model, name2);
+      model.attributes[qualifiedName2] = {
+        name: name2,
+        qualifiedName: qualifiedName2,
+        hasDefault,
+        defaultValue: maybeDefault
+      };
+      return void 0;
+    },
+    {
+      kind: "attribute",
+      name: name2,
+      value: maybeDefault
+    }
+  );
+}
+function operation(name2, implementation) {
+  return attachSpec(
+    function(model) {
+      var qualifiedName2 = qualifyModelName(model, name2);
+      model.operations[qualifiedName2] = {
+        name: name2,
+        qualifiedName: qualifiedName2,
+        implementation
+      };
+      return void 0;
+    },
+    {
+      kind: "operation",
+      name: name2,
+      impl: implementation
+    }
+  );
+}
+function after(duration) {
+  return attachSpec(function(model, stack) {
+    var transition2 = findTransition(stack);
+    if (!transition2) {
+      return void 0;
+    }
+    var eventName = join(transition2.qualifiedName, "after_" + Object.keys(model.members).length);
+    var event2 = {
+      name: eventName,
+      kind: kinds.TimeEvent
+    };
+    transition2.events.push(eventName);
+    registerEvent(model, event2);
+    model.partials.push(function() {
+      var source2 = getState(model, transition2.source);
+      if (!source2) {
+        return;
+      }
+      pushBehaviors(
+        join(source2.qualifiedName, "activity_after_" + source2.activities.length),
+        kinds.Concurrent,
+        // Activities can be concurrent/asynchronous
+        source2.activities,
+        model,
+        [
+          function(ctx, instance, evt) {
+            var runtime = runtimeFor(instance);
+            if (!runtime) {
+              return;
+            }
+            var delay = typeof duration === "string" ? coerceDuration(instance.get(duration)) : duration(ctx, instance, evt);
+            return withThenable(delay, function(value) {
+              if (ctx.done) {
+                return;
+              }
+              var coerceDelay = coerceDuration(value);
+              if (coerceDelay <= 0) {
+                return;
+              }
+              return new Promise(function(resolve) {
+                var timeout = runtime.clock.setTimeout(function() {
+                  instance.dispatch(event2);
+                  resolve();
+                }, coerceDelay);
+                ctx.addEventListener("done", function() {
+                  runtime.clock.clearTimeout(timeout);
+                  resolve();
+                });
+              });
+            });
+          }
+        ]
+      );
+    });
+  }, {
+    kind: "after",
+    value: duration
+  });
+}
+function every(duration) {
+  return attachSpec(function(model, stack) {
+    var transition2 = findTransition(stack);
+    if (!transition2) {
+      return void 0;
+    }
+    var eventName = join(transition2.qualifiedName, "every_" + Object.keys(model.members).length);
+    var event2 = {
+      name: eventName,
+      kind: kinds.TimeEvent
+    };
+    transition2.events.push(eventName);
+    registerEvent(model, event2);
+    model.partials.push(function() {
+      var source2 = getState(model, transition2.source);
+      if (!source2) {
+        return;
+      }
+      pushBehaviors(
+        join(source2.qualifiedName, "activity_every_" + source2.activities.length),
+        kinds.Concurrent,
+        // Activities can be concurrent/asynchronous
+        source2.activities,
+        model,
+        [
+          function(ctx, instance, evt) {
+            var runtime = runtimeFor(instance);
+            if (!runtime) {
+              return;
+            }
+            var interval = typeof duration === "string" ? coerceDuration(instance.get(duration)) : duration(ctx, instance, evt);
+            return withThenable(interval, function(value) {
+              if (ctx.done) {
+                return;
+              }
+              var coerceInterval = coerceDuration(value);
+              if (coerceInterval <= 0) {
+                return;
+              }
+              return new Promise(function(resolve) {
+                var timeout = runtime.clock.setTimeout(function tick() {
+                  if (ctx.done) {
+                    runtime.clock.clearTimeout(timeout);
+                    resolve();
+                    return;
+                  }
+                  instance.dispatch(event2);
+                  timeout = runtime.clock.setTimeout(tick, coerceInterval);
+                }, coerceInterval);
+                ctx.addEventListener("done", function() {
+                  runtime.clock.clearTimeout(timeout);
+                  resolve();
+                });
+              });
+            });
+          }
+        ]
+      );
+    });
+  }, {
+    kind: "every",
+    value: duration
+  });
+}
+function at(timepoint) {
+  return attachSpec(function(model, stack) {
+    var transition2 = findTransition(stack);
+    if (!transition2) {
+      return void 0;
+    }
+    var eventName = join(transition2.qualifiedName, "at_" + Object.keys(model.members).length);
+    var event2 = {
+      name: eventName,
+      kind: kinds.TimeEvent
+    };
+    transition2.events.push(eventName);
+    registerEvent(model, event2);
+    model.partials.push(function() {
+      var source2 = getState(model, transition2.source);
+      if (!source2) {
+        return;
+      }
+      pushBehaviors(
+        join(source2.qualifiedName, "activity_at_" + source2.activities.length),
+        kinds.Concurrent,
+        source2.activities,
+        model,
+        [function(ctx, instance, evt) {
+          var runtime = runtimeFor(instance);
+          if (!runtime) {
+            return;
+          }
+          var timepointValue = typeof timepoint === "string" ? coerceTimepoint(instance.get(timepoint)) : timepoint(ctx, instance, evt);
+          return withThenable(timepointValue, function(value) {
+            if (ctx.done) {
+              return;
+            }
+            var deadline = coerceTimepoint(value);
+            var delay = deadline - runtime.clock.now();
+            if (delay <= 0) {
+              instance.dispatch(event2);
+              return;
+            }
+            return new Promise(function(resolve) {
+              var timeout = runtime.clock.setTimeout(function() {
+                instance.dispatch(event2);
+                resolve();
+              }, delay);
+              ctx.addEventListener("done", function() {
+                runtime.clock.clearTimeout(timeout);
+                resolve();
+              });
+            });
+          });
+        }]
+      );
+    });
+  }, {
+    kind: "at",
+    value: timepoint
+  });
+}
+function defer(...eventNames) {
+  var names = eventNames;
+  return attachSpec(
+    function(model, stack) {
+      var state2 = findState(stack);
+      if (!state2) {
+        return void 0;
+      }
+      for (var i = 0; i < names.length; i++) {
+        state2.deferred.push(names[i]);
+      }
+      return state2;
+    },
+    {
+      kind: "defer",
+      eventNames
+    }
+  );
+}
+function final(name2) {
+  return attachSpec(
+    function(model, stack) {
+      var parent = findState(stack);
+      if (!parent) {
+        return void 0;
+      }
+      var qualifiedName2 = join(parent.qualifiedName, name2);
+      var finalState = {
+        qualifiedName: qualifiedName2,
+        kind: kinds.FinalState,
+        entry: [],
+        exit: [],
+        activities: [],
+        deferred: [],
+        transitions: [],
+        initial: void 0
+      };
+      model.members[qualifiedName2] = finalState;
+      return finalState;
+    },
+    {
+      kind: "final",
+      name: name2
+    }
+  );
+}
+function shallowHistory(elementOrName) {
+  var partials = slice(arguments, 1);
+  var name2 = "";
+  if (typeof elementOrName === "string") {
+    name2 = elementOrName;
+  } else if (typeof elementOrName === "function") {
+    partials.unshift(elementOrName);
+  }
+  return function(model, stack) {
+    var owner = findState(stack);
+    if (!owner) {
+      return void 0;
+    }
+    if (!name2) {
+      name2 = "shallow_history_" + Object.keys(model.members).length;
+    }
+    var qualifiedName2 = join(owner.qualifiedName, name2);
+    var history = {
+      qualifiedName: qualifiedName2,
+      kind: kinds.ShallowHistory,
+      transitions: []
+    };
+    model.members[qualifiedName2] = history;
+    stack.push(history);
+    apply(model, stack, partials);
+    stack.pop();
+    return history;
+  };
+}
+function deepHistory(elementOrName) {
+  var partials = slice(arguments, 1);
+  var name2 = "";
+  if (typeof elementOrName === "string") {
+    name2 = elementOrName;
+  } else if (typeof elementOrName === "function") {
+    partials.unshift(elementOrName);
+  }
+  return function(model, stack) {
+    var owner = findState(stack);
+    if (!owner) {
+      return void 0;
+    }
+    if (!name2) {
+      name2 = "deep_history_" + Object.keys(model.members).length;
+    }
+    var qualifiedName2 = join(owner.qualifiedName, name2);
+    var history = {
+      qualifiedName: qualifiedName2,
+      kind: kinds.DeepHistory,
+      transitions: []
+    };
+    model.members[qualifiedName2] = history;
+    stack.push(history);
+    apply(model, stack, partials);
+    stack.pop();
+    return history;
+  };
+}
+function choice(elementOrName) {
+  var partials = slice(arguments, 1);
+  var name2 = "";
+  if (typeof elementOrName === "string") {
+    name2 = elementOrName;
+  } else if (typeof elementOrName === "function") {
+    partials.unshift(elementOrName);
+  }
+  return function(model, stack) {
+    var owner = find(stack, kinds.Transition, kinds.State);
+    if (!owner) {
+      return void 0;
+    }
+    if (isTransitionElement(owner)) {
+      var transition2 = owner;
+      var source2 = transition2.source;
+      var ownerVertex = getVertex(model, source2);
+      if (!ownerVertex) {
+        return void 0;
+      }
+      if (isKind(ownerVertex.kind, kinds.Pseudostate)) {
+        owner = find(stack, kinds.State);
+      } else if (isStateElement(ownerVertex)) {
+        owner = ownerVertex;
+      } else {
+        return void 0;
+      }
+    }
+    if (!owner || !isStateElement(owner)) {
+      return void 0;
+    }
+    if (name2 === "") {
+      name2 = "choice_" + Object.keys(model.members).length;
+    }
+    var qualifiedName2 = join(owner.qualifiedName, name2);
+    var choice2 = {
+      qualifiedName: qualifiedName2,
+      kind: kinds.Choice,
+      transitions: []
+    };
+    model.members[qualifiedName2] = choice2;
+    stack.push(choice2);
+    apply(model, stack, partials);
+    stack.pop();
+    return choice2;
+  };
+}
+function dispatchAll(ctx, event2) {
+  for (var id2 in ctx.instances) {
+    var instance = ctx.instances[id2];
+    instance.dispatch(event2);
+  }
+}
+function define(name2, ...partials) {
+  var model = {
+    qualifiedName: join("/", name2),
+    kind: kinds.Model,
+    members: {},
+    transitions: [],
+    entry: [],
+    exit: [],
+    activities: [],
+    deferred: [],
+    initial: "",
+    transitionMap: {},
+    deferredMap: {},
+    events: {},
+    attributes: {},
+    operations: {},
+    partials: []
+  };
+  model.members[model.qualifiedName] = model;
+  registerEvent(model, InitialEvent);
+  registerEvent(model, FinalEvent);
+  registerEvent(model, ErrorEvent);
+  var stack = [model];
+  apply(model, stack, partials);
+  while (model.partials.length > 0) {
+    var currentPartials = model.partials.slice();
+    model.partials = [];
+    for (var i = 0; i < currentPartials.length; i++) {
+      currentPartials[i](model, stack);
+    }
+  }
+  buildTransitionTable(model);
+  buildDeferredTable(model);
+  return model;
+}
+function dispatchTo(ctx, event2, ...ids) {
+  if (!ids.length) {
+    return dispatchAll(ctx, event2);
+  }
+  for (var i = 0; i < ids.length; i++) {
+    var instance = ctx.instances[ids[i]];
+    if (instance) {
+      instance.dispatch(event2);
+    }
+  }
+}
+function get(ctxOrInstance, maybeInstanceOrName, maybeName) {
+  var instance = ctxOrInstance instanceof Context ? maybeInstanceOrName : ctxOrInstance;
+  var name2 = ctxOrInstance instanceof Context ? maybeName : maybeInstanceOrName;
+  if (ctxOrInstance instanceof Context && typeof maybeName !== "string") {
+    return void 0;
+  }
+  if (!name2) {
+    return void 0;
+  }
+  if (!instance) {
+    return void 0;
+  }
+  var runtime = runtimeFor(instance);
+  return runtime ? runtime.get(name2) : void 0;
+}
+function set(ctxOrInstance, maybeInstanceOrName, maybeNameOrValue, maybeValue) {
+  var instance = ctxOrInstance instanceof Context ? maybeInstanceOrName : ctxOrInstance;
+  var name2 = ctxOrInstance instanceof Context ? maybeNameOrValue : maybeInstanceOrName;
+  var value = ctxOrInstance instanceof Context ? maybeValue : maybeNameOrValue;
+  if (!instance) {
+    return;
+  }
+  var runtime = runtimeFor(instance);
+  if (runtime) {
+    runtime.set(name2, value);
+  }
+}
+function call(ctxOrInstance, maybeInstanceOrName, maybeName, ...args) {
+  var instance = ctxOrInstance instanceof Context ? maybeInstanceOrName : ctxOrInstance;
+  var name2 = ctxOrInstance instanceof Context ? maybeName : maybeInstanceOrName;
+  if (!instance) {
+    return void 0;
+  }
+  var callArgs = slice(arguments, ctxOrInstance instanceof Context ? 3 : 2);
+  var runtime = runtimeFor(instance);
+  if (runtime) {
+    return runtime.call(name2, ...callArgs);
+  }
+}
+function restart(instance, data) {
+  var runtime = runtimeFor(instance);
+  if (runtime) {
+    runtime.restart(data);
+  }
+}
+function takeSnapshot(ctxOrInstance, maybeInstance) {
+  var instance = ctxOrInstance instanceof Context ? maybeInstance : ctxOrInstance;
+  var runtime = runtimeFor(instance);
+  return runtime ? runtime.takeSnapshot() : {
+    id: "",
+    qualifiedName: "",
+    state: "",
+    attributes: {},
+    queueLen: 0,
+    events: []
+  };
+}
+function afterProcess(ctx, instance, maybeEvent) {
+  return new Promise(function(resolve) {
+    var runtime = runtimeFor(instance);
+    if (!runtime) {
+      resolve();
+      return;
+    }
+    if (maybeEvent) {
+      runtime.onAfter("processed", maybeEvent.name, function() {
+        resolve();
+      });
+      return;
+    }
+    if (!runtime.processing) {
+      resolve();
+      return;
+    }
+    runtime.onAfter("processed", "__next__", function() {
+      resolve();
+    });
+  });
+}
+function afterDispatch(ctx, instance, event2) {
+  return new Promise(function(resolve) {
+    var runtime = runtimeFor(instance);
+    if (!runtime) {
+      resolve();
+      return;
+    }
+    runtime.onAfter("dispatched", event2.name, function() {
+      resolve();
+    });
+  });
+}
+function afterEntry(ctx, instance, stateName) {
+  return new Promise(function(resolve) {
+    var runtime = runtimeFor(instance);
+    if (!runtime) {
+      resolve();
+      return;
+    }
+    runtime.onAfter("entered", stateName, function() {
+      resolve();
+    });
+  });
+}
+function afterExit(ctx, instance, stateName) {
+  return new Promise(function(resolve) {
+    var runtime = runtimeFor(instance);
+    if (!runtime) {
+      resolve();
+      return;
+    }
+    runtime.onAfter("exited", stateName, function() {
+      resolve();
+    });
+  });
+}
+function afterExecuted(ctx, instance, stateOrBehavior) {
+  return new Promise(function(resolve) {
+    var runtime = runtimeFor(instance);
+    if (!runtime) {
+      resolve();
+      return;
+    }
+    runtime.onAfter("executed", stateOrBehavior, function() {
+      resolve();
+    });
+  });
+}
+function id(instance) {
+  var runtime = runtimeFor(instance);
+  return runtime ? runtime.id : "";
+}
+function qualifiedName(instance) {
+  var runtime = runtimeFor(instance);
+  return runtime ? runtime.model.qualifiedName : "";
+}
+function name(instance) {
+  var runtime = runtimeFor(instance);
+  return runtime ? runtime.name : "";
+}
+function clock(instance) {
+  if (instance instanceof Group) {
+    return instance.clock();
+  }
+  var runtime = runtimeFor(instance);
+  return runtime ? runtime.clock : DefaultClock;
+}
+var Group = class _Group {
+  instances = [];
+  __hsm_group_members;
+  constructor(...instances) {
+    for (var i = 0; i < instances.length; i++) {
+      var instance = instances[i];
+      if (!instance) {
+        continue;
+      }
+      if (instance instanceof _Group) {
+        for (var j = 0; j < instance.instances.length; j++) {
+          this.instances.push(instance.instances[j]);
+        }
+        continue;
+      }
+      this.instances.push(instance);
+    }
+  }
+  dispatch(event2) {
+    for (var i = 0; i < this.instances.length; i++) {
+      this.instances[i].dispatch(event2);
+    }
+  }
+  set(name2, value) {
+    for (var i = 0; i < this.instances.length; i++) {
+      this.instances[i].set(name2, value);
+    }
+  }
+  call(name2, ...args) {
+    if (!this.instances.length) {
+      return void 0;
+    }
+    return this.instances[0].call(name2, ...args);
+  }
+  stop() {
+    for (var i = 0; i < this.instances.length; i++) {
+      stop(this.instances[i]);
+    }
+  }
+  restart(data) {
+    for (var i = 0; i < this.instances.length; i++) {
+      restart(this.instances[i], data);
+    }
+  }
+  takeSnapshot() {
+    var members = [];
+    var queueLen = 0;
+    var events = [];
+    var ids = [];
+    var qualifiedNames = [];
+    var states = [];
+    for (var i = 0; i < this.instances.length; i++) {
+      var snapshot = this.instances[i].takeSnapshot();
+      members.push(snapshot);
+      queueLen += snapshot.queueLen;
+      ids.push(snapshot.id);
+      qualifiedNames.push(snapshot.qualifiedName);
+      states.push(snapshot.state);
+      for (var j = 0; j < snapshot.events.length; j++) {
+        events.push(snapshot.events[j]);
+      }
+    }
+    return {
+      id: ids.join(","),
+      qualifiedName: qualifiedNames.join(","),
+      state: states.join(" | "),
+      attributes: {},
+      queueLen,
+      events,
+      members
+    };
+  }
+  clock() {
+    return DefaultClock;
+  }
+};
+function makeGroup() {
+  return new Group(...slice(arguments, 0));
+}
+var NullKind = kinds.Null;
+var ElementKind = kinds.Element;
+var PartialKind = kinds.Partial;
+var VertexKind = kinds.Vertex;
+var ConstraintKind = kinds.Constraint;
+var BehaviorKind = kinds.Behavior;
+var NamespaceKind = kinds.Namespace;
+var ConcurrentKind = kinds.Concurrent;
+var SequentialKind = kinds.Sequential;
+var StateMachineKind = kinds.StateMachine;
+var AttributeKind = kinds.Attribute;
+var StateKind = kinds.State;
+var ModelKind = kinds.Model;
+var TransitionKind = kinds.Transition;
+var InternalKind = kinds.Internal;
+var ExternalKind = kinds.External;
+var LocalKind = kinds.Local;
+var SelfKind = kinds.Self;
+var EventKind = kinds.Event;
+var CompletionEventKind = kinds.CompletionEvent;
+var ChangeEventKind = kinds.ChangeEvent;
+var ErrorEventKind = kinds.ErrorEvent;
+var TimeEventKind = kinds.TimeEvent;
+var CallEventKind = kinds.CallEvent;
+var PseudostateKind = kinds.Pseudostate;
+var InitialKind = kinds.Initial;
+var FinalStateKind = kinds.FinalState;
+var ChoiceKind = kinds.Choice;
+var JunctionKind = kinds.Junction;
+var DeepHistoryKind = kinds.DeepHistory;
+var ShallowHistoryKind = kinds.ShallowHistory;
+var Define = define;
+var State = state;
+var Final = final;
+var ShallowHistory = shallowHistory;
+var DeepHistory = deepHistory;
+var Choice = choice;
+var Transition = transition;
+var Initial = initial;
+var Event = event;
+var On = on;
+var OnCall = onCall;
+var OnSet = onSet;
+var When = when;
+var After = after;
+var Every = every;
+var At = at;
+var Target = target;
+var Source = source;
+var Entry = entry;
+var Exit = exit;
+var Activity = activity;
+var Effect = effect;
+var Guard = guard;
+var Defer = defer;
+var Attribute = attribute;
+var Operation = operation;
+var DispatchAll = dispatchAll;
+var DispatchTo = dispatchTo;
+var Get = get;
+var Set = set;
+var Call = call;
+var Restart = restart;
+var TakeSnapshot = takeSnapshot;
+var MakeGroup = makeGroup;
+var LCA = lca;
+var IsAncestor = isAncestor;
+var ID = id;
+var QualifiedName = qualifiedName;
+var Name = name;
+var Clock = clock;
+
+// src/muid.ts
+var defaultEpochValue = 17e11;
+var make64 = (high, low) => ({
+  high: high >>> 0,
+  low: low >>> 0
+});
+var from32 = (value) => make64(0, value >>> 0);
+var add64 = (a, b) => {
+  const low = a.low + b.low >>> 0;
+  const carry = a.low + b.low > 4294967295 ? 1 : 0;
+  const high = a.high + b.high + carry >>> 0;
+  return make64(high, low);
+};
+var sub64 = (a, b) => {
+  const low = a.low - b.low >>> 0;
+  const borrow = a.low < b.low ? 1 : 0;
+  const high = a.high - b.high - borrow >>> 0;
+  return make64(high, low);
+};
+var shl64 = (value, bits) => {
+  if (bits === 0) {
+    return value;
+  }
+  if (bits >= 64) {
+    return make64(0, 0);
+  }
+  if (bits >= 32) {
+    return make64(value.low << bits - 32, 0);
+  }
+  const high = value.high << bits | value.low >>> 32 - bits;
+  const low = value.low << bits;
+  return make64(high >>> 0, low >>> 0);
+};
+var shr64 = (value, bits) => {
+  if (bits === 0) {
+    return value;
+  }
+  if (bits >= 64) {
+    return make64(0, 0);
+  }
+  if (bits >= 32) {
+    return make64(0, value.high >>> bits - 32);
+  }
+  const low = value.low >>> bits | value.high << 32 - bits;
+  const high = value.high >>> bits;
+  return make64(high >>> 0, low >>> 0);
+};
+var or64 = (a, b) => make64((a.high | b.high) >>> 0, (a.low | b.low) >>> 0);
+var and64 = (a, b) => make64((a.high & b.high) >>> 0, (a.low & b.low) >>> 0);
+var cmp64 = (a, b) => {
+  if (a.high < b.high) {
+    return -1;
+  }
+  if (a.high > b.high) {
+    return 1;
+  }
+  if (a.low < b.low) {
+    return -1;
+  }
+  if (a.low > b.low) {
+    return 1;
+  }
+  return 0;
+};
+var gte64 = (a, b) => cmp64(a, b) >= 0;
+var toHex64 = (value) => {
+  if (value.high === 0) {
+    return value.low.toString(16);
+  }
+  const highHex = value.high.toString(16);
+  let lowHex = value.low.toString(16);
+  while (lowHex.length < 8) {
+    lowHex = `0${lowHex}`;
+  }
+  return `${highHex}${lowHex}`;
+};
+var toString64 = (value) => {
+  if (value.high === 0) {
+    return value.low.toString();
+  }
+  if (value.high < 2097152) {
+    return (value.high * 4294967296 + value.low).toString();
+  }
+  return `0x${toHex64(value)}`;
+};
+var toBase32_64 = (value) => {
+  if (value.high === 0) {
+    return value.low.toString(32);
+  }
+  const hex = toHex64(value);
+  let num = 0;
+  let result = "";
+  for (let index = 0; index < hex.length; index += 1) {
+    num = num * 16 + Number.parseInt(hex[index], 16);
+    if (num >= 32) {
+      result += (num % 32).toString(32);
+      num = Math.floor(num / 32);
+    }
+  }
+  if (num > 0) {
+    result = `${num.toString(32)}${result}`;
+  }
+  return result || "0";
+};
+var hashString = (value) => {
+  let hash = make64(2166136261, 0);
+  const prime = from32(16777619);
+  for (let index = 0; index < value.length; index += 1) {
+    const char = from32(value.charCodeAt(index));
+    hash = and64(or64(hash, char), make64(0, 4294967295));
+    if (hash.high === 0) {
+      hash = from32(hash.low * prime.low >>> 0);
+    }
+  }
+  return hash;
+};
+var getMachineIdentifier = () => {
+  if (typeof process !== "undefined") {
+    const identifier = process.env.HOSTNAME ?? process.env.COMPUTERNAME ?? process.release?.name;
+    if (identifier) {
+      return identifier;
+    }
+  }
+  if (typeof navigator !== "undefined") {
+    return `${navigator.userAgent}${navigator.platform}${navigator.hardwareConcurrency ?? ""}`;
+  }
+  return `js-${Math.random().toString(36).slice(2)}`;
+};
+var getRandomBytes = (length2) => {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.getRandomValues) {
+    const values = new Uint8Array(length2);
+    cryptoApi.getRandomValues(values);
+    return Array.from(values);
+  }
+  return Array.from({ length: length2 }, () => Math.floor(Math.random() * 256));
+};
+var getDefaultConfig = () => {
+  const epoch = make64(
+    Math.floor(defaultEpochValue / 4294967296),
+    defaultEpochValue % 4294967296
+  );
+  const timestampBitLen = 41;
+  const machineIDBitLen = 14;
+  const maxMachineID = (1 << machineIDBitLen) - 1;
+  const identifier = getMachineIdentifier();
+  let machineID;
+  if (identifier) {
+    const hash = hashString(identifier);
+    machineID = from32(hash.low & maxMachineID);
+  } else {
+    const randomBytes = getRandomBytes(4);
+    let randomValue = 0;
+    for (let index = 0; index < 4; index += 1) {
+      randomValue = randomValue << 8 | randomBytes[index];
+    }
+    machineID = from32(randomValue & maxMachineID);
+  }
+  return {
+    epoch,
+    machineID,
+    machineIDBitLen,
+    timestampBitLen
+  };
+};
+var MUID = class {
+  value;
+  constructor(value) {
+    if (typeof value === "number") {
+      this.value = from32(value);
+      return;
+    }
+    if (value && typeof value.high === "number" && typeof value.low === "number") {
+      this.value = make64(value.high, value.low);
+      return;
+    }
+    this.value = make64(0, 0);
+  }
+  toString() {
+    return toBase32_64(this.value);
+  }
+  toHex() {
+    return toHex64(this.value);
+  }
+  toDecimal() {
+    return toString64(this.value);
+  }
+  valueOf() {
+    return this.value;
+  }
+};
+var Generator = class {
+  timestampBitLen;
+  machineIDBitLen;
+  epoch;
+  shardIndex;
+  shardBitLen;
+  counterBitLen;
+  timestampBitShift;
+  machineIDShift;
+  shardIndexShift;
+  counterBitMask;
+  machineID;
+  state;
+  constructor(config = {}, shardIndex = 0, shardBitLen = 0) {
+    this.timestampBitLen = config.timestampBitLen ?? 41;
+    this.machineIDBitLen = config.machineIDBitLen ?? 14;
+    this.epoch = config.epoch ?? make64(
+      Math.floor(defaultEpochValue / 4294967296),
+      defaultEpochValue % 4294967296
+    );
+    this.shardIndex = shardIndex;
+    this.shardBitLen = shardBitLen;
+    this.counterBitLen = 64 - this.timestampBitLen - this.machineIDBitLen - this.shardBitLen;
+    this.timestampBitShift = this.machineIDBitLen + this.shardBitLen + this.counterBitLen;
+    this.machineIDShift = this.shardBitLen + this.counterBitLen;
+    this.shardIndexShift = this.counterBitLen;
+    this.counterBitMask = this.counterBitLen >= 32 ? make64(4294967295, 4294967295) : sub64(shl64(from32(1), this.counterBitLen), from32(1));
+    const machineIDMask = this.machineIDBitLen >= 32 ? make64(4294967295, 4294967295) : sub64(shl64(from32(1), this.machineIDBitLen), from32(1));
+    this.machineID = and64(config.machineID ?? from32(0), machineIDMask);
+    this.shardIndex = (this.shardIndex & (1 << Math.min(this.shardBitLen, 31)) - 1) >>> 0;
+    this.state = from32(1);
+  }
+  id() {
+    let now = sub64(from32(Date.now() & 4294967295), this.epoch);
+    const dateNow = Date.now();
+    if (dateNow > 4294967295) {
+      now = sub64(
+        make64(Math.floor(dateNow / 4294967296), dateNow & 4294967295),
+        this.epoch
+      );
+    }
+    const lastTimestamp = shr64(this.state, this.counterBitLen);
+    let counter2 = and64(this.state, this.counterBitMask);
+    if (cmp64(now, lastTimestamp) < 0) {
+      now = lastTimestamp;
+    }
+    if (cmp64(now, lastTimestamp) === 0) {
+      if (gte64(counter2, this.counterBitMask)) {
+        now = add64(now, from32(1));
+        counter2 = from32(1);
+      } else {
+        counter2 = add64(counter2, from32(1));
+      }
+    } else {
+      counter2 = from32(1);
+    }
+    this.state = or64(shl64(now, this.counterBitLen), counter2);
+    const timestampPart = shl64(now, this.timestampBitShift);
+    const machineIDPart = shl64(this.machineID, this.machineIDShift);
+    const shardIndexPart = shl64(from32(this.shardIndex), this.shardIndexShift);
+    return new MUID(
+      or64(or64(or64(timestampPart, machineIDPart), shardIndexPart), counter2)
+    );
+  }
+};
+var ShardedGenerators = class {
+  pool;
+  size;
+  index = 0;
+  constructor() {
+    const numCPU = typeof navigator !== "undefined" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
+    const shardBits = numCPU > 1 ? Math.min(Math.ceil(Math.log2(numCPU)), 5) : 0;
+    const defaultConfig = getDefaultConfig();
+    this.size = 1 << shardBits;
+    this.pool = [];
+    for (let index = 0; index < this.size; index += 1) {
+      this.pool.push(new Generator(defaultConfig, index, shardBits));
+    }
+  }
+  next() {
+    const generator = this.pool[this.index];
+    this.index = (this.index + 1) % this.size;
+    return generator;
+  }
+};
+var defaultGenerator = new Generator(getDefaultConfig(), 0, 0);
+var make = () => defaultGenerator.id();
+var newGenerator = (config = {}, shardIndex = 0, shardBitLen = 0) => new Generator(
+  {
+    ...getDefaultConfig(),
+    ...config
+  },
+  shardIndex,
+  shardBitLen
+);
+var makeMuid = (prefix) => `${prefix}-${make().toString()}`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Activity,
+  After,
+  At,
+  Attribute,
+  AttributeKind,
+  BehaviorKind,
+  Call,
+  CallEventKind,
+  ChangeEventKind,
+  Choice,
+  ChoiceKind,
+  Clock,
+  CompletionEventKind,
+  ConcurrentKind,
+  ConstraintKind,
+  Context,
+  DeepHistory,
+  DeepHistoryKind,
+  DefaultClock,
+  Defer,
+  Define,
+  DispatchAll,
+  DispatchTo,
+  Effect,
+  ElementKind,
+  Entry,
+  ErrorEvent,
+  ErrorEventKind,
+  Event,
+  EventKind,
+  Every,
+  Exit,
+  ExternalKind,
+  Final,
+  FinalEvent,
+  FinalStateKind,
+  Generator,
+  Get,
+  Group,
+  Guard,
+  ID,
+  Initial,
+  InitialEvent,
+  InitialKind,
+  Instance,
+  InternalKind,
+  IsAncestor,
+  IsKind,
+  JunctionKind,
+  Kinds,
+  LCA,
+  LocalKind,
+  MUID,
+  MakeGroup,
+  MakeKind,
+  ModelKind,
+  Name,
+  NamespaceKind,
+  NullKind,
+  On,
+  OnCall,
+  OnSet,
+  Operation,
+  PartialKind,
+  PseudostateKind,
+  QualifiedName,
+  Queue,
+  Restart,
+  SelfKind,
+  SequentialKind,
+  Set,
+  ShallowHistory,
+  ShallowHistoryKind,
+  ShardedGenerators,
+  Source,
+  State,
+  StateKind,
+  StateMachineKind,
+  TakeSnapshot,
+  Target,
+  TimeEventKind,
+  Transition,
+  TransitionKind,
+  VertexKind,
+  When,
+  activity,
+  add64,
+  after,
+  afterDispatch,
+  afterEntry,
+  afterExecuted,
+  afterExit,
+  afterProcess,
+  and64,
+  apply,
+  at,
+  attribute,
+  call,
+  choice,
+  clock,
+  cmp64,
+  deepHistory,
+  defer,
+  define,
+  dirname,
+  dispatchAll,
+  dispatchTo,
+  effect,
+  entry,
+  event,
+  every,
+  exit,
+  final,
+  find,
+  from32,
+  get,
+  getDefaultConfig,
+  guard,
+  id,
+  initial,
+  isAbsolute,
+  isAncestor,
+  isKind,
+  join,
+  kinds,
+  lca,
+  make,
+  make64,
+  makeGroup,
+  makeKind,
+  makeMuid,
+  name,
+  newGenerator,
+  on,
+  onCall,
+  onSet,
+  operation,
+  or64,
+  qualifiedName,
+  restart,
+  set,
+  shallowHistory,
+  shl64,
+  shr64,
+  source,
+  start,
+  state,
+  stop,
+  sub64,
+  takeSnapshot,
+  target,
+  transition,
+  when
+});
+//# sourceMappingURL=index.cjs.map