@sphereon/ssi-sdk.xstate-machine-persistence 0.33.1-next.3 → 0.33.1-next.73

package/dist/index.cjs

@@ -0,0 +1,1014 @@
+"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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module2) {
+    module2.exports = {
+      IMachineStatePersistence: {
+        components: {
+          schemas: {
+            MachineStateDeleteArgs: {
+              $ref: '#/components/schemas/Pick<StoreMachineStateInfo,("instanceId"|"tenantId")>'
+            },
+            'Pick<StoreMachineStateInfo,("instanceId"|"tenantId")>': {
+              type: "object",
+              properties: {
+                instanceId: {
+                  type: "string",
+                  description: "Unique instance ID of the machine"
+                },
+                tenantId: {
+                  type: "string"
+                }
+              },
+              required: ["instanceId"],
+              additionalProperties: false
+            },
+            MachineStateGetArgs: {
+              $ref: '#/components/schemas/Pick<StoreMachineStateInfo,("instanceId"|"tenantId")>'
+            },
+            MachineStateInfo: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                state: {
+                  $ref: "#/components/schemas/SerializableState"
+                },
+                instanceId: {
+                  type: "string",
+                  description: "Unique instance ID of the machine"
+                },
+                sessionId: {
+                  type: "string",
+                  description: "Session Id of the machine. Not necessarily unique"
+                },
+                machineName: {
+                  type: "string",
+                  description: "Machine name"
+                },
+                latestStateName: {
+                  type: "string",
+                  description: "The latest state name. Can be empty for a newly initialize machine"
+                },
+                latestEventType: {
+                  type: "string",
+                  description: "event types like SET_TOC, SET_FIRSTNAME, .... Will be xstate.init on a newly initialized machine"
+                },
+                createdAt: {
+                  type: "string",
+                  description: "Represents the creation date"
+                },
+                expiresAt: {
+                  type: "string",
+                  description: "Represents the expiration date"
+                },
+                updatedAt: {
+                  type: "string",
+                  description: "Represents the update date"
+                },
+                updatedCount: {
+                  type: "number",
+                  description: "Represents a counter for tracking updates."
+                },
+                completedAt: {
+                  type: "string",
+                  format: "date-time"
+                },
+                tenantId: {
+                  type: "string"
+                }
+              },
+              required: ["createdAt", "instanceId", "latestEventType", "machineName", "state", "updatedAt", "updatedCount"]
+            },
+            SerializableState: {
+              $ref: "#/components/schemas/XStateConfig<any,AnyEventObject>"
+            },
+            "XStateConfig<any,AnyEventObject>": {
+              type: "object",
+              properties: {
+                value: {
+                  $ref: "#/components/schemas/StateValue"
+                },
+                context: {},
+                _event: {
+                  $ref: "#/components/schemas/SCXML.Event<AnyEventObject>"
+                },
+                _sessionid: {
+                  type: ["string", "null"]
+                },
+                historyValue: {
+                  $ref: "#/components/schemas/HistoryValue"
+                },
+                history: {},
+                actions: {
+                  type: "array",
+                  items: {}
+                },
+                activities: {},
+                meta: {},
+                events: {
+                  type: "array",
+                  items: {
+                    $ref: "#/components/schemas/AnyEventObject"
+                  }
+                },
+                configuration: {
+                  type: "array",
+                  items: {}
+                },
+                transitions: {
+                  type: "array",
+                  items: {}
+                },
+                children: {
+                  $ref: "#/components/schemas/Record<string,any>"
+                },
+                done: {
+                  type: "boolean"
+                },
+                tags: {
+                  $ref: "#/components/schemas/Set<string>"
+                },
+                machine: {}
+              },
+              required: ["value", "context", "_event", "_sessionid", "configuration", "transitions", "children"],
+              additionalProperties: false,
+              description: "The configuration for the XState machine state. Simplified StateConfig object from XState so we have a minimal typed structure"
+            },
+            StateValue: {
+              anyOf: [
+                {
+                  type: "string"
+                },
+                {
+                  $ref: "#/components/schemas/StateValueMap"
+                }
+              ],
+              description: 'The string or object representing the state value relative to the parent state node.\n\n- For a child atomic state node, this is a string, e.g., `"pending"`.\n- For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.'
+            },
+            StateValueMap: {
+              type: "object",
+              additionalProperties: {
+                $ref: "#/components/schemas/StateValue"
+              }
+            },
+            "SCXML.Event<AnyEventObject>": {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string",
+                  description: "This is a character string giving the name of the event. The SCXML Processor must set the name field to the name of this event. It is what is matched against the 'event' attribute of <transition>. Note that transitions can do additional tests by using the value of this field inside boolean expressions in the 'cond' attribute."
+                },
+                type: {
+                  type: "string",
+                  enum: ["platform", "internal", "external"],
+                  description: `This field describes the event type. The SCXML Processor must set it to: "platform" (for events raised by the platform itself, such as error events), "internal" (for events raised by <raise> and <send> with target '_internal') or "external" (for all other events).`
+                },
+                sendid: {
+                  type: "string",
+                  description: "If the sending entity has specified a value for this, the Processor must set this field to that value (see C Event I/O Processors for details). Otherwise, in the case of error events triggered by a failed attempt to send an event, the Processor must set this field to the send id of the triggering <send> element. Otherwise it must leave it blank."
+                },
+                origin: {
+                  type: "string",
+                  description: "This is a URI, equivalent to the 'target' attribute on the <send> element. For external events, the SCXML Processor should set this field to a value which, when used as the value of 'target', will allow the receiver of the event to <send> a response back to the originating entity via the Event I/O Processor specified in 'origintype'. For internal and platform events, the Processor must leave this field blank."
+                },
+                origintype: {
+                  type: "string",
+                  description: "This is equivalent to the 'type' field on the <send> element. For external events, the SCXML Processor should set this field to a value which, when used as the value of 'type', will allow the receiver of the event to <send> a response back to the originating entity at the URI specified by 'origin'. For internal and platform events, the Processor must leave this field blank."
+                },
+                invokeid: {
+                  type: "string",
+                  description: "If this event is generated from an invoked child process, the SCXML Processor must set this field to the invoke id of the invocation that triggered the child process. Otherwise it must leave it blank."
+                },
+                data: {
+                  $ref: "#/components/schemas/AnyEventObject",
+                  description: "This field contains whatever data the sending entity chose to include in this event. The receiving SCXML Processor should reformat this data to match its data model, but must not otherwise modify it.\n\nIf the conversion is not possible, the Processor must leave the field blank and must place an error 'error.execution' in the internal event queue."
+                },
+                $$type: {
+                  type: "string",
+                  const: "scxml"
+                }
+              },
+              required: ["name", "type", "data", "$$type"],
+              additionalProperties: false
+            },
+            AnyEventObject: {
+              type: "object",
+              properties: {
+                type: {
+                  type: "string",
+                  description: "The type of event that is sent."
+                }
+              },
+              required: ["type"]
+            },
+            HistoryValue: {
+              type: "object",
+              properties: {
+                states: {
+                  $ref: "#/components/schemas/Record<string,(interface-434048446-6094-6223-434048446-0-57488|undefined)>"
+                },
+                current: {
+                  $ref: "#/components/schemas/StateValue"
+                }
+              },
+              required: ["states"],
+              additionalProperties: false
+            },
+            "Record<string,(interface-434048446-6094-6223-434048446-0-57488|undefined)>": {
+              type: "object",
+              additionalProperties: {
+                anyOf: [
+                  {
+                    $ref: "#/components/schemas/HistoryValue"
+                  },
+                  {
+                    not: {}
+                  }
+                ]
+              }
+            },
+            "Record<string,any>": {
+              type: "object"
+            },
+            "Set<string>": {
+              type: "object",
+              properties: {
+                size: {
+                  type: "number"
+                }
+              },
+              required: ["size"],
+              additionalProperties: false
+            },
+            InitMachineStateArgs: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                cleanupAllOtherInstances: {
+                  type: "boolean"
+                },
+                customInstanceId: {
+                  type: "string"
+                },
+                existingInstanceId: {
+                  type: "string"
+                },
+                machineName: {
+                  type: "string",
+                  description: "Machine name"
+                },
+                tenantId: {
+                  type: "string"
+                },
+                createdAt: {
+                  type: "string",
+                  description: "Represents the creation date"
+                },
+                expiresAt: {
+                  type: "string",
+                  description: "Represents the expiration date"
+                },
+                stateType: {
+                  $ref: "#/components/schemas/MachineStateInitType"
+                },
+                machineState: {
+                  $ref: "#/components/schemas/MachineStateInfo"
+                }
+              },
+              required: ["machineName"]
+            },
+            MachineStateInitType: {
+              type: "string",
+              enum: ["new", "existing"]
+            },
+            MachineStateInit: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                stateType: {
+                  $ref: "#/components/schemas/MachineStateInitType"
+                },
+                machineState: {
+                  $ref: "#/components/schemas/MachineStateInfo"
+                },
+                instanceId: {
+                  type: "string",
+                  description: "Unique instance ID of the machine"
+                },
+                machineName: {
+                  type: "string",
+                  description: "Machine name"
+                },
+                tenantId: {
+                  type: "string"
+                },
+                createdAt: {
+                  type: "string",
+                  description: "Represents the creation date"
+                },
+                expiresAt: {
+                  type: "string",
+                  description: "Represents the expiration date"
+                }
+              },
+              required: ["createdAt", "instanceId", "machineName", "stateType"]
+            },
+            MachineStatePersistArgs: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                cleanupOnFinalState: {
+                  type: "boolean"
+                },
+                updatedCount: {
+                  type: "number",
+                  description: "Represents a counter for tracking updates."
+                },
+                state: {
+                  $ref: "#/components/schemas/SerializableState"
+                },
+                instanceId: {
+                  type: "string",
+                  description: "Unique instance ID of the machine"
+                },
+                machineName: {
+                  type: "string",
+                  description: "Machine name"
+                },
+                tenantId: {
+                  type: "string"
+                },
+                expiresAt: {
+                  type: "string",
+                  description: "Represents the expiration date"
+                },
+                stateType: {
+                  $ref: "#/components/schemas/MachineStateInitType"
+                },
+                machineState: {
+                  $ref: "#/components/schemas/MachineStateInfo"
+                }
+              },
+              required: ["instanceId", "machineName", "state", "stateType"],
+              description: "Represents the arguments required to persist the machine state."
+            },
+            DeleteExpiredStatesArgs: {
+              $ref: '#/components/schemas/Pick<StoreMachineStateDeleteExpiredArgs,("deleteDoneStates"|"machineName"|"tenantId")>',
+              description: "Represents the arguments for deleting expired states from a machine."
+            },
+            'Pick<StoreMachineStateDeleteExpiredArgs,("deleteDoneStates"|"machineName"|"tenantId")>': {
+              type: "object",
+              properties: {
+                deleteDoneStates: {
+                  type: "boolean"
+                },
+                machineName: {
+                  type: "string"
+                },
+                tenantId: {
+                  type: "string"
+                }
+              },
+              additionalProperties: false
+            },
+            DeleteStateResult: {
+              type: "number"
+            },
+            FindActiveStatesArgs: {
+              $ref: "#/components/schemas/StoreMachineStatesFindActiveArgs",
+              description: "Represents the arguments for finding active states of a store machine."
+            },
+            StoreMachineStatesFindActiveArgs: {
+              $ref: '#/components/schemas/Partial<Pick<StoreMachineStateInfo,("machineName"|"tenantId"|"instanceId")>>'
+            },
+            'Partial<Pick<StoreMachineStateInfo,("machineName"|"tenantId"|"instanceId")>>': {
+              type: "object",
+              properties: {
+                machineName: {
+                  type: "string",
+                  description: "Machine name"
+                },
+                tenantId: {
+                  type: "string"
+                },
+                instanceId: {
+                  type: "string",
+                  description: "Unique instance ID of the machine"
+                }
+              },
+              additionalProperties: false
+            }
+          },
+          methods: {
+            machineStateDelete: {
+              description: "Delete a particular machine state by instance id and tenant id",
+              arguments: {
+                $ref: "#/components/schemas/MachineStateDeleteArgs"
+              },
+              returnType: {
+                type: "boolean"
+              }
+            },
+            machineStateGet: {
+              description: "Get a particular machine state by instance id and tenant id",
+              arguments: {
+                $ref: "#/components/schemas/MachineStateGetArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/MachineStateInfo"
+              }
+            },
+            machineStateInit: {
+              description: "Initializes a state object for a new machine. Does not persist anything",
+              arguments: {
+                $ref: "#/components/schemas/InitMachineStateArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/MachineStateInit"
+              }
+            },
+            machineStatePersist: {
+              description: "Persists the state",
+              arguments: {
+                $ref: "#/components/schemas/MachineStatePersistArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/MachineStateInfo"
+              }
+            },
+            machineStatesDeleteExpired: {
+              description: "Deletes the state of an xstate machine in the database.",
+              arguments: {
+                $ref: "#/components/schemas/DeleteExpiredStatesArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/DeleteStateResult"
+              }
+            },
+            machineStatesFindActive: {
+              description: "Loads the states of active xstate machines from the database.",
+              arguments: {
+                $ref: "#/components/schemas/FindActiveStatesArgs"
+              },
+              returnType: {
+                type: "array",
+                items: {
+                  $ref: "#/components/schemas/MachineStateInfo"
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MachineStatePersistEventType: () => MachineStatePersistEventType,
+  MachineStatePersistence: () => MachineStatePersistence,
+  deserializeMachineState: () => deserializeMachineState,
+  emitMachineStatePersistEvent: () => emitMachineStatePersistEvent,
+  interpreterResumeFromState: () => interpreterResumeFromState,
+  interpreterStartOrResume: () => interpreterStartOrResume,
+  interpreterStartOrResumeFromInit: () => interpreterStartOrResumeFromInit,
+  machineStatePersistInit: () => machineStatePersistInit,
+  machineStatePersistOnTransition: () => machineStatePersistOnTransition,
+  machineStatePersistRegistration: () => machineStatePersistRegistration,
+  machineStateToMachineInit: () => machineStateToMachineInit,
+  machineStateToStoreInfo: () => machineStateToStoreInfo,
+  schema: () => schema,
+  serializeMachineState: () => serializeMachineState,
+  storeInfoToMachineInit: () => storeInfoToMachineInit
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agent/MachineStatePersistence.ts
+var import_debug2 = __toESM(require("debug"), 1);
+var import_uuid = require("uuid");
+
+// src/functions/machineRegistration.ts
+var import_xstate2 = require("xstate");
+var import_waitFor = require("xstate/lib/waitFor");
+
+// src/types/types.ts
+var MachineStatePersistEventType = /* @__PURE__ */ function(MachineStatePersistEventType2) {
+  MachineStatePersistEventType2["INIT"] = "INIT";
+  MachineStatePersistEventType2["EVERY"] = "EVERY";
+  return MachineStatePersistEventType2;
+}({});
+
+// src/functions/stateEventEmitter.ts
+var import_debug = __toESM(require("debug"), 1);
+var debug = (0, import_debug.default)("sphereon:ssi-sdk:machine-state:xstate-persistence");
+var emitMachineStatePersistEvent = /* @__PURE__ */ __name((event, context) => {
+  debug(`Emitting machine state persistence event '${event.type}' with counter: ${event.data._eventCounter} and state ${JSON.stringify(event.data.state.value)}`);
+  void context.agent.emit(event.type, event.data);
+}, "emitMachineStatePersistEvent");
+
+// src/functions/stateMapper.ts
+var import_xstate = require("xstate");
+var machineStateToStoreInfo = /* @__PURE__ */ __name((machineInfo, existingState) => {
+  const { state, machineName, tenantId, expiresAt, instanceId, updatedCount } = machineInfo;
+  const existing = existingState ?? {
+    machineName,
+    createdAt: /* @__PURE__ */ new Date(),
+    expiresAt
+  };
+  const stateInstance = import_xstate.State.create(machineInfo.state);
+  let latestStateName = void 0;
+  if (stateInstance.value) {
+    latestStateName = typeof stateInstance.value === "string" ? stateInstance.value : JSON.stringify(stateInstance.value);
+  }
+  if (latestStateName === "{}") {
+    latestStateName = void 0;
+  }
+  return {
+    instanceId,
+    updatedCount: updatedCount ?? (existing?.updatedCount ? existing.updatedCount++ : 0),
+    sessionId: stateInstance._sessionid ?? void 0,
+    machineName,
+    state: serializeMachineState(state),
+    tenantId,
+    latestStateName,
+    latestEventType: stateInstance.event.type,
+    updatedAt: /* @__PURE__ */ new Date(),
+    expiresAt,
+    createdAt: existing.createdAt ?? /* @__PURE__ */ new Date(),
+    completedAt: existing.completedAt ?? (stateInstance.done ? /* @__PURE__ */ new Date() : void 0)
+  };
+}, "machineStateToStoreInfo");
+var storeInfoToMachineInit = /* @__PURE__ */ __name((args) => {
+  const { instanceId, machineName, tenantId, expiresAt, createdAt, stateType, machineState } = args;
+  return {
+    stateType,
+    machineName,
+    tenantId,
+    expiresAt,
+    instanceId,
+    createdAt,
+    machineState
+  };
+}, "storeInfoToMachineInit");
+var machineStateToMachineInit = /* @__PURE__ */ __name((machineInfo, existingState) => {
+  return storeInfoToMachineInit({
+    ...machineStateToStoreInfo(machineInfo, existingState),
+    stateType: "existing",
+    machineState: machineInfo.machineState
+  });
+}, "machineStateToMachineInit");
+var serializeMachineState = /* @__PURE__ */ __name((state) => {
+  if (typeof state === "string") {
+    return state;
+  }
+  const jsonState = "toJSON" in state ? state.toJSON() : state;
+  return JSON.stringify(jsonState);
+}, "serializeMachineState");
+var deserializeMachineState = /* @__PURE__ */ __name((state) => {
+  return import_xstate.State.create(JSON.parse(state));
+}, "deserializeMachineState");
+
+// src/functions/machineRegistration.ts
+var machineStatePersistInit = /* @__PURE__ */ __name(async (opts) => {
+  const { context, ...args } = opts;
+  if (!(context.agent.availableMethods().includes("machineStateInit") && "machineStateInit" in context.agent)) {
+    console.log(`IMachineStatePersistence was not exposed in the current agent. Not initializing new persistence object`);
+    return;
+  }
+  return await context.agent.machineStateInit(args);
+}, "machineStatePersistInit");
+var machineStatePersistOnTransition = /* @__PURE__ */ __name(async (opts) => {
+  const { cleanupOnFinalState, context, init, interpreter } = opts;
+  const { machineState, ...initEventData } = init;
+  if (!(context.agent.availableMethods().includes("machineStatePersist") && "machineStatePersist" in context.agent)) {
+    console.log(`IMachineStatePersistence was not exposed in the current agent. Disabling machine state persistence events`);
+    return;
+  }
+  let _eventCounter = init.machineState?.updatedCount ?? 0;
+  interpreter.onChange(async (_machineContext) => {
+    emitMachineStatePersistEvent({
+      type: MachineStatePersistEventType.EVERY,
+      data: {
+        ...initEventData,
+        state: interpreter.getSnapshot(),
+        _eventCounter: ++_eventCounter,
+        _eventDate: /* @__PURE__ */ new Date(),
+        _cleanupOnFinalState: cleanupOnFinalState !== false
+      }
+    }, context);
+  });
+  if (cleanupOnFinalState && context.agent.availableMethods().includes("machineStateDelete")) {
+    interpreter.onDone((doneEvent) => {
+      ;
+      context.agent.machineStateDelete({
+        tenantId: initEventData.tenantId,
+        instanceId: initEventData.instanceId
+      });
+    });
+  }
+}, "machineStatePersistOnTransition");
+var machineStatePersistRegistration = /* @__PURE__ */ __name(async (args) => {
+  const { disablePersistence } = args;
+  if (disablePersistence === true) {
+    return;
+  }
+  const expiresAt = args.expireInMS ? new Date(Date.now() + args.expireInMS) : args.expiresAt;
+  const machineName = args.machineName ?? args.interpreter.machine.id ?? args.interpreter.id;
+  const init = await machineStatePersistInit({
+    ...args,
+    machineName,
+    expiresAt
+  });
+  if (init) {
+    await machineStatePersistOnTransition({
+      ...args,
+      init
+    });
+  }
+  return init;
+}, "machineStatePersistRegistration");
+var assertNonExpired = /* @__PURE__ */ __name((args) => {
+  const { expiresAt, machineName } = args;
+  if (expiresAt && expiresAt.getTime() < Date.now()) {
+    throw new Error(`Cannot resume ${machineName}. It expired at ${expiresAt.toLocaleString()}`);
+  }
+}, "assertNonExpired");
+var interpreterResumeFromState = /* @__PURE__ */ __name(async (args) => {
+  const { interpreter, machineState, context, noRegistration, cleanupAllOtherInstances, cleanupOnFinalState } = args;
+  const { machineName, instanceId, tenantId } = machineState;
+  assertNonExpired(machineState);
+  if (noRegistration !== true) {
+    await machineStatePersistRegistration({
+      stateType: "existing",
+      machineName,
+      tenantId,
+      existingInstanceId: instanceId,
+      cleanupAllOtherInstances,
+      cleanupOnFinalState,
+      context,
+      interpreter
+    });
+  }
+  const state = import_xstate2.State.from(machineState.state.value, machineState.state.context);
+  interpreter.start(state);
+  await (0, import_waitFor.waitFor)(interpreter, (awaitState) => awaitState.matches(state.value));
+  return {
+    machineState,
+    init: machineStateToMachineInit({
+      ...machineState,
+      stateType: "existing"
+    }, machineStateToStoreInfo({
+      ...machineState,
+      stateType: "existing"
+    })),
+    interpreter
+  };
+}, "interpreterResumeFromState");
+var interpreterStartOrResumeFromInit = /* @__PURE__ */ __name(async (args) => {
+  const { init, noRegistration, interpreter, cleanupOnFinalState, cleanupAllOtherInstances, context } = args;
+  const { stateType, instanceId, machineName, tenantId, expiresAt } = init;
+  if (init.machineName !== interpreter.id) {
+    throw new Error(`Machine state init machine name ${init.machineName} does not match name from state machine interpreter ${interpreter.id}`);
+  }
+  assertNonExpired({
+    machineName,
+    expiresAt
+  });
+  if (noRegistration !== true) {
+    await machineStatePersistRegistration({
+      stateType: stateType ?? "existing",
+      machineName,
+      tenantId,
+      ...stateType === "existing" && {
+        existingInstanceId: instanceId
+      },
+      ...stateType === "new" && {
+        customInstanceId: instanceId
+      },
+      cleanupAllOtherInstances,
+      cleanupOnFinalState,
+      context,
+      interpreter
+    });
+  }
+  let machineState;
+  if (stateType === "new") {
+    interpreter.start();
+  } else {
+    machineState = await context.agent.machineStateGet({
+      tenantId,
+      instanceId
+    });
+    interpreter.start(machineState.state);
+  }
+  await new Promise((res) => setTimeout(res, 50));
+  return {
+    interpreter,
+    machineState,
+    init
+  };
+}, "interpreterStartOrResumeFromInit");
+var interpreterStartOrResume = /* @__PURE__ */ __name(async (args) => {
+  const { stateType, singletonCheck, instanceId, tenantId, noRegistration, context, interpreter, cleanupAllOtherInstances, cleanupOnFinalState } = args;
+  const machineName = args.machineName ?? interpreter.id;
+  let activeStates = await context.agent.machineStatesFindActive({
+    machineName,
+    tenantId,
+    instanceId
+  });
+  if (stateType === "new" && activeStates.length > 0 && cleanupAllOtherInstances) {
+    await Promise.all(activeStates.map((state) => context.agent.machineStateDelete({
+      tenantId: args.tenantId,
+      instanceId: state.instanceId
+    })));
+    activeStates = await context.agent.machineStatesFindActive({
+      machineName,
+      tenantId,
+      instanceId
+    });
+  }
+  if (singletonCheck && activeStates.length > 0) {
+    if (stateType === "new" || stateType === "existing" && (!instanceId && activeStates.length > 1 || instanceId && activeStates.every((state) => state.instanceId !== instanceId))) {
+      return Promise.reject(new Error(`Found ${activeStates.length} active '${machineName}' instances, but only one is allows at the same time`));
+    }
+  }
+  if (stateType === "new") {
+    if (instanceId && activeStates.length > 0) {
+      return Promise.reject(new Error(`Found an active '${machineName}' instance with id ${instanceId}, but a new instance was requested with the same id`));
+    }
+    const init = await context.agent.machineStateInit({
+      stateType: "new",
+      customInstanceId: instanceId,
+      machineName: machineName ?? interpreter.id,
+      tenantId,
+      cleanupAllOtherInstances
+    });
+    return await interpreterStartOrResumeFromInit({
+      init,
+      noRegistration,
+      interpreter,
+      context,
+      cleanupOnFinalState,
+      cleanupAllOtherInstances
+    });
+  }
+  if (activeStates.length === 0) {
+    if (stateType === "existing") {
+      return Promise.reject(new Error(`Could not find existing state machine ${machineName}, instanceId ${instanceId}`));
+    }
+    const init = await context.agent.machineStateInit({
+      stateType: "new",
+      customInstanceId: instanceId,
+      machineName: machineName ?? interpreter.id,
+      tenantId,
+      cleanupAllOtherInstances
+    });
+    return await interpreterStartOrResumeFromInit({
+      init,
+      noRegistration,
+      interpreter,
+      context,
+      cleanupOnFinalState,
+      cleanupAllOtherInstances
+    });
+  }
+  const activeState = activeStates[0];
+  return interpreterResumeFromState({
+    machineState: activeState,
+    noRegistration,
+    interpreter,
+    context,
+    cleanupOnFinalState,
+    cleanupAllOtherInstances
+  });
+}, "interpreterStartOrResume");
+
+// src/agent/MachineStatePersistence.ts
+var debug2 = (0, import_debug2.default)("sphereon:ssi-sdk:machine-state:xstate-persistence");
+var MachineStatePersistence = class {
+  static {
+    __name(this, "MachineStatePersistence");
+  }
+  schema = schema.IMachineStatePersistence;
+  methods;
+  eventTypes;
+  _store;
+  get store() {
+    if (!this._store) {
+      throw Error("No store available in options");
+    }
+    return this._store;
+  }
+  constructor(opts) {
+    const { store, eventTypes, isRESTClient } = opts;
+    this.eventTypes = eventTypes;
+    this.methods = {
+      machineStatesFindActive: this.machineStatesFindActive.bind(this),
+      machineStatesDeleteExpired: this.machineStatesDeleteExpired.bind(this),
+      machineStateInit: this.machineStateInit.bind(this),
+      machineStatePersist: this.machineStatePersist.bind(this),
+      machineStateGet: this.machineStateGet.bind(this),
+      machineStateDelete: this.machineStateDelete.bind(this)
+    };
+    this._store = store;
+    if (isRESTClient) {
+      return;
+    } else if (!store) {
+      throw Error("No store available in options");
+    }
+  }
+  async onEvent(event, context) {
+    debug2(`Received machine state persistence event '${event.type}' counter: ${event.data._eventCounter}}`);
+    if (!this.eventTypes.includes(event.type)) {
+      console.log(`event type ${event.type} not registered for agent. Registered: ${JSON.stringify(this.eventTypes)}`);
+      return;
+    }
+    switch (event.type) {
+      case MachineStatePersistEventType.INIT:
+        await context.agent.machineStateInit({
+          ...event.data
+        });
+        break;
+      case MachineStatePersistEventType.EVERY:
+        await context.agent.machineStatePersist({
+          ...event.data,
+          cleanupOnFinalState: event.data.cleanupOnFinalState ?? event.data._cleanupOnFinalState,
+          updatedCount: event.data._eventCounter ?? event.data.updatedCount
+        });
+        break;
+      default:
+        return Promise.reject(Error(`Event type ${event.type} not supported`));
+    }
+  }
+  async machineStateInit(args, context) {
+    const { tenantId, machineName, expiresAt, customInstanceId, existingInstanceId, cleanupAllOtherInstances } = args;
+    debug2(`machineStateInit for machine name ${machineName}, tenant ${tenantId}, custom instance ${customInstanceId}, existing id ${existingInstanceId}`);
+    if (customInstanceId && existingInstanceId) {
+      return Promise.reject(new Error(`Cannot have both a custom and existing instance id at the same time`));
+    }
+    if (cleanupAllOtherInstances) {
+      await context.agent.machineStatesDeleteExpired({
+        machineName,
+        tenantId,
+        deleteDoneStates: true
+      });
+      await context.agent.machineStatesDeleteExpired({
+        machineName,
+        tenantId,
+        deleteDoneStates: false
+      });
+      const activeMachineStates = (await context.agent.machineStatesFindActive({
+        machineName,
+        tenantId
+      })).filter((state) => !existingInstanceId || state.instanceId !== existingInstanceId);
+      await Promise.all(activeMachineStates.map((state) => context.agent.machineStateDelete({
+        instanceId: state.instanceId,
+        tenantId
+      })));
+    }
+    let machineInit = void 0;
+    let machineState;
+    if (existingInstanceId) {
+      debug2(`machineStateInit is using a previously persisted instance id (${existingInstanceId})`);
+      machineState = await context.agent.machineStateGet({
+        tenantId,
+        instanceId: existingInstanceId
+      });
+      machineInit = machineStateToMachineInit({
+        ...machineState,
+        machineState,
+        stateType: "existing"
+      }, {
+        ...machineState,
+        state: serializeMachineState(machineState.state)
+      });
+    }
+    if (customInstanceId) {
+      debug2(`machineStateInit is using a custom instance id (${customInstanceId})`);
+    }
+    if (!machineInit) {
+      machineInit = {
+        machineName,
+        tenantId,
+        expiresAt,
+        instanceId: customInstanceId ?? (0, import_uuid.v4)(),
+        createdAt: args.createdAt ?? /* @__PURE__ */ new Date(),
+        stateType: "new"
+      };
+    }
+    return machineInit;
+  }
+  async machineStatePersist(args, context) {
+    const { instanceId, tenantId, machineName, updatedCount } = args;
+    const cleanupOnFinalState = args.cleanupOnFinalState !== false;
+    debug2(`machineStatePersist for machine name ${machineName}, updateCount: ${updatedCount}, instance ${instanceId} and tenant ${tenantId}...`);
+    try {
+      const queriedStates = await this.store.findMachineStates({
+        filter: [
+          {
+            instanceId,
+            tenantId
+          }
+        ]
+      });
+      const existingState = queriedStates.length === 1 ? queriedStates[0] : void 0;
+      const storeInfoArgs = machineStateToStoreInfo(args, existingState);
+      let storedState;
+      if (updatedCount !== void 0 && updatedCount > 1 && storeInfoArgs.latestEventType === "xstate.init") {
+        console.log(`Not persisting machine state for resumed init event for machine ${machineName}, tenant ${tenantId} and state with id ${instanceId}`);
+        storedState = storeInfoArgs;
+      } else {
+        storedState = await this.store.persistMachineState(storeInfoArgs);
+      }
+      const machineStateInfo = {
+        ...storedState,
+        state: deserializeMachineState(storedState.state)
+      };
+      debug2(`machineStatePersist success for machine name ${machineName}, instance ${instanceId}, update count ${machineStateInfo.updatedCount}, tenant ${tenantId}, last event: ${machineStateInfo.latestEventType}, last state: ${machineStateInfo.latestStateName}`);
+      if (cleanupOnFinalState && machineStateInfo.state.done) {
+        debug2(`reached final state for machine ${machineName} instance ${instanceId} and auto cleanup was enabled. Deleting machine state`);
+        await context.agent.machineStateDelete(machineStateInfo);
+      }
+      return machineStateInfo;
+    } catch (error) {
+      console.log(error);
+      return Promise.reject(error);
+    }
+  }
+  async machineStatesFindActive(args) {
+    const { machineName, tenantId } = args;
+    debug2(`machineStateFindActive for machine name ${machineName} and tenant ${tenantId}...`);
+    const storedStates = await this.store.findActiveMachineStates(args);
+    const machineStateInfos = storedStates.map((storedState) => {
+      return {
+        ...storedState,
+        state: deserializeMachineState(storedState.state)
+      };
+    });
+    debug2(`machineStateFindActive returned ${machineStateInfos.length} results for machine name ${machineName} and tenant ${tenantId}`);
+    return machineStateInfos;
+  }
+  async machineStatesDeleteExpired(args) {
+    const { machineName, tenantId } = args;
+    debug2(`machineStatesDeleteExpired for machine name ${machineName} and tenant ${tenantId}...`);
+    const deleteResult = await this.store.deleteExpiredMachineStates(args);
+    debug2(`machineStatesDeleteExpired result for machine name ${machineName} and tenant ${tenantId}: ${deleteResult}`);
+    return deleteResult;
+  }
+  async machineStateGet(args, context) {
+    const { instanceId, tenantId } = args;
+    debug2(`machineStateGet for machine instance ${instanceId} and tenant ${tenantId}...`);
+    const storedState = await this.store.getMachineState(args);
+    const machineInfo = {
+      ...storedState,
+      state: deserializeMachineState(storedState.state)
+    };
+    debug2(`machineStateGet success for machine instance ${instanceId} and tenant ${tenantId}`);
+    return machineInfo;
+  }
+  async machineStateDelete(args, context) {
+    const { instanceId, tenantId } = args;
+    debug2(`machineStateDelete for machine instance ${instanceId} and tenant ${tenantId}...`);
+    const deleteResult = await this.store.deleteMachineState(args);
+    debug2(`machineStateDelete result for machine instance ${instanceId} and tenant ${tenantId}: ${deleteResult}`);
+    return deleteResult;
+  }
+};
+
+// src/index.ts
+var schema = require_plugin_schema();
+//# sourceMappingURL=index.cjs.map