@state-flow/core 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1458 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/package-json.ts
+var package_json_default = { name: "@state-flow/core", version: "1.0.0", commit: "6b8863c9d96e7ff65eaf983b247f122628b986d5", branch: "HEAD" };
+
+// src/flow.ts
+import { EventEmitter } from "events";
+
+// src/logger.ts
+var STACKTRACE_VIEWER_URL = "https://stacktrace.pirogov.dev/";
+var dispatchContextProvider = null;
+function setGlobalDispatchContextProvider(provider) {
+  dispatchContextProvider = provider;
+  return () => {
+    if (dispatchContextProvider === provider) {
+      dispatchContextProvider = null;
+    }
+  };
+}
+function getGlobalDispatchContext() {
+  if (dispatchContextProvider == null) {
+    return null;
+  }
+  try {
+    return dispatchContextProvider();
+  } catch {
+    return null;
+  }
+}
+var globalLogHandlers = /* @__PURE__ */ new Set();
+function addGlobalLogHandler(handler) {
+  globalLogHandlers.add(handler);
+  return () => {
+    globalLogHandlers.delete(handler);
+  };
+}
+function withGlobalLogHandlers(handlers) {
+  if (globalLogHandlers.size === 0) {
+    return handlers;
+  }
+  return [...handlers, ...globalLogHandlers];
+}
+var consoleSilencedOverride = null;
+function isConsoleSilenced() {
+  if (consoleSilencedOverride !== null) {
+    return consoleSilencedOverride;
+  }
+  return typeof process !== "undefined" && process.env?.VITEST != null;
+}
+function setConsoleLogSilenced(silenced) {
+  consoleSilencedOverride = silenced;
+}
+var consoleLogHandler = (entry) => {
+  if (isConsoleSilenced()) {
+    return;
+  }
+  const logs = {};
+  entry.stateChanges.reduce((l, r) => {
+    var _a;
+    l[_a = r.stateName] ?? (l[_a] = []);
+    l[r.stateName].push(`State: ${r.oldState} => ${r.newState}`);
+    return l;
+  }, logs);
+  entry.handlerResults.reduce((l, r) => {
+    var _a;
+    l[_a = r.stateName] ?? (l[_a] = []);
+    l[r.stateName].push(`	${r.type} ${r.handlerName}() => ${r.result}`);
+    return l;
+  }, logs);
+  entry.observers.reduce((l, r) => {
+    var _a;
+    l[_a = r.stateName] ?? (l[_a] = []);
+    l[r.stateName].push(`	observed by ${r.observerName}() => ${r.needObserve}`);
+    return l;
+  }, logs);
+  console.groupCollapsed(entry.message);
+  for (const [, rows] of Object.entries(logs)) {
+    for (const row of rows) {
+      console.log(row);
+    }
+  }
+  if (entry.enqueuedSignals.length > 0) {
+    console.log("\nEnqueued Signals:");
+    for (const enq of entry.enqueuedSignals) {
+      console.log(`	${enq.signal} (from ${enq.fromHandler})`);
+    }
+  }
+  console.log("\nFinal States:");
+  Object.entries(entry.finalStates).forEach(([name, state]) => {
+    console.debug(`	${name}: ${state}`);
+  });
+  if (entry.stacktrace != null) {
+    console.log("\nStacktrace:");
+    console.log(`${STACKTRACE_VIEWER_URL}#${btoa(JSON.stringify(entry.stacktrace))}`);
+  }
+  console.groupEnd();
+};
+function emitGrouped(handlers, label, entries, context = null) {
+  if (entries.length === 0) {
+    return;
+  }
+  if (isConsoleSilenced()) {
+    for (const entry of entries) {
+      entry.groupLabel = label;
+      if (context != null) {
+        entry.dispatchContext = context;
+      }
+      for (const handler of handlers) {
+        handler(entry);
+      }
+    }
+    return;
+  }
+  console.group(context != null ? `${label} \u27F5 ${context}` : label);
+  try {
+    for (const entry of entries) {
+      entry.groupLabel = label;
+      if (context != null) {
+        entry.dispatchContext = context;
+      }
+      for (const handler of handlers) {
+        handler(entry);
+      }
+    }
+  } finally {
+    console.groupEnd();
+  }
+}
+
+// src/symbols.ts
+var SIGNAL = /* @__PURE__ */ Symbol.for("SIGNAL");
+var DEF = /* @__PURE__ */ Symbol.for("DEF");
+var IS_INITIAL = /* @__PURE__ */ Symbol.for("IS_INITIAL");
+var VARIANT = /* @__PURE__ */ Symbol.for("VARIANT");
+var SIGNALS = /* @__PURE__ */ Symbol.for("SIGNALS");
+var HANDLERS = /* @__PURE__ */ Symbol.for("HANDLERS");
+var STRING_REPR = /* @__PURE__ */ Symbol.for("STRING_REPR");
+var PARSER = /* @__PURE__ */ Symbol.for("PARSER");
+if (typeof Symbol.dispose === "undefined") {
+  Object.defineProperty(Symbol, "dispose", { value: /* @__PURE__ */ Symbol.for("dispose") });
+}
+if (typeof Symbol.asyncDispose === "undefined") {
+  Object.defineProperty(Symbol, "asyncDispose", { value: /* @__PURE__ */ Symbol.for("asyncDispose") });
+}
+
+// src/utils.ts
+function buildName(ctx, func) {
+  let fnName = null;
+  let ctxName = null;
+  if (func != null) {
+    fnName = Symbol.toStringTag in func && func[Symbol.toStringTag] !== "AsyncFunction" ? func[Symbol.toStringTag] : func.name;
+  }
+  if (ctx != null && typeof ctx === "object") {
+    ctxName = Symbol.toStringTag in ctx ? ctx[Symbol.toStringTag] : ctx.constructor.name;
+  }
+  if (ctxName == null) {
+    return String(fnName);
+  } else if (fnName == null) {
+    return String(ctxName);
+  }
+  if (String(fnName).startsWith(String(ctxName))) {
+    return String(fnName);
+  }
+  return `${ctxName}.${fnName}`;
+}
+var StateFlowError = class extends Error {
+  constructor(message, inner = null) {
+    super(message);
+    this.name = "StateFlowError";
+    if (inner != null) {
+      this.stack = inner.stack;
+    }
+  }
+};
+var urlRegex = /(https?:\/\/[^:]+(?::\d+)?(?:\/[^:]*)*?):(\d+):(\d+)/g;
+function parseCompactStacktrace(stacktrace) {
+  if (stacktrace == null) {
+    return null;
+  }
+  const urlMap = /* @__PURE__ */ new Map();
+  const urls = [];
+  const compactFrames = [];
+  const matches = stacktrace.matchAll(urlRegex);
+  for (const match of matches) {
+    const [, url, lineStr, columnStr] = match;
+    if (!urlMap.has(url)) {
+      urlMap.set(url, urls.length);
+      urls.push(url);
+    }
+    const urlIndex = urlMap.get(url);
+    const line = parseInt(lineStr, 10);
+    const column = parseInt(columnStr, 10);
+    compactFrames.push([urlIndex, line, column]);
+  }
+  if (compactFrames.length === 0) {
+    return null;
+  }
+  return [urls, compactFrames];
+}
+var maxArrayItems = 10;
+var maxStringLen = 25;
+var abbreviate = true;
+var inlineSingleArrays = true;
+var maxDepth = 3;
+var SPACES_REGEX = /\s/;
+var BRACKETS_REGEX = /[{}[\]=]/;
+function isObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function isPlainObject(val) {
+  if (!isObject(val)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(val);
+  return proto === null || proto === Object.prototype;
+}
+function getClassName(val) {
+  const proto = Object.getPrototypeOf(val);
+  if (proto?.constructor?.name != null) {
+    return proto.constructor.name;
+  }
+  return "Object";
+}
+function flattenPath(val, path = [], depthBudget = maxDepth) {
+  if (isPlainObject(val) && depthBudget > 0) {
+    const keys = Reflect.ownKeys(val).filter((k) => typeof k === "string");
+    if (keys.length === 1) {
+      const key = keys[0];
+      if (key !== void 0) {
+        const nextVal = Reflect.get(val, key);
+        return flattenPath(nextVal, [...path, key], depthBudget - 1);
+      }
+    }
+  }
+  return { path, value: val };
+}
+function serializeValue(val, depth = 0) {
+  if (val === null) {
+    return abbreviate ? "N" : "null";
+  }
+  if (val === void 0) {
+    return abbreviate ? "U" : "undefined";
+  }
+  if (typeof val === "boolean") {
+    return abbreviate ? val ? "T" : "F" : String(val);
+  }
+  if (typeof val === "number") {
+    return String(val);
+  }
+  if (typeof val === "string") {
+    let str = val;
+    if (maxStringLen && str.length > maxStringLen) {
+      str = `${str.slice(0, maxStringLen)}\u2026`;
+    }
+    const hasSpaces = SPACES_REGEX.test(str);
+    const hasSpecialChars = BRACKETS_REGEX.test(str);
+    if (hasSpaces || hasSpecialChars) {
+      return `'${str.replace(/'/g, "\\'")}'`;
+    }
+    return str;
+  }
+  if (Array.isArray(val)) {
+    if (inlineSingleArrays && val.length === 1) {
+      const first = val[0];
+      if (first === null || first === void 0 || typeof first === "number" || typeof first === "boolean" || typeof first === "string") {
+        return serializeValue(first, depth + 1);
+      }
+    }
+    let items = val;
+    let truncated = false;
+    if (maxArrayItems && val.length > maxArrayItems) {
+      items = val.slice(0, maxArrayItems);
+      truncated = true;
+    }
+    const serialized = items.map((item) => {
+      if (isPlainObject(item)) {
+        if (depth >= maxDepth) {
+          return "{...}";
+        }
+        const depthBudget = maxDepth - depth - 1;
+        const entries = Reflect.ownKeys(item).filter((k) => typeof k === "string").map((k) => {
+          const v = Reflect.get(item, k);
+          const { path, value } = flattenPath(v, [], depthBudget);
+          const fullPath = path.length > 0 ? `${k}.${path.join(".")}` : k;
+          return `${fullPath}=${serializeValue(value, depth + 1 + path.length)}`;
+        });
+        return entries.length === 1 ? entries[0] : `{${entries.join(" ")}}`;
+      }
+      return serializeValue(item, depth + 1);
+    });
+    const result = serialized.join(" ");
+    return `[${result}${truncated ? ` \u2026+${val.length - maxArrayItems}` : ""}]`;
+  }
+  if (isObject(val)) {
+    if (val instanceof Date) {
+      return val.toISOString();
+    }
+    if (Reflect.has(val, Symbol.toPrimitive) && !Reflect.has(val, VARIANT)) {
+      return String(val);
+    }
+    if (val instanceof Map) {
+      if (depth >= maxDepth) {
+        return `Map(${val.size}){...}`;
+      }
+      let entries2 = [...val.entries()];
+      const dropped = maxArrayItems ? entries2.length - maxArrayItems : 0;
+      if (dropped > 0) {
+        entries2 = entries2.slice(0, maxArrayItems);
+      }
+      const body = entries2.map(([k, v]) => `${serializeValue(k, depth + 1)}=${serializeValue(v, depth + 1)}`);
+      return `Map(${val.size}){${body.join(" ")}${dropped > 0 ? ` \u2026+${dropped}` : ""}}`;
+    }
+    if (val instanceof Set) {
+      if (depth >= maxDepth) {
+        return `Set(${val.size}){...}`;
+      }
+      let items = [...val.values()];
+      const dropped = maxArrayItems ? items.length - maxArrayItems : 0;
+      if (dropped > 0) {
+        items = items.slice(0, maxArrayItems);
+      }
+      const body = items.map((item) => serializeValue(item, depth + 1));
+      return `Set(${val.size}){${body.join(" ")}${dropped > 0 ? ` \u2026+${dropped}` : ""}}`;
+    }
+    if (val instanceof Error) {
+      let message = val.message;
+      if (maxStringLen && message.length > maxStringLen) {
+        message = `${message.slice(0, maxStringLen)}\u2026`;
+      }
+      return `${val.name}(${message})`;
+    }
+    if (val instanceof RegExp) {
+      return String(val);
+    }
+    if (val instanceof ArrayBuffer) {
+      return `ArrayBuffer(${val.byteLength})`;
+    }
+    if (ArrayBuffer.isView(val)) {
+      const length = val.length ?? val.byteLength;
+      return `${getClassName(val)}(${length})`;
+    }
+    if (typeof val.type === "string" && getClassName(val).endsWith("Event")) {
+      return `${getClassName(val)}(${val.type})`;
+    }
+    if (getClassName(val) === "URL" && typeof val.href === "string") {
+      return serializeValue(val.href, depth);
+    }
+    if (!isPlainObject(val)) {
+      const className = getClassName(val);
+      return `{${className}}`;
+    }
+    if (depth >= maxDepth) {
+      return "{...}";
+    }
+    const depthBudget = maxDepth - depth - 1;
+    const entries = Reflect.ownKeys(val).filter((k) => typeof k === "string").map((k) => {
+      const v = Reflect.get(val, k);
+      const { path, value } = flattenPath(v, [], depthBudget);
+      const fullPath = path.length > 0 ? `${k}.${path.join(".")}` : k;
+      return `${fullPath}=${serializeValue(value, depth + 1 + path.length)}`;
+    });
+    return depth === 0 ? entries.join(" ") : `{${entries.join(" ")}}`;
+  }
+  return String(val);
+}
+function serializeDebug(obj) {
+  if (obj == null) {
+    return "";
+  }
+  return serializeValue(obj);
+}
+
+// src/result.ts
+var ResultKind = /* @__PURE__ */ ((ResultKind2) => {
+  ResultKind2[ResultKind2["OK"] = 0] = "OK";
+  ResultKind2[ResultKind2["Ignored"] = 1] = "Ignored";
+  ResultKind2[ResultKind2["InTransition"] = 2] = "InTransition";
+  ResultKind2[ResultKind2["Rejected"] = 3] = "Rejected";
+  ResultKind2[ResultKind2["Error"] = 4] = "Error";
+  return ResultKind2;
+})(ResultKind || {});
+var _executors, _enqueued, _promise, _expectedKinds, _timestamps, _signal, _handler, _state, _stacktrace, _meta, _Result_instances, assertExpected_fn;
+var _Result = class _Result {
+  /**
+   * Internal constructor of Result
+   *
+   * @param kind
+   * @param data
+   * @param msg
+   * @param ts
+   * @private
+   * @internal
+   */
+  constructor(kind, data, msg, ts = Date.now()) {
+    this.kind = kind;
+    this.data = data;
+    this.msg = msg;
+    __privateAdd(this, _Result_instances);
+    // a list of transitioning result promises
+    __privateAdd(this, _executors, []);
+    // signals to dispatch after this result completes successfully
+    __privateAdd(this, _enqueued, []);
+    // cached promise for current result
+    __privateAdd(this, _promise, null);
+    // kinds the caller asserted via expect() on an InTransition result.
+    // The assertion is deferred to the FINAL resolved result and enforced in done().
+    __privateAdd(this, _expectedKinds, null);
+    // contexts for logging purposes
+    __privateAdd(this, _timestamps, [Date.now(), Date.now()]);
+    __privateAdd(this, _signal, null);
+    __privateAdd(this, _handler, null);
+    __privateAdd(this, _state, null);
+    __privateAdd(this, _stacktrace, null);
+    __privateAdd(this, _meta, null);
+    __privateSet(this, _timestamps, [ts, ts]);
+    if (kind === 2 /* InTransition */) {
+      __privateGet(this, _executors).push(data);
+    }
+    Object.freeze(this);
+  }
+  get startedAt() {
+    return __privateGet(this, _timestamps)[0];
+  }
+  get finishedAt() {
+    return __privateGet(this, _timestamps)[1];
+  }
+  get stacktrace() {
+    return __privateGet(this, _stacktrace);
+  }
+  in(...args) {
+    return args.includes(this.kind);
+  }
+  /**
+   * Returns a promise with result
+   * Useful for `InTransition` kind results
+   * For all other kinds it wraps "this" object
+   */
+  async done() {
+    if (this.kind === 2 /* InTransition */ && __privateGet(this, _meta)?.transitioning != null && typeof __privateGet(this, _meta).transitioning !== "boolean") {
+      return __privateMethod(this, _Result_instances, assertExpected_fn).call(this, await __privateGet(this, _meta).transitioning);
+    }
+    const result = await this.waitAll();
+    if (__privateGet(this, _meta)?.transitioning != null) {
+      await __privateGet(this, _meta).transitioning;
+    }
+    return __privateMethod(this, _Result_instances, assertExpected_fn).call(this, result);
+  }
+  /**
+   * Error object for `Error` results
+   * Or null for all other kinds of results
+   */
+  get error() {
+    if (this.msg instanceof Error) {
+      return this.msg;
+    }
+    return null;
+  }
+  /**
+   * Message string for `Ignored` or `Rejected` kinds
+   * Or null for all other kinds of results
+   */
+  get message() {
+    if (typeof this.msg === "string" && this.msg !== "") {
+      return this.msg;
+    }
+    return null;
+  }
+  /**
+   * Signals enqueued for dispatch after this result completes successfully
+   */
+  get enqueuedSignals() {
+    return __privateGet(this, _enqueued);
+  }
+  /**
+   * @internal
+   * @private
+   */
+  waitAll() {
+    if (__privateGet(this, _promise) == null) {
+      if (this.kind === 2 /* InTransition */) {
+        __privateSet(this, _promise, Promise.all(__privateGet(this, _executors)).then(mergeResults).then((res) => res.kind === 2 /* InTransition */ ? res.waitAll() : res).then((res) => res.withTimestamps(...__privateGet(this, _timestamps), Date.now())));
+      } else {
+        __privateSet(this, _promise, Promise.resolve(this));
+      }
+    }
+    return __privateGet(this, _promise);
+  }
+  /**
+   * Creates `Ignored` result with explanation message
+   *
+   * @param message explanation message
+   */
+  static ignore(message) {
+    return new _Result(1 /* Ignored */, null, message);
+  }
+  /**
+   * Creates `Ok` result without any messages
+   */
+  static ok(data = null) {
+    return new _Result(0 /* OK */, data, "");
+  }
+  /**
+   * Creates `Ok` result with a new state
+   * Used in a flow handlers
+   *
+   * @param data a new state
+   */
+  static state(data) {
+    return new _Result(0 /* OK */, data, "");
+  }
+  /**
+   * Creates `Ok` result that enqueues a follow-up signal for dispatch
+   * after the current dispatch completes successfully.
+   * If the enqueued signal fails, the entire chain is rolled back.
+   *
+   * @param signal - Signal to dispatch after current dispatch succeeds
+   */
+  static enqueue(signal) {
+    const result = new _Result(0 /* OK */, null, "");
+    __privateSet(result, _enqueued, [signal]);
+    return result;
+  }
+  /**
+   * Creates a new `InTransition` result with using async callback
+   * and timeout for executing it.
+   *
+   * @param asyncFn
+   * @param timeout
+   */
+  static transition(asyncFn, timeout = 500) {
+    const ts = Date.now();
+    return new _Result(
+      2 /* InTransition */,
+      withTimeout(
+        asyncFn().catch((err) => _Result.error(err)),
+        timeout
+      ),
+      "",
+      ts
+    );
+  }
+  /**
+   * Creates a new `Rejected` result with explanation message
+   *
+   * @param message
+   */
+  static reject(message) {
+    return new _Result(3 /* Rejected */, null, message);
+  }
+  static error(error) {
+    if (error instanceof Error) {
+      return new _Result(4 /* Error */, null, error);
+    }
+    return new _Result(4 /* Error */, null, new Error(String(error)));
+  }
+  expect(...kinds) {
+    if (this.kind === 2 /* InTransition */) {
+      __privateSet(this, _expectedKinds, kinds);
+      return this;
+    }
+    if (!kinds.includes(this.kind)) {
+      throw new StateFlowError(
+        buildErrorMessages(this.kind, this.error, this.message, __privateGet(this, _signal), __privateGet(this, _handler), __privateGet(this, _state)),
+        this.error
+      );
+    }
+    return this;
+  }
+  /**
+   * @internal
+   */
+  withTimestamps(...ts) {
+    __privateSet(this, _timestamps, [Math.min(...ts), Math.max(...ts)]);
+    return this;
+  }
+  /**
+   * @internal
+   * @param signal
+   */
+  withSignal(signal) {
+    __privateSet(this, _signal, signal);
+    return this;
+  }
+  /**
+   * @internal
+   * @param name
+   */
+  withHandlerName(name) {
+    __privateSet(this, _handler, name);
+    return this;
+  }
+  withStacktrace(stack) {
+    __privateSet(this, _stacktrace, Array.isArray(stack) ? stack : parseCompactStacktrace(stack));
+    return this;
+  }
+  /**
+   * @internal
+   * @param state
+   */
+  withStateUpdating(state) {
+    __privateSet(this, _state, state);
+    return this;
+  }
+  withMeta(meta) {
+    __privateSet(this, _meta, meta);
+    return this;
+  }
+  /**
+   * @internal
+   */
+  withEnqueued(signals) {
+    __privateSet(this, _enqueued, signals);
+    return this;
+  }
+  /**
+   * @internal
+   * @param other
+   */
+  merge(other) {
+    const combinedEnqueued = [...__privateGet(this, _enqueued), ...__privateGet(other, _enqueued)];
+    if (this.kind === other.kind) {
+      switch (this.kind) {
+        case 1 /* Ignored */:
+          return _Result.ignore(mergeStrings(this.msg, other.msg)).withTimestamps(...__privateGet(this, _timestamps), ...__privateGet(other, _timestamps)).withSignal(__privateGet(this, _signal)).withHandlerName(__privateGet(this, _handler)).withStateUpdating(__privateGet(this, _state)).withStacktrace(__privateGet(this, _stacktrace)).withEnqueued(combinedEnqueued);
+        case 0 /* OK */:
+          return this.withTimestamps(...__privateGet(this, _timestamps), ...__privateGet(other, _timestamps)).withEnqueued(combinedEnqueued);
+        case 2 /* InTransition */:
+          __privateGet(this, _executors).push(...__privateGet(other, _executors));
+          __privateSet(this, _enqueued, combinedEnqueued);
+          return this;
+        case 3 /* Rejected */:
+          return this.withTimestamps(...__privateGet(this, _timestamps), ...__privateGet(other, _timestamps)).withEnqueued(combinedEnqueued);
+        case 4 /* Error */: {
+          const msg = [this.data, other.data].filter((m) => m !== "").map((e) => String(e)).filter((m) => m !== "").join("; ");
+          return _Result.error(new StateFlowError(msg)).withTimestamps(...__privateGet(this, _timestamps), ...__privateGet(other, _timestamps)).withSignal(__privateGet(this, _signal)).withHandlerName(__privateGet(this, _handler)).withStateUpdating(__privateGet(this, _state)).withStacktrace(__privateGet(this, _stacktrace)).withEnqueued(combinedEnqueued);
+        }
+        default:
+          throw new Error(`unknown state result: ${this.kind}`);
+      }
+    }
+    const choose = (a, b) => {
+      switch (a.kind) {
+        case 1 /* Ignored */:
+          return b;
+        case 2 /* InTransition */:
+          __privateGet(a, _executors).push(b.waitAll());
+          return a;
+        case 3 /* Rejected */:
+        case 4 /* Error */:
+          return a;
+        default:
+          return null;
+      }
+    };
+    return (choose(this, other) ?? choose(other, this) ?? this).withTimestamps(...__privateGet(this, _timestamps), ...__privateGet(other, _timestamps)).withSignal(__privateGet(this, _signal)).withHandlerName(__privateGet(this, _handler)).withStateUpdating(__privateGet(this, _state)).withStacktrace(__privateGet(this, _stacktrace)).withEnqueued(combinedEnqueued);
+  }
+  [Symbol.toStringTag]() {
+    if (__privateGet(this, _enqueued).length > 0) {
+      return `Result.Enqueue(${__privateGet(this, _enqueued).map(String).join(", ")})`;
+    }
+    return `Result.${ResultKind[this.kind]}()`;
+  }
+  [Symbol.toPrimitive]() {
+    if (__privateGet(this, _enqueued).length > 0) {
+      return `Enqueue(${__privateGet(this, _enqueued).map(String).join(", ")})`;
+    }
+    if (this.kind === 4 /* Error */) {
+      return this.error != null ? String(this.error) : ResultKind[this.kind];
+    }
+    return `${ResultKind[this.kind]}${this.message != null ? `: ${this.message}` : ""}`;
+  }
+};
+_executors = new WeakMap();
+_enqueued = new WeakMap();
+_promise = new WeakMap();
+_expectedKinds = new WeakMap();
+_timestamps = new WeakMap();
+_signal = new WeakMap();
+_handler = new WeakMap();
+_state = new WeakMap();
+_stacktrace = new WeakMap();
+_meta = new WeakMap();
+_Result_instances = new WeakSet();
+/**
+ * Applies a previously-stored expect() assertion (from an InTransition
+ * result) to the FINAL resolved result. Throws if the final kind is not
+ * allowed. No-op when no expectation was registered.
+ * @internal
+ */
+assertExpected_fn = function(final) {
+  if (__privateGet(this, _expectedKinds) == null) {
+    return final;
+  }
+  if (!__privateGet(this, _expectedKinds).includes(final.kind)) {
+    throw new StateFlowError(
+      buildErrorMessages(
+        final.kind,
+        final.error,
+        final.message,
+        __privateGet(final, _signal) ?? __privateGet(this, _signal),
+        __privateGet(final, _handler) ?? __privateGet(this, _handler),
+        __privateGet(final, _state) ?? __privateGet(this, _state)
+      ),
+      final.error
+    );
+  }
+  return final;
+};
+var Result = _Result;
+function mergeStrings(a, b) {
+  if (a == null && b == null) {
+    return "";
+  }
+  if (a == null || a === "") {
+    return String(b);
+  }
+  if (b == null || b === "") {
+    return String(a);
+  }
+  return `${a}; ${b}`;
+}
+function withTimeout(promise, timeout) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      resolve(Result.error(new Error("timeout")));
+    }, timeout);
+    promise.then(
+      (res) => {
+        clearTimeout(timer);
+        resolve(res);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function buildErrorMessages(got, error, message, signal = null, handler = null, stateUpd = null) {
+  let msg;
+  if (signal != null) {
+    msg = `[SF] Signal '${String(signal)}' `;
+  } else {
+    msg = "[SF] Result ";
+  }
+  if (handler != null) {
+    msg += `in handler '${handler}()' `;
+  }
+  switch (got) {
+    case 3 /* Rejected */:
+      msg += "was rejected";
+      break;
+    case 4 /* Error */:
+      msg += "thrown an error";
+      break;
+    case 2 /* InTransition */:
+      msg += "was in transition";
+      break;
+    case 0 /* OK */:
+      msg += "was ok";
+      break;
+    default:
+      msg += "was ignored";
+  }
+  if (stateUpd != null) {
+    msg += ` while tried to ${stateUpd}`;
+  }
+  if (error != null) {
+    msg += `: ${error}`;
+  }
+  if (message != null) {
+    msg += `: Message: ${message}`;
+  }
+  return msg;
+}
+var dispatchCounter = 0;
+var ResultCollector = class {
+  constructor(flowName, signal, duringTransition = false) {
+    this.results = [];
+    this.entry = {
+      message: "",
+      flowName,
+      signal: String(signal),
+      isAsync: false,
+      startTime: Date.now(),
+      dispatchOrder: ++dispatchCounter,
+      finalStates: {},
+      stateChanges: [],
+      handlerResults: [],
+      observers: [],
+      enqueuedSignals: [],
+      stacktrace: null,
+      finalResult: ""
+    };
+    if (duringTransition) {
+      this.entry.duringTransition = true;
+    }
+  }
+  merge() {
+    if (this.results.length === 1 && this.results[0] != null) {
+      return this.results[0];
+    }
+    const final = mergeResults(this.results);
+    this.results = [final];
+    return final;
+  }
+  push(val) {
+    const res = val instanceof Result ? val : Result.error(val);
+    this.results.push(res);
+  }
+  logStateChange(stateName, oldState, newState) {
+    this.entry.stateChanges.push({
+      stateName,
+      oldState: String(oldState),
+      newState: String(newState)
+    });
+  }
+  logHandler(stateName, type, handlerName, result) {
+    this.entry.handlerResults.push({
+      type,
+      handlerName,
+      stateName,
+      result: String(result)
+    });
+  }
+  logEnqueue(signal, handlerName) {
+    this.entry.enqueuedSignals.push({ signal, fromHandler: handlerName });
+  }
+  logObserver(stateName, observerName, needObserve) {
+    this.entry.observers.push({
+      stateName,
+      observerName,
+      needObserve
+    });
+  }
+  async finish(snapshot, result) {
+    this.entry.stacktrace = result.stacktrace;
+    let finalResult = result;
+    if (result.kind === 2 /* InTransition */) {
+      const startTime = this.entry.startTime;
+      finalResult = await result.waitAll();
+      this.entry.isAsync = true;
+      this.entry.duration = Date.now() - startTime;
+    }
+    this.entry.finalStates = Object.fromEntries(Object.entries(snapshot).map(([k, v]) => [k, String(v)]));
+    this.entry.finalResult = String(finalResult);
+    const timing = this.entry.duration != null ? `[${this.entry.duration}ms] ` : "";
+    const stale = this.entry.duringTransition ? "(during transition) " : "";
+    this.entry.message = `[SF/${this.entry.flowName}] ${this.entry.signal} - ${this.entry.isAsync ? "async " : ""}${timing}${stale}${this.entry.finalResult}`;
+    return this.entry;
+  }
+};
+function mergeResults(results, ignoreMessage = "") {
+  return results.reduce((l, r) => r.merge(l), Result.ignore(ignoreMessage));
+}
+
+// src/state.ts
+function isState(state) {
+  return typeof state === "object" && state != null && VARIANT in state;
+}
+function isStateDef(obj) {
+  return obj != null && typeof obj === "function" && SIGNALS in obj;
+}
+function isStateInstance(obj, name) {
+  if (obj == null || typeof obj !== "object" || !(VARIANT in obj) || !(Symbol.toStringTag in obj)) {
+    return false;
+  }
+  return String(obj[Symbol.toStringTag]).startsWith(name);
+}
+function stateAccepts(state, signalName) {
+  return signalName in state[VARIANT][HANDLERS];
+}
+function stateVar(obj) {
+  if (obj == null || typeof obj !== "object" || !(VARIANT in obj)) {
+    throw new StateFlowError("Not a state");
+  }
+  return obj[VARIANT];
+}
+function getInitialState(def) {
+  const svar = Object.values(def).find((x) => x[IS_INITIAL]);
+  if (svar == null) {
+    throw new StateFlowError("Initial state variant not found");
+  }
+  return svar;
+}
+function getName(def) {
+  return def[Symbol.toStringTag];
+}
+function factory(value, props) {
+  const name = String(value);
+  const inst = value[DEF][PARSER](props);
+  Object.defineProperties(inst, {
+    [Symbol.toStringTag]: { value: name, writable: false, configurable: false, enumerable: false },
+    [Symbol.toPrimitive]: {
+      value: () => `${name}(${value[DEF][STRING_REPR](inst)})`,
+      writable: false,
+      configurable: false,
+      enumerable: false
+    },
+    [VARIANT]: { value, writable: false, configurable: false, enumerable: false }
+  });
+  return Object.freeze(inst);
+}
+function extract(name, ctx) {
+  if (ctx == null || typeof ctx !== "object" || !(name in ctx)) {
+    throw new StateFlowError("State Flow object not found");
+  }
+  const state = Reflect.get(ctx, name);
+  if (!isStateInstance(state, name)) {
+    throw new StateFlowError(`State not found: ${name}`);
+  }
+  return state;
+}
+var _signals, _variants, _parser, _stringRepr, _name;
+var StateBuilder = class {
+  constructor() {
+    __privateAdd(this, _signals);
+    __privateAdd(this, _variants, []);
+    __privateAdd(this, _parser, (v) => ({ ...v }));
+    __privateAdd(this, _stringRepr, (v) => serializeDebug(v));
+    __privateAdd(this, _name, "");
+  }
+  name(name) {
+    const self = this;
+    __privateSet(self, _name, name);
+    return self;
+  }
+  signals(signals) {
+    const self = this;
+    __privateSet(self, _signals, signals);
+    return self;
+  }
+  variant(variant, isInitial = false) {
+    const self = this;
+    if (isInitial && __privateGet(self, _variants).some(([_, i]) => i)) {
+      throw new StateFlowError("Only one initial state variant is allowed");
+    }
+    __privateGet(self, _variants).push([variant, isInitial]);
+    return self;
+  }
+  parser(func) {
+    __privateSet(this, _parser, func);
+    return this;
+  }
+  stringRepr(func) {
+    __privateSet(this, _stringRepr, func);
+    return this;
+  }
+  build() {
+    const signals = __privateGet(this, _signals);
+    const name = __privateGet(this, _name);
+    if (signals == null) {
+      throw new StateFlowError("Signals were not provided");
+    }
+    if (name === "") {
+      throw new StateFlowError("Name was not provided");
+    }
+    if (__privateGet(this, _variants).length === 0) {
+      throw new StateFlowError("No state variants are defined");
+    }
+    const def = extract.bind(null, name);
+    Object.assign(def, Object.fromEntries(__privateGet(this, _variants).map(([v, i]) => this.buildFactories(def, v, i))));
+    Object.defineProperties(def, {
+      [Symbol.toStringTag]: { value: __privateGet(this, _name), enumerable: false, configurable: false, writable: false },
+      [Symbol.toPrimitive]: { value: () => __privateGet(this, _name), enumerable: false, configurable: false, writable: false },
+      [SIGNALS]: { value: signals, enumerable: false, configurable: false, writable: false },
+      [PARSER]: { value: __privateGet(this, _parser), enumerable: false, configurable: false, writable: false },
+      [STRING_REPR]: { value: __privateGet(this, _stringRepr), enumerable: false, configurable: false, writable: false }
+    });
+    return Object.freeze(def);
+  }
+  buildFactories(def, variant, isInitial) {
+    const fn = Object.defineProperties(
+      function stateFactory(props) {
+        return factory(fn, props);
+      },
+      {
+        [Symbol.toStringTag]: { value: variant, enumerable: false, writable: false, configurable: false },
+        [Symbol.toPrimitive]: {
+          value: () => `${String(def)}.${String(variant)}`,
+          enumerable: false,
+          writable: false,
+          configurable: false
+        },
+        [DEF]: { value: def, enumerable: false, writable: false, configurable: false },
+        [HANDLERS]: { value: {}, enumerable: false, writable: false, configurable: false },
+        [IS_INITIAL]: { value: isInitial, enumerable: false, writable: false, configurable: false }
+      }
+    );
+    return [variant, fn];
+  }
+};
+_signals = new WeakMap();
+_variants = new WeakMap();
+_parser = new WeakMap();
+_stringRepr = new WeakMap();
+_name = new WeakMap();
+function defineState() {
+  return new StateBuilder();
+}
+function defineFlow(state, handlers) {
+  if (Object.isFrozen(state[HANDLERS])) {
+    throw new StateFlowError(`Flow is already defined: ${String(state)}`);
+  }
+  Object.assign(state[HANDLERS], handlers);
+  Object.freeze(state[HANDLERS]);
+}
+function handleSignal(state, signal, ctx) {
+  const signalName = signal[Symbol.toStringTag];
+  if (!stateAccepts(state, signalName)) {
+    return Result.ignore("");
+  }
+  const handler = state[VARIANT][HANDLERS][signalName];
+  try {
+    const result = handler(state, signal, ctx);
+    if (result instanceof Result) {
+      return result;
+    }
+    if (isState(result)) {
+      return Result.state(result);
+    }
+    return Result.state(state[VARIANT](result));
+  } catch (err) {
+    return Result.error(err);
+  }
+}
+
+// src/flow.ts
+var managementStateMap = /* @__PURE__ */ new WeakMap();
+var observersMap = /* @__PURE__ */ new WeakMap();
+var currentRC = {
+  ref: null,
+  set(rc) {
+    this.ref = rc;
+  },
+  clear() {
+    this.ref = null;
+  }
+};
+function eventKey(kind, state) {
+  return `${kind}:${state}`;
+}
+function stateMeta(target) {
+  const meta = managementStateMap.get(target);
+  if (meta == null) {
+    throw new StateFlowError(`${buildName(target)} doesn't contains state flows`);
+  }
+  return meta;
+}
+function addStateHandler(emitter, kind, stateVar2, cb, ctx) {
+  const wrapper = (state, snapshot, stateUpd, collector) => {
+    const handlerName = buildName(ctx, cb);
+    try {
+      const res = cb.apply(ctx, [state, snapshot]);
+      if (!(res instanceof Result)) {
+        throw new StateFlowError(`Handler '${handlerName}' returned not result`);
+      }
+      collector?.logHandler(String(stateVar2[DEF]), kind, handlerName, res);
+      collector?.push(res.withHandlerName(handlerName).withStateUpdating(stateUpd));
+    } catch (err) {
+      collector?.logHandler(String(stateVar2[DEF]), kind, handlerName, err);
+      collector?.push(Result.error(err).withHandlerName(handlerName).withStateUpdating(stateUpd));
+    }
+  };
+  emitter.on(eventKey(kind, String(stateVar2)), wrapper);
+}
+function applyFlow(target, states, initializer, config = {}) {
+  for (const def of states) {
+    if (!isStateDef(def)) {
+      throw new StateFlowError("Incorrect state definition");
+    }
+    const name = getName(def);
+    const st = target[name];
+    if (st == null) {
+      throw new StateFlowError(`State object ${name} not found`);
+    }
+    Object.defineProperty(target, name, { value: getInitialState(def)(st) });
+  }
+  const logHandlers = config.logHandlers?.length ? config.logHandlers : [consoleLogHandler];
+  const emitter = new EventEmitter();
+  managementStateMap.set(target, {
+    emitter,
+    logHandlers,
+    states,
+    transitioning: null,
+    lockHolder: null,
+    lockQueue: [],
+    logGroup: null,
+    name: String(Symbol.toStringTag in target ? target[Symbol.toStringTag] : target.constructor.name)
+  });
+  initializer({
+    addEnterHandler: addStateHandler.bind(null, emitter, "enter"),
+    addUpdateHandler: addStateHandler.bind(null, emitter, "update"),
+    addExitHandler: addStateHandler.bind(null, emitter, "exit"),
+    addRollbackHandler: addStateHandler.bind(null, emitter, "rollback")
+  });
+}
+function prepareSnapshot(target) {
+  const meta = managementStateMap.get(target);
+  if (meta == null) {
+    return {};
+  }
+  return Object.fromEntries(
+    meta.states.map((s) => [s[Symbol.toStringTag], Reflect.get(target, s[Symbol.toStringTag])])
+  );
+}
+function dispatch(target, signal, mute = false) {
+  const meta = stateMeta(target);
+  if (meta.lockHolder != null) {
+    throw new StateFlowError("Lock is held. Use `await using send = lock(target)` for queued access");
+  }
+  if (meta.transitioning != null) {
+    throw new StateFlowError("States are in transitioning. Use `await sync(obj)` or await a previous result");
+  }
+  const chainSnapshot = prepareSnapshot(target);
+  const result = dispatchCore(target, signal, meta, mute);
+  return processEnqueueChain(target, result, meta, chainSnapshot, mute);
+}
+async function lock(target, label) {
+  const meta = stateMeta(target);
+  const id = /* @__PURE__ */ Symbol("lock");
+  const dispatchContext = label != null ? getGlobalDispatchContext() : null;
+  const lockRequestedAt = dispatchContext != null ? Date.now() : 0;
+  if (meta.lockHolder != null || meta.lockQueue.length > 0) {
+    await new Promise((resolve) => meta.lockQueue.push({ id, resolve }));
+  } else {
+    meta.lockHolder = id;
+  }
+  await sync(target);
+  if (label != null) {
+    const lockWaitMs = dispatchContext != null ? Date.now() - lockRequestedAt : 0;
+    const context = dispatchContext != null && lockWaitMs >= 5 ? `${dispatchContext} [lock ${lockWaitMs}ms]` : dispatchContext;
+    meta.logGroup = { label, pending: [], context };
+  }
+  let chainSnapshot = null;
+  const dispose = async () => {
+    if (meta.lockHolder !== id) {
+      return;
+    }
+    if (meta.transitioning instanceof Promise) {
+      await meta.transitioning;
+    }
+    chainSnapshot = null;
+    const group = meta.logGroup;
+    if (group != null) {
+      meta.logGroup = null;
+      const settled = await Promise.allSettled(group.pending);
+      const entries = [];
+      for (const outcome of settled) {
+        if (outcome.status === "fulfilled") {
+          entries.push(outcome.value);
+        }
+      }
+      emitGrouped(withGlobalLogHandlers(meta.logHandlers), group.label, entries, group.context);
+    }
+    const next = meta.lockQueue.shift();
+    if (next) {
+      meta.lockHolder = next.id;
+      next.resolve();
+    } else {
+      meta.lockHolder = null;
+    }
+  };
+  const send = Object.assign(
+    (signal, mute = false) => {
+      if (meta.lockHolder !== id) {
+        throw new StateFlowError("Lock has been released");
+      }
+      if (chainSnapshot == null) {
+        chainSnapshot = prepareSnapshot(target);
+      }
+      const result = dispatchCore(target, signal, meta, mute);
+      return processEnqueueChain(target, result, meta, chainSnapshot, mute);
+    },
+    { [Symbol.asyncDispose]: dispose }
+  );
+  return send;
+}
+function dispatchCore(target, signal, meta, mute) {
+  const st = new Error().stack;
+  const collector = new ResultCollector(meta.name, signal, meta.transitioning != null);
+  let result = Result.ignore("");
+  let snapshot = prepareSnapshot(target);
+  try {
+    result = prepareStatesAfterSignal(target, signal, meta.states, collector);
+    if (!result.in(0 /* OK */) || result.data == null) {
+      return result.withSignal(signal).withStacktrace(st ?? null);
+    }
+    const processResult = result.data;
+    snapshot = processResult.snapshot;
+    for (const kind of ["exit", "update", "enter"]) {
+      processHandlers(kind, meta.emitter, processResult[kind], snapshot, collector);
+      result = collector.merge();
+      if (result.in(3 /* Rejected */, 4 /* Error */)) {
+        processHandlers("rollback", meta.emitter, processResult.rollback, prepareSnapshot(target), collector);
+        return result.withSignal(signal).withStacktrace(st ?? null);
+      }
+    }
+    result = result.merge(Result.ok());
+    for (const enqueued of result.enqueuedSignals) {
+      collector.logEnqueue(String(enqueued), result.message ?? "handler");
+    }
+    if (result.enqueuedSignals.length > 1) {
+      console.warn(
+        `[SF/${meta.name}] ${String(signal)}: ${result.enqueuedSignals.length} signals were enqueued in a single dispatch cycle by different handlers (${result.enqueuedSignals.map(String).join(", ")}). Only ONE enqueue per cycle (the self-terminating record chain) is supported; co-enqueuing from multiple handlers is unsupported and may not behave as expected.`
+      );
+    }
+    if (result.kind !== 2 /* InTransition */) {
+      meta.transitioning = true;
+      applyState(target, snapshot, collector);
+    } else {
+      meta.transitioning = result.withMeta(meta).waitAll().then((res) => {
+        meta.transitioning = null;
+        if (res.kind === 0 /* OK */) {
+          const preTransitionSnap = res.enqueuedSignals.length > 0 ? prepareSnapshot(target) : null;
+          applyState(target, snapshot, collector);
+          if (preTransitionSnap && res.enqueuedSignals.length > 0) {
+            const enqResult = processEnqueueChain(target, res, meta, preTransitionSnap, mute);
+            if (enqResult.in(3 /* Rejected */, 4 /* Error */)) {
+              return enqResult;
+            }
+          }
+        } else if (res.in(3 /* Rejected */, 4 /* Error */)) {
+          processHandlers("rollback", meta.emitter, processResult.rollback, prepareSnapshot(target), collector);
+        }
+        return res;
+      });
+    }
+    return result.withMeta(meta).withSignal(signal).withStacktrace(st ?? null);
+  } finally {
+    if (meta.transitioning === true) {
+      meta.transitioning = null;
+    }
+    if (!mute) {
+      const finished = collector.finish(snapshot, result);
+      const group = meta.logGroup;
+      if (group != null) {
+        group.pending.push(finished);
+      } else {
+        finished.then((entry) => {
+          withGlobalLogHandlers(meta.logHandlers).forEach((handler) => {
+            handler(entry);
+          });
+        }).catch(() => {
+        });
+      }
+    }
+  }
+}
+function processEnqueueChain(target, result, meta, chainSnapshot, mute) {
+  let current = result;
+  while (current.enqueuedSignals.length > 0) {
+    const signals = [...current.enqueuedSignals];
+    for (const signal of signals) {
+      const enqResult = dispatchCore(target, signal, meta, mute);
+      if (enqResult.in(3 /* Rejected */, 4 /* Error */)) {
+        rollbackToSnapshot(target, chainSnapshot);
+        return enqResult;
+      }
+      current = enqResult;
+    }
+  }
+  return current;
+}
+function rollbackToSnapshot(target, snapshot) {
+  for (const [key, value] of Object.entries(snapshot)) {
+    Reflect.set(target, key, value);
+  }
+}
+function prepareStatesAfterSignal(target, signal, states, collector) {
+  const processResult = {
+    snapshot: Object.fromEntries(states.map((s) => [s[Symbol.toStringTag], s(target)])),
+    enter: [],
+    update: [],
+    exit: [],
+    rollback: []
+  };
+  const results = [];
+  const unhandled = [];
+  for (const def of states) {
+    const name = getName(def);
+    const oldState = def(target);
+    if (!stateAccepts(oldState, signal[Symbol.toStringTag])) {
+      unhandled.push(String(oldState[Symbol.toStringTag]));
+    }
+    const result = handleSignal(oldState, signal, processResult.snapshot);
+    switch (result.kind) {
+      // state was successfully changed
+      case 0 /* OK */: {
+        const newState = result.data;
+        const desc = `'${oldState}->${newState}'`;
+        processResult.snapshot[name] = newState;
+        collector.logStateChange(def[Symbol.toStringTag], oldState, newState);
+        if (newState[VARIANT] === oldState[VARIANT]) {
+          processResult.update.push([newState, `update ${desc}`]);
+        } else {
+          processResult.enter.push([newState, `enter to ${desc}`]);
+          processResult.exit.push([oldState, `exit from ${desc}`]);
+        }
+        processResult.rollback.push([oldState, `rollback ${desc}`]);
+        break;
+      }
+      // the signal was ignored completely
+      case 1 /* Ignored */:
+        processResult.snapshot[name] = oldState;
+        break;
+      // got incorrect result
+      case 2 /* InTransition */:
+        return Result.error(new StateFlowError("Transition is not allowed in flow handlers")).withSignal(
+          signal
+        );
+      // Error or Rejected are left
+      default:
+        return result;
+    }
+    results.push(result);
+  }
+  const final = mergeResults(results);
+  if (final.kind !== 0 /* OK */) {
+    if (final.kind === 1 /* Ignored */ && final.message == null && unhandled.length === states.length) {
+      return Result.ignore(`no handler in ${unhandled.join(", ")}`);
+    }
+    return final;
+  }
+  return Result.ok(processResult);
+}
+function applyState(target, snapshot, rc) {
+  const meta = stateMeta(target);
+  currentRC.set(rc);
+  for (const [key, value] of Object.entries(snapshot)) {
+    if (value !== Reflect.get(target, key)) {
+      meta.emitter.emit(eventKey("observe", String(value[VARIANT])), Reflect.get(target, key), value);
+      Reflect.set(target, key, value);
+    }
+  }
+  currentRC.clear();
+}
+function processHandlers(kind, emitter, states, snapshot, collector) {
+  for (const [state, desc] of states) {
+    const key = eventKey(kind, String(state[VARIANT]));
+    emitter.emit(key, snapshot[state[VARIANT][DEF][Symbol.toStringTag]], snapshot, desc, collector);
+  }
+}
+async function sync(target) {
+  const meta = stateMeta(target);
+  const transitioning = meta.transitioning;
+  if (transitioning instanceof Promise) {
+    return new Promise((r) => {
+      const wait = () => {
+        if (meta.transitioning == null) {
+          r();
+          return;
+        }
+        transitioning.finally(() => setTimeout(wait, 0)).catch(() => {
+        });
+      };
+      wait();
+    });
+  }
+}
+function observe(target, stateVariants, handlerFn, compareFn = (a, b) => a !== b, ctx) {
+  const meta = stateMeta(target);
+  for (const stateVar2 of stateVariants) {
+    subscribe(meta.emitter, stateVar2, compareFn, handlerFn, ctx);
+  }
+  return {
+    [Symbol.dispose]: () => {
+      for (const stateVar2 of stateVariants) {
+        unsubscribe(meta.emitter, stateVar2, handlerFn);
+      }
+    }
+  };
+}
+function subscribe(emitter, stateVar2, cmpFn, hdlFn, ctx) {
+  const key = eventKey("observe", String(stateVar2));
+  const cb = (a, b) => {
+    const needObserve = cmpFn(a, b);
+    currentRC.ref?.logObserver(String(stateVar2[DEF]), buildName(ctx, hdlFn), needObserve);
+    if (needObserve) {
+      setTimeout(() => hdlFn(b), 0);
+    }
+  };
+  emitter.on(key, cb);
+  observersMap.set(hdlFn, [...observersMap.get(hdlFn) ?? [], cb]);
+}
+function unsubscribe(emitter, stateVar2, hdlFn) {
+  const key = eventKey("observe", String(stateVar2));
+  const cbs = observersMap.get(hdlFn);
+  cbs?.forEach((cb) => {
+    emitter.off(key, cb);
+  });
+}
+function disposeFlow(target) {
+  const meta = stateMeta(target);
+  meta.emitter.removeAllListeners();
+  Reflect.deleteProperty(meta, "emitter");
+  for (const state of meta.states) {
+    Reflect.deleteProperty(target, state[Symbol.toStringTag]);
+  }
+}
+
+// src/signal.ts
+function defineSignal(name, stringRepr = (args) => serializeDebug(args)) {
+  const fn = (p) => {
+    return Object.freeze({
+      ...p,
+      [SIGNAL]: true,
+      [Symbol.toStringTag]: name,
+      [Symbol.toPrimitive]: () => `${name}{${stringRepr(p)}}`
+    });
+  };
+  Reflect.defineProperty(fn, Symbol.toStringTag, {
+    value: name,
+    writable: false,
+    configurable: false,
+    enumerable: false
+  });
+  return fn;
+}
+
+// src/index.ts
+globalThis.__STATE_FLOW__ ?? (globalThis.__STATE_FLOW__ = {
+  version: `${package_json_default.version} (${package_json_default.branch} <${package_json_default.commit}>)`
+});
+export {
+  PARSER,
+  Result,
+  ResultCollector,
+  ResultKind,
+  SIGNALS,
+  STRING_REPR,
+  StateFlowError,
+  VARIANT,
+  addGlobalLogHandler,
+  applyFlow,
+  consoleLogHandler,
+  defineFlow,
+  defineSignal,
+  defineState,
+  dispatch,
+  disposeFlow,
+  isState,
+  lock,
+  observe,
+  serializeDebug,
+  setConsoleLogSilenced,
+  setGlobalDispatchContextProvider,
+  stateVar,
+  sync
+};
+//# sourceMappingURL=index.mjs.map