@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/utils/process/index.cjs

@@ -0,0 +1,743 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/process/index.ts
+var process_exports = {};
+__export(process_exports, {
+  processInstanceKeyOf: () => processInstanceKeyOf,
+  processManager: () => processManager,
+  processStateKeyOf: () => processStateKeyOf
+});
+module.exports = __toCommonJS(process_exports);
+var import_core3 = require("@graphrefly/pure-ts/core");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+var import_graph2 = require("@graphrefly/pure-ts/graph");
+
+// src/base/mutation/index.ts
+var import_core = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+var import_graph = require("@graphrefly/pure-ts/graph");
+var DEFAULT_AUDIT_GUARD = (0, import_core.policy)((allow, deny) => {
+  allow("observe");
+  allow("signal");
+  deny("write");
+});
+function createAuditLog(opts) {
+  const log = (0, import_extra.reactiveLog)([], {
+    name: opts.name,
+    maxSize: opts.retainedLimit ?? 1024,
+    guard: opts.guard ?? DEFAULT_AUDIT_GUARD,
+    ...opts.versioning != null ? { versioning: opts.versioning } : {}
+  });
+  log.withLatest();
+  if (opts.graph) {
+    opts.graph.add(log.entries, { name: opts.name });
+  }
+  return log;
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const k of Object.keys(value)) {
+    deepFreeze(value[k]);
+  }
+  return Object.freeze(value);
+}
+function mutate(act, opts) {
+  const { up, down } = typeof act === "function" ? { up: act, down: void 0 } : act;
+  const freeze = opts.freeze ?? true;
+  if (opts.frame === "inline") {
+    return function wrapped(...args) {
+      const sealed = freeze ? args.map(deepFreeze) : args;
+      const t_ns = (0, import_core.wallClockNs)();
+      const seq = opts.seq ? bumpCursor(opts.seq) : void 0;
+      try {
+        const result = up(...sealed);
+        if (opts.log && opts.onSuccessRecord) {
+          appendAudit(
+            opts.log,
+            opts.onSuccessRecord,
+            sealed,
+            result,
+            { t_ns, seq },
+            opts.handlerVersion
+          );
+        }
+        return result;
+      } catch (err) {
+        if (opts.log && opts.onFailureRecord) {
+          const errorType = err instanceof Error ? err.name : typeof err;
+          appendAudit(
+            opts.log,
+            opts.onFailureRecord,
+            sealed,
+            err,
+            { t_ns, seq, errorType },
+            opts.handlerVersion
+          );
+        }
+        throw err;
+      }
+    };
+  }
+  return function wrapped(...args) {
+    const sealed = freeze ? args.map(deepFreeze) : args;
+    const t_ns = (0, import_core.wallClockNs)();
+    let result;
+    let captured;
+    let captureSet = false;
+    let seq;
+    try {
+      (0, import_core.batch)(() => {
+        if (opts.seq) seq = bumpCursor(opts.seq);
+        try {
+          result = up(...sealed);
+          if (opts.log && opts.onSuccessRecord) {
+            appendAudit(
+              opts.log,
+              opts.onSuccessRecord,
+              sealed,
+              result,
+              { t_ns, seq },
+              opts.handlerVersion
+            );
+          }
+        } catch (err) {
+          captured = err;
+          captureSet = true;
+          throw err;
+        }
+      });
+    } catch (outerErr) {
+      if (captureSet && down) {
+        try {
+          down(...sealed);
+        } catch (downErr) {
+          console.error(
+            `mutate: down hook threw \u2014 original action error preserved (${captured instanceof Error ? captured.name : typeof captured}). Down error:`,
+            downErr
+          );
+        }
+      }
+      if (captureSet && opts.log && opts.onFailureRecord) {
+        const errorType = captured instanceof Error ? captured.name : typeof captured;
+        appendAudit(
+          opts.log,
+          opts.onFailureRecord,
+          sealed,
+          captured,
+          { t_ns, seq, errorType },
+          opts.handlerVersion
+        );
+      }
+      throw captureSet ? captured : outerErr;
+    }
+    return result;
+  };
+}
+var _bumpCursorWarned = /* @__PURE__ */ new WeakSet();
+function bumpCursor(seq) {
+  const raw = seq.cache;
+  const valid = typeof raw === "number" && Number.isFinite(raw);
+  if (!valid && raw !== void 0 && !_bumpCursorWarned.has(seq)) {
+    _bumpCursorWarned.add(seq);
+    console.warn(
+      `bumpCursor: cursor cache held a non-numeric value (${String(raw)}); resetting to 0. Causes include: a snapshot codec round-tripping the cursor as a string / null / NaN, OR a malformed initial seed (e.g. state<number>(NaN)). Audit consumers may see colliding seq values after this point.`
+    );
+  }
+  const cur = valid ? raw : 0;
+  const next = cur + 1;
+  seq.down([[import_core.DIRTY], [import_core.DATA, next]]);
+  return next;
+}
+function appendAudit(audit, builder, args, value, meta, handlerVersion) {
+  const record = builder(args, value, meta);
+  if (record === void 0) return;
+  const stamped = handlerVersion != null ? { ...record, handlerVersion } : record;
+  audit.append(stamped);
+}
+function registerCursor(graph, name, initial = 0) {
+  const cursor = (0, import_core.node)([], { initial, name, describeKind: "state" });
+  graph.add(cursor, { name });
+  return cursor;
+}
+
+// src/base/sources/settled.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+function firstWhere(source, predicate, opts) {
+  let pending;
+  let resolveFn;
+  let rejectFn;
+  let settled = false;
+  let shouldUnsub = false;
+  let unsub;
+  let inInitialSyncPhase = opts?.skipCurrent === true;
+  const settleData = (v) => {
+    if (settled) return;
+    settled = true;
+    if (resolveFn != null) resolveFn(v);
+    else pending = { kind: "data", value: v };
+  };
+  const settleError = (err) => {
+    if (settled) return;
+    settled = true;
+    if (rejectFn != null) rejectFn(err);
+    else pending = { kind: "error", err };
+  };
+  const settleComplete = () => {
+    if (settled) return;
+    settled = true;
+    const err = new Error("completed without matching value");
+    if (rejectFn != null) rejectFn(err);
+    else pending = { kind: "complete" };
+  };
+  const detach = () => {
+    if (unsub) {
+      unsub();
+      unsub = void 0;
+    } else shouldUnsub = true;
+  };
+  const sink = (msgs) => {
+    if (settled) return;
+    for (const m of msgs) {
+      if (settled) return;
+      if (inInitialSyncPhase && m[0] === import_core2.DATA) continue;
+      if (m[0] === import_core2.DATA) {
+        const v = m[1];
+        if (predicate(v)) {
+          settleData(v);
+          detach();
+          return;
+        }
+      }
+      if (m[0] === import_core2.ERROR) {
+        settleError(m[1]);
+        detach();
+        return;
+      }
+      if (m[0] === import_core2.COMPLETE) {
+        settleComplete();
+        detach();
+        return;
+      }
+    }
+  };
+  unsub = source.subscribe(sink);
+  inInitialSyncPhase = false;
+  if (opts?.kick != null && !settled) {
+    try {
+      opts.kick();
+    } catch (err) {
+      settleError(err);
+      detach();
+    }
+  }
+  if (shouldUnsub) {
+    unsub?.();
+    unsub = void 0;
+  }
+  return new Promise((resolve, reject) => {
+    if (pending != null) {
+      if (pending.kind === "data") resolve(pending.value);
+      else if (pending.kind === "error") reject(pending.err);
+      else reject(new Error("completed without matching value"));
+      return;
+    }
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+}
+
+// src/utils/process/index.ts
+var processInstanceKeyOf = (i) => i.correlationId;
+var processStateKeyOf = (s) => s.correlationId;
+function toPromise(input) {
+  if (input == null) return Promise.resolve(void 0);
+  const n = (0, import_extra2.fromAny)(input);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let unsub;
+    const cleanup = () => {
+      if (unsub) {
+        unsub();
+      }
+    };
+    unsub = n.subscribe((msgs) => {
+      if (settled) return;
+      for (const m of msgs) {
+        if (m[0] === import_core3.DATA) {
+          settled = true;
+          Promise.resolve().then(cleanup);
+          resolve(m[1]);
+          return;
+        }
+        if (m[0] === import_core3.ERROR) {
+          settled = true;
+          Promise.resolve().then(cleanup);
+          reject(m[1]);
+          return;
+        }
+        if (m[0] === import_core3.COMPLETE) {
+          settled = true;
+          Promise.resolve().then(cleanup);
+          resolve(void 0);
+          return;
+        }
+      }
+    });
+  });
+}
+async function runWithRetry(step, state, event, retryMax, backoffMs) {
+  let lastError;
+  for (let attempt = 0; attempt <= retryMax; attempt++) {
+    if (attempt > 0) {
+      const delayMs = backoffMs[Math.min(attempt - 1, backoffMs.length - 1)] ?? 0;
+      if (delayMs > 0) {
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+    }
+    try {
+      const result = await toPromise(step(state, event));
+      return result;
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  return { outcome: "failure", error: lastError };
+}
+function processManager(cqrsGraph, name, opts) {
+  const retryMax = opts.retryMax ?? 0;
+  const backoffMs = opts.backoffMs ?? [0];
+  const retainedLimit = 1024;
+  const instanceStates = /* @__PURE__ */ new Map();
+  const activeInstances = /* @__PURE__ */ new Set();
+  const startedAt = /* @__PURE__ */ new Map();
+  const mountName = `__processManagers__/${name}`;
+  const subgraph = new import_graph2.Graph(name);
+  try {
+    cqrsGraph.mount(mountName, subgraph);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `processManager: name "${name}" is already in use on this CQRS graph (mount path "${mountName}" collides). Call .dispose() on the prior manager OR pick a different name before re-creating. (${detail})`
+    );
+  }
+  const instances = createAuditLog({
+    name: "instances",
+    retainedLimit,
+    graph: subgraph
+  });
+  const seqCursor = registerCursor(subgraph, "seq", 0);
+  const appendRecord = mutate(
+    // No closure-state mutation in the action — the audit-record append IS
+    // the effect, performed by the framework via `onSuccessRecord`.
+    () => void 0,
+    {
+      frame: "transactional",
+      log: instances,
+      seq: seqCursor,
+      freeze: true,
+      ...opts.handlerVersion !== void 0 ? { handlerVersion: opts.handlerVersion } : {},
+      onSuccessRecord: ([correlationId, state, status, reason], _r, { t_ns, seq }) => ({
+        correlationId,
+        state,
+        status,
+        startedAt: startedAt.get(correlationId) ?? t_ns,
+        updatedAt: t_ns,
+        t_ns,
+        seq: seq ?? 0,
+        ...reason !== void 0 ? { reason } : {}
+      })
+    }
+  );
+  const stateStorageTiers = opts.persistence?.stateStorage ?? [];
+  const buildSnapshot = (correlationId, status) => {
+    const stateValue = instanceStates.get(correlationId);
+    if (stateValue === void 0) return void 0;
+    return {
+      correlationId,
+      state: stateValue,
+      status,
+      startedAt: startedAt.get(correlationId) ?? (0, import_core3.wallClockNs)(),
+      updatedAt: (0, import_core3.wallClockNs)(),
+      ...opts.handlerVersion !== void 0 ? { handlerVersion: opts.handlerVersion } : {}
+    };
+  };
+  const persistState = (correlationId, status) => {
+    if (stateStorageTiers.length === 0) return;
+    const snapshot = buildSnapshot(correlationId, status);
+    if (snapshot === void 0) return;
+    for (const tier of stateStorageTiers) {
+      try {
+        const r = tier.save(correlationId, snapshot);
+        if (r != null && typeof r.then === "function") {
+          r.catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+  };
+  const persistStateThrowing = (correlationId, status) => {
+    if (stateStorageTiers.length === 0) return;
+    const snapshot = buildSnapshot(correlationId, status);
+    if (snapshot === void 0) return;
+    for (const tier of stateStorageTiers) {
+      const r = tier.save(correlationId, snapshot);
+      if (r != null && typeof r.then === "function") {
+        r.catch(() => void 0);
+      }
+    }
+  };
+  const removeState = (correlationId) => {
+    if (stateStorageTiers.length === 0) return;
+    for (const tier of stateStorageTiers) {
+      if (!tier.delete) continue;
+      try {
+        const r = tier.delete(correlationId);
+        if (r != null && typeof r.then === "function") {
+          r.catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+  };
+  const startedEventType = `_process_${name}_started`;
+  cqrsGraph.event(startedEventType);
+  if (opts.persistence?.eventStorage) {
+    cqrsGraph.attachEventStorage(opts.persistence.eventStorage);
+  }
+  async function runCompensate(correlationId, state, error, reason) {
+    activeInstances.delete(correlationId);
+    instanceStates.delete(correlationId);
+    startedAt.delete(correlationId);
+    if (opts.compensate) {
+      try {
+        await toPromise(opts.compensate(state, error));
+        appendRecord(correlationId, state, "cancelled", reason);
+        removeState(correlationId);
+      } catch (_compErr) {
+        appendRecord(correlationId, state, "errored", void 0);
+        removeState(correlationId);
+      }
+    } else {
+      appendRecord(correlationId, state, "errored", void 0);
+      removeState(correlationId);
+    }
+  }
+  async function handleStepResult(correlationId, result) {
+    if (!activeInstances.has(correlationId)) return;
+    if (result.outcome === "failure") {
+      const state = instanceStates.get(correlationId) ?? opts.initial;
+      await runCompensate(correlationId, state, result.error);
+      return;
+    }
+    if (result.outcome === "success") {
+      instanceStates.set(correlationId, result.state);
+      if (result.emit) {
+        for (const ev of result.emit) {
+          try {
+            cqrsGraph._appendEvent(ev.type, ev.payload, {
+              correlationId,
+              aggregateId: correlationId
+            });
+          } catch (_emitErr) {
+          }
+        }
+      }
+      appendRecord(correlationId, result.state, "running", void 0);
+      persistState(correlationId, "running");
+      if (opts.isTerminal?.(result.state)) {
+        activeInstances.delete(correlationId);
+        instanceStates.delete(correlationId);
+        startedAt.delete(correlationId);
+        appendRecord(correlationId, result.state, "completed", void 0);
+        removeState(correlationId);
+        return;
+      }
+      if (result.schedule) {
+        const { afterMs, eventType } = result.schedule;
+        let timerUnsub;
+        const timerNode = (0, import_extra2.fromTimer)(afterMs);
+        const timerCb = (msgs) => {
+          for (const m of msgs) {
+            if (m[0] === import_core3.DATA) {
+              if (timerUnsub) {
+                timerUnsub();
+              } else {
+                queueMicrotask(() => timerUnsub?.());
+              }
+              if (!activeInstances.has(correlationId)) return;
+              const currentState = instanceStates.get(correlationId);
+              if (currentState === void 0) return;
+              const step = opts.steps[eventType];
+              if (!step) return;
+              const syntheticEvent = {
+                type: eventType,
+                // m5: null payload (not undefined) to avoid soft §1.2 risk.
+                // seq: Number.NaN — sentinel for synthetic events that do not
+                // participate in cross-event ordering.
+                payload: null,
+                timestampNs: (0, import_core3.wallClockNs)(),
+                seq: Number.NaN,
+                correlationId,
+                aggregateId: correlationId
+              };
+              dispatchStep(correlationId, step, currentState, syntheticEvent);
+            }
+          }
+        };
+        timerUnsub = timerNode.subscribe(timerCb);
+      }
+      return;
+    }
+    if (result.outcome === "terminate") {
+      instanceStates.set(correlationId, result.state);
+      if (result.emit) {
+        for (const ev of result.emit) {
+          try {
+            cqrsGraph._appendEvent(ev.type, ev.payload, {
+              correlationId,
+              aggregateId: correlationId
+            });
+          } catch (_emitErr) {
+          }
+        }
+      }
+      activeInstances.delete(correlationId);
+      instanceStates.delete(correlationId);
+      startedAt.delete(correlationId);
+      appendRecord(correlationId, result.state, "completed", void 0);
+      removeState(correlationId);
+    }
+  }
+  const inFlight = /* @__PURE__ */ new Map();
+  function dispatchStep(correlationId, step, _state, event) {
+    const prior = inFlight.get(correlationId) ?? Promise.resolve();
+    const next = prior.then(async () => {
+      const currentState = instanceStates.get(correlationId);
+      if (currentState === void 0) return;
+      if (!activeInstances.has(correlationId)) return;
+      let result;
+      try {
+        result = await runWithRetry(
+          step,
+          currentState,
+          event,
+          retryMax,
+          backoffMs
+        );
+      } catch (err) {
+        await runCompensate(correlationId, instanceStates.get(correlationId) ?? opts.initial, err);
+        return;
+      }
+      await handleStepResult(correlationId, result);
+    });
+    inFlight.set(correlationId, next);
+    next.finally(() => {
+      if (inFlight.get(correlationId) === next) inFlight.delete(correlationId);
+    });
+  }
+  let _disposed = false;
+  const restoreState = (0, import_core3.node)([], {
+    initial: "pending",
+    name: "restoreState",
+    describeKind: "state"
+  });
+  subgraph.add(restoreState, { name: "restoreState" });
+  const gateOpen = (0, import_core3.node)(
+    [restoreState],
+    (data, a, ctx) => {
+      const batch0 = data[0];
+      const v = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+      a.emit(v === "completed");
+    },
+    { name: "gateOpen", describeKind: "derived" }
+  );
+  subgraph.add(gateOpen, { name: "gateOpen" });
+  const watchDisposers = [];
+  for (const eventType of opts.watching) {
+    const eventNode = cqrsGraph.event(eventType);
+    const gated = (0, import_extra2.valve)(eventNode, gateOpen, { name: `gatedEvent:${eventType}` });
+    let lastCount = 0;
+    const unsub = gated.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] !== import_core3.DATA) continue;
+        const events = m[1];
+        if (events.length <= lastCount) continue;
+        const newEvents = events.slice(lastCount);
+        lastCount = events.length;
+        for (const ev of newEvents) {
+          const corrId = ev.correlationId;
+          if (corrId === void 0) continue;
+          if (!activeInstances.has(corrId)) continue;
+          const step = opts.steps[eventType];
+          if (!step) continue;
+          const state = instanceStates.get(corrId);
+          if (state === void 0) continue;
+          dispatchStep(corrId, step, state, ev);
+        }
+      }
+    });
+    watchDisposers.push(unsub);
+  }
+  const startInternal = mutate(
+    (correlationId, initialPayload) => {
+      cqrsGraph._appendEvent(startedEventType, initialPayload ?? null, {
+        correlationId,
+        aggregateId: correlationId
+      });
+      startedAt.set(correlationId, (0, import_core3.wallClockNs)());
+      instanceStates.set(correlationId, opts.initial);
+      activeInstances.add(correlationId);
+      persistStateThrowing(correlationId, "running");
+    },
+    {
+      frame: "transactional",
+      log: instances,
+      seq: seqCursor,
+      freeze: true,
+      ...opts.handlerVersion !== void 0 ? { handlerVersion: opts.handlerVersion } : {},
+      onSuccessRecord: ([correlationId], _r, { t_ns, seq }) => ({
+        correlationId,
+        state: opts.initial,
+        status: "running",
+        startedAt: startedAt.get(correlationId) ?? t_ns,
+        updatedAt: t_ns,
+        t_ns,
+        seq: seq ?? 0
+      })
+    }
+  );
+  function start(correlationId, initialPayload) {
+    if (_disposed) return;
+    if (activeInstances.has(correlationId)) return;
+    startInternal(correlationId, initialPayload);
+  }
+  function cancel(correlationId, reason) {
+    if (_disposed) return;
+    if (!activeInstances.has(correlationId)) return;
+    const state = instanceStates.get(correlationId) ?? opts.initial;
+    runCompensate(
+      correlationId,
+      state,
+      new Error(`cancelled: ${reason ?? "no reason given"}`),
+      reason
+    );
+  }
+  function getState(correlationId) {
+    return instanceStates.get(correlationId);
+  }
+  let restoreSubscription;
+  function startRestorePipeline() {
+    if (restoreSubscription !== void 0) return;
+    const tier = stateStorageTiers[0];
+    if (tier == null || tier.list == null || tier.load == null) {
+      if (!_disposed) restoreState.emit("completed");
+      restoreSubscription = () => void 0;
+      return;
+    }
+    const tierLoad = tier.load.bind(tier);
+    const tierList = tier.list.bind(tier);
+    const listSource = (0, import_extra2.fromAny)(tierList());
+    const flattened = (0, import_extra2.mergeMap)(listSource, (keys) => {
+      if (keys.length === 0) {
+        return (0, import_extra2.fromIter)([]);
+      }
+      return (0, import_extra2.mergeMap)(
+        (0, import_extra2.fromIter)(keys),
+        (key) => (0, import_extra2.fromAny)(tierLoad(key)),
+        // Bound concurrent in-flight loads (D2, 2026-05-01) so a
+        // large persisted-instance count doesn't exhaust file
+        // handles / connection pools on the storage backend.
+        { concurrent: opts.restoreConcurrency ?? 8 }
+      );
+    });
+    const restoreEffect = (0, import_core3.node)(
+      [flattened],
+      (data, _a, ctx) => {
+        if (_disposed) return;
+        const batch0 = data[0];
+        const hasSnapshots = batch0 != null && batch0.length > 0;
+        const allDone = ctx.terminalDeps[0] === true;
+        if (!hasSnapshots && !allDone) return;
+        (0, import_core3.batch)(() => {
+          if (hasSnapshots) {
+            for (const snap of batch0) {
+              if (snap == null) continue;
+              if (snap.status !== "running") continue;
+              instanceStates.set(snap.correlationId, snap.state);
+              activeInstances.add(snap.correlationId);
+              startedAt.set(snap.correlationId, snap.startedAt);
+            }
+          }
+          if (allDone) restoreState.emit("completed");
+        });
+      },
+      { name: "restoreEffect", describeKind: "effect" }
+    );
+    subgraph.add(restoreEffect, { name: "restoreEffect" });
+    restoreSubscription = restoreEffect.subscribe(() => void 0);
+  }
+  function restore() {
+    startRestorePipeline();
+    if (_disposed) return Promise.resolve();
+    if (restoreState.cache === "completed") return Promise.resolve();
+    return firstWhere(restoreState, (s) => s === "completed").then(() => void 0).catch((err) => {
+      if (err instanceof Error && err.message === "completed without matching value") {
+        return void 0;
+      }
+      throw err;
+    });
+  }
+  function dispose() {
+    if (_disposed) return;
+    _disposed = true;
+    if (restoreSubscription) {
+      try {
+        restoreSubscription();
+      } catch {
+      }
+      restoreSubscription = void 0;
+    }
+    for (const unsub of watchDisposers) {
+      try {
+        unsub();
+      } catch (_err) {
+      }
+    }
+    watchDisposers.length = 0;
+    try {
+      cqrsGraph.remove(mountName);
+    } catch (_err) {
+    }
+  }
+  if (opts.deferRestore !== true) {
+    startRestorePipeline();
+  }
+  return {
+    instances,
+    audit: instances,
+    restoreState,
+    start,
+    cancel,
+    getState,
+    restore,
+    dispose
+  };
+}
+//# sourceMappingURL=index.cjs.map