slapflow 1.0.2

package/dist/index.js

@@ -0,0 +1,2524 @@
+// src/helpers/config/defineConfig.ts
+var defineConfig = (config) => config;
+
+// src/helpers/trace/cloneData.ts
+var cloneData = (data) => ({ ...data });
+
+// src/helpers/trace/createMemoryTraceSink.ts
+var createMemoryTraceSink = () => {
+  const items = [];
+  return {
+    push: (entry) => {
+      items.push(entry);
+    },
+    entries: () => [...items]
+  };
+};
+
+// src/helpers/errors/slapError.ts
+var slapError = (code, message, extras = {}) => ({ code, message, ...extras });
+
+// src/helpers/errors/defineErrorReporter.ts
+var defineErrorReporter = (handlers) => typeof handlers === "function" ? handlers : handlers.report;
+
+// src/errors.ts
+var SyncAsyncError = class extends Error {
+  slapError;
+  constructor(error) {
+    super(error.message);
+    this.name = "SyncAsyncError";
+    this.slapError = error;
+  }
+};
+
+// src/helpers/ids/createId.ts
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var idLength = 12;
+var createId = () => {
+  const { crypto } = globalThis;
+  const randomValues = crypto?.getRandomValues ? crypto.getRandomValues(new Uint32Array(idLength)) : void 0;
+  return Array.from(
+    { length: idLength },
+    (_, index) => alphabet[Math.floor((randomValues?.[index] ?? Math.random() * 2 ** 32) / 2 ** 32 * alphabet.length)]
+  ).join("");
+};
+
+// src/helpers/pubSub/isBusEvent.ts
+var isBusEvent = (event) => {
+  if (!event || typeof event !== "object") {
+    return false;
+  }
+  const candidate = event;
+  return typeof candidate.id === "string" && typeof candidate.topic === "string" && typeof candidate.occurredAt === "number" && typeof candidate.serialized === "string" && "parsed" in candidate && (candidate.origin === void 0 || typeof candidate.origin === "string");
+};
+
+// src/helpers/pubSub/serializeError.ts
+var serializeError = (error) => ({
+  error: error instanceof Error ? error.message : String(error)
+});
+
+// src/pubSub.ts
+var createPubSub = (options = {}) => {
+  const subscribers = /* @__PURE__ */ new Map();
+  const dispatch = (event) => {
+    let dispatchedEvent;
+    if (!isBusEvent(event)) {
+      options.onError?.({
+        type: "serialization",
+        topic: "unknown",
+        payload: event,
+        error: new Error("Invalid bus event")
+      });
+    } else {
+      const handlers = subscribers.get(event.topic);
+      if (handlers) {
+        for (const handler of [...handlers]) {
+          try {
+            handler(event);
+          } catch (error) {
+            options.onError?.({ type: "subscriber", event, error });
+          }
+        }
+      }
+      dispatchedEvent = event;
+    }
+    return dispatchedEvent;
+  };
+  const on = (event, handler) => {
+    const handlers = subscribers.get(event) ?? /* @__PURE__ */ new Set();
+    const listener = handler;
+    handlers.add(listener);
+    subscribers.set(event, handlers);
+    return () => off(event, handler);
+  };
+  const off = (event, handler) => {
+    if (handler) {
+      const handlers = subscribers.get(event);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          subscribers.delete(event);
+        }
+      }
+    } else {
+      subscribers.delete(event);
+    }
+  };
+  const emit = (topic, payload, emitOptions = {}) => {
+    let event;
+    try {
+      const serialized = JSON.stringify(payload);
+      if (typeof serialized !== "string") {
+        throw new Error("Payload cannot be serialized");
+      }
+      event = {
+        id: createId(),
+        topic,
+        occurredAt: Date.now(),
+        ...emitOptions.origin ? { origin: emitOptions.origin } : {},
+        parsed: payload,
+        serialized
+      };
+    } catch (error) {
+      const parsed = serializeError(error);
+      event = {
+        id: createId(),
+        topic,
+        occurredAt: Date.now(),
+        ...emitOptions.origin ? { origin: emitOptions.origin } : {},
+        parsed,
+        serialized: JSON.stringify(parsed)
+      };
+      options.onError?.({
+        type: "serialization",
+        topic,
+        payload,
+        ...emitOptions.origin ? { origin: emitOptions.origin } : {},
+        error
+      });
+    }
+    return dispatch(event);
+  };
+  return { on, off, emit, dispatch };
+};
+var PubSub = createPubSub();
+
+// src/helpers/actions/coreDelay.ts
+var coreDelay = async ({
+  props,
+  signal
+}) => {
+  const ms = Math.max(0, Number(props.ms ?? 0));
+  await new Promise((resolve) => {
+    let timer;
+    const finish = () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    if (signal.aborted) {
+      finish();
+    } else {
+      timer = setTimeout(finish, ms);
+      signal.addEventListener("abort", finish, { once: true });
+    }
+  });
+};
+
+// src/helpers/actions/coreEmit.ts
+var coreEmit = ({
+  props,
+  runtime
+}) => {
+  const type = props.type;
+  if (typeof type === "string") {
+    runtime.emit({ type, payload: props.payload });
+  }
+};
+
+// src/helpers/actions/coreFail.ts
+var coreFail = ({
+  props,
+  runtime
+}) => runtime.fail(String(props.reason ?? "failed"), props.data);
+
+// src/helpers/retry/getRetryDelay.ts
+var getRetryDelay = (attempt, options) => {
+  const { initialDelay = 500, maxDelay = 1e4, multiplier = 2, jitter } = options;
+  const delay = Math.min(initialDelay * multiplier ** attempt, maxDelay);
+  return jitter === false ? delay : Math.round(delay * (0.5 + Math.random() * 0.5));
+};
+
+// src/helpers/retry/waitForRetry.ts
+var waitForRetry = (delay, signal) => new Promise((resolve, reject) => {
+  const timer = setTimeout(resolve, delay);
+  const abort = () => {
+    clearTimeout(timer);
+    reject(signal.reason);
+  };
+  signal.addEventListener("abort", abort, { once: true });
+});
+
+// src/helpers/actions/coreFetch.ts
+var defaultMaxAttempts = 2;
+var retryableStatuses = /* @__PURE__ */ new Set([408, 425, 429]);
+var credentialsValues = /* @__PURE__ */ new Set(["include", "same-origin", "omit"]);
+var responseReaders = {
+  json: (response) => response.json(),
+  text: (response) => response.text(),
+  blob: (response) => response.blob(),
+  arrayBuffer: (response) => response.arrayBuffer(),
+  none: async () => void 0
+};
+var coreFetch = async ({
+  props,
+  runtime,
+  signal
+}) => {
+  const {
+    acceptStatuses,
+    body,
+    contextPath,
+    credentials,
+    dataPath,
+    headers,
+    method,
+    response,
+    retry: retryProps,
+    retryStatuses,
+    url
+  } = props;
+  const responseType = typeof response === "string" ? response : "json";
+  const retry = retryProps ?? {};
+  const maxAttempts = Math.max(0, Number(retry.maxAttempts ?? defaultMaxAttempts));
+  const acceptedStatusSet = Array.isArray(acceptStatuses) ? new Set(acceptStatuses) : void 0;
+  const retryStatusSet = Array.isArray(retryStatuses) ? new Set(retryStatuses) : void 0;
+  const requestCredentials = typeof credentials === "string" ? credentials : void 0;
+  if (typeof url !== "string" || !url) {
+    return runtime.fail("core.fetch requires a non-empty url");
+  }
+  if (!Object.prototype.hasOwnProperty.call(responseReaders, responseType)) {
+    return runtime.fail("core.fetch response must be json, text, blob, arrayBuffer, or none");
+  }
+  if (credentials !== void 0 && (typeof credentials !== "string" || !credentialsValues.has(credentials))) {
+    return runtime.fail("core.fetch credentials must be include, same-origin, or omit");
+  }
+  for (let attempt = 0; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const request = {
+        signal,
+        ...typeof method === "string" ? { method } : {},
+        ...requestCredentials ? { credentials: requestCredentials } : {},
+        ...headers ? { headers } : {},
+        ...body === void 0 ? {} : { body }
+      };
+      const response2 = await fetch(url, request);
+      const accepted = acceptedStatusSet?.has(response2.status) ?? response2.ok;
+      if (accepted) {
+        let responseBody;
+        try {
+          responseBody = await responseReaders[responseType](response2);
+        } catch (cause) {
+          return runtime.fail("Fetch response could not be parsed", { cause });
+        }
+        const result = {
+          status: response2.status,
+          ok: response2.ok,
+          headers: Object.fromEntries(response2.headers),
+          body: responseBody
+        };
+        if (typeof dataPath === "string") {
+          runtime.data.set(dataPath, result);
+        }
+        if (typeof contextPath === "string") {
+          runtime.set(contextPath, result);
+        }
+        return;
+      }
+      const retryableStatus = retryStatusSet?.has(response2.status) ?? (retryableStatuses.has(response2.status) || response2.status >= 500);
+      if (attempt === maxAttempts || !retryableStatus) {
+        return runtime.fail(`Fetch request failed with status ${response2.status}`, { status: response2.status });
+      }
+    } catch (cause) {
+      if (signal.aborted) {
+        return false;
+      }
+      if (attempt === maxAttempts) {
+        return runtime.fail("Fetch request failed", { cause });
+      }
+    }
+    try {
+      await waitForRetry(getRetryDelay(attempt, retry), signal);
+    } catch (cause) {
+      return signal.aborted ? false : runtime.fail("Fetch retry was interrupted", { cause });
+    }
+  }
+};
+
+// src/helpers/runner/stopResult.ts
+var stopResult = (reason) => reason ? { type: "stop", reason } : { type: "stop" };
+
+// src/helpers/actions/coreLoop.ts
+var defaultMax = 999;
+var coreLoop = ({
+  props,
+  signal,
+  runtime
+}) => new Promise((resolve) => {
+  const configuredDuration = Number(props.duration ?? 0);
+  const duration = Number.isFinite(configuredDuration) ? Math.max(1, configuredDuration) : 1;
+  const configuredMax = Number(props.max ?? defaultMax);
+  const max = configuredMax === -1 ? Number.POSITIVE_INFINITY : Number.isFinite(configuredMax) && configuredMax >= 1 ? Math.floor(configuredMax) : defaultMax;
+  const immediate = props.immediate === true;
+  let iterationCount = 0;
+  let running = false;
+  let stopped = false;
+  const finish = (result) => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    clearInterval(interval);
+    signal.removeEventListener("abort", abort);
+    resolve(result);
+  };
+  const abort = () => {
+    clearInterval(interval);
+    finish({ continue: false });
+  };
+  const tick = async () => {
+    if (running || signal.aborted) {
+      return;
+    }
+    running = true;
+    iterationCount += 1;
+    try {
+      const result = await runtime.executeThen();
+      if (result.status === "failed") {
+        const recovered = await runtime.executeCatch();
+        if (recovered?.status === "failed") {
+          finish({ type: "fail", reason: recovered.error.message, error: recovered.error, handled: true });
+        } else if (recovered?.status === "stopped") {
+          finish(stopResult(recovered.reason));
+        } else if (!recovered) {
+          finish({ type: "fail", reason: result.error.message, error: result.error });
+        }
+      } else if (result.status === "stopped") {
+        finish(stopResult(result.reason));
+      }
+      if (!stopped && iterationCount >= max) {
+        finish({ continue: false });
+      }
+    } finally {
+      running = false;
+      if (signal.aborted) {
+        finish({ continue: false });
+      }
+    }
+  };
+  const interval = setInterval(() => {
+    void tick().catch((error) => {
+      finish({ type: "fail", reason: "core.loop tick failed", error });
+    });
+  }, duration);
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted) {
+    abort();
+    return;
+  }
+  if (immediate) {
+    void tick().catch((error) => {
+      finish({ type: "fail", reason: "core.loop tick failed", error });
+    });
+  }
+});
+
+// src/helpers/actions/coreNoop.ts
+var coreNoop = () => void 0;
+
+// src/helpers/actions/corePatch.ts
+var corePatch = ({
+  props,
+  runtime
+}) => {
+  if ("patch" in props) {
+    runtime.patch(props.patch);
+  }
+};
+
+// src/helpers/actions/coreSet.ts
+var coreSet = ({
+  props,
+  runtime
+}) => {
+  const path = props.path;
+  if (typeof path === "string") {
+    runtime.set(path, props.value);
+  }
+  return props.data ? { data: props.data } : void 0;
+};
+
+// src/helpers/actions/coreSetData.ts
+var coreSetData = ({
+  props,
+  runtime
+}) => {
+  const path = props.path;
+  if (typeof path === "string") {
+    runtime.data.set(path, props.value);
+  }
+  return props.data ? { data: props.data } : void 0;
+};
+
+// src/helpers/actions/coreStop.ts
+var coreStop = ({
+  props,
+  runtime
+}) => runtime.stop(String(props.reason ?? "stopped"));
+
+// src/registry/actions.ts
+var createActionsRegistry = () => /* @__PURE__ */ new Map([
+  ["core.noop", coreNoop],
+  ["core.stop", coreStop],
+  ["core.fail", coreFail],
+  ["core.fetch", coreFetch],
+  ["core.loop", coreLoop],
+  ["core.sequence", coreNoop],
+  ["core.selector", coreNoop],
+  ["core.parallel", coreNoop],
+  ["core.set", coreSet],
+  ["core.setData", coreSetData],
+  ["core.emit", coreEmit],
+  ["core.patch", corePatch],
+  ["core.delay", coreDelay]
+]);
+
+// src/helpers/conditions/changedCondition.ts
+var changedCondition = (_args, current, previous) => !Object.is(current, previous);
+
+// src/helpers/conditions/cooldownReadyCondition.ts
+var cooldownReadyCondition = (_args, now, lastAt, cooldownMs) => {
+  if (lastAt == null) {
+    return true;
+  }
+  return Number(now) - Number(lastAt) >= Number(cooldownMs ?? 0);
+};
+
+// src/helpers/conditions/sizeOf.ts
+var sizeOf = (value) => {
+  if (value == null) {
+    return 0;
+  }
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    return value.size;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length;
+  }
+  return 0;
+};
+
+// src/helpers/conditions/emptyCondition.ts
+var emptyCondition = (_args, value) => sizeOf(value) === 0;
+
+// src/helpers/conditions/eqCondition.ts
+var eqCondition = (_args, left, right) => Object.is(left, right);
+
+// src/helpers/conditions/existsCondition.ts
+var existsCondition = (_args, value) => value !== void 0 && value !== null;
+
+// src/helpers/conditions/falsyCondition.ts
+var falsyCondition = (_args, value) => !value;
+
+// src/helpers/conditions/gtCondition.ts
+var gtCondition = (_args, left, right) => Number(left) > Number(right);
+
+// src/helpers/conditions/gteCondition.ts
+var gteCondition = (_args, left, right) => Number(left) >= Number(right);
+
+// src/helpers/conditions/includesCondition.ts
+var includesCondition = (_args, collection, value) => {
+  if (typeof collection === "string") {
+    return collection.includes(String(value));
+  }
+  if (Array.isArray(collection)) {
+    return collection.includes(value);
+  }
+  if (collection instanceof Set) {
+    return collection.has(value);
+  }
+  return false;
+};
+
+// src/helpers/conditions/ltCondition.ts
+var ltCondition = (_args, left, right) => Number(left) < Number(right);
+
+// src/helpers/conditions/lteCondition.ts
+var lteCondition = (_args, left, right) => Number(left) <= Number(right);
+
+// src/helpers/conditions/missingCondition.ts
+var missingCondition = (_args, value) => value === void 0 || value === null;
+
+// src/helpers/conditions/neqCondition.ts
+var neqCondition = (_args, left, right) => !Object.is(left, right);
+
+// src/helpers/conditions/notEmptyCondition.ts
+var notEmptyCondition = (_args, value) => sizeOf(value) > 0;
+
+// src/helpers/conditions/truthyCondition.ts
+var truthyCondition = (_args, value) => Boolean(value);
+
+// src/helpers/conditions/typeIsCondition.ts
+var typeIsCondition = (_args, value, expected) => {
+  if (expected === "finite-number") {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  if (expected === "array") {
+    return Array.isArray(value);
+  }
+  if (expected === "record") {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  return expected === "string" || expected === "number" || expected === "boolean" ? typeof value === expected : false;
+};
+
+// src/registry/conditions.ts
+var createConditionsRegistry = () => /* @__PURE__ */ new Map([
+  ["eq", eqCondition],
+  ["neq", neqCondition],
+  ["gt", gtCondition],
+  ["gte", gteCondition],
+  ["lt", ltCondition],
+  ["lte", lteCondition],
+  ["truthy", truthyCondition],
+  ["falsy", falsyCondition],
+  ["exists", existsCondition],
+  ["missing", missingCondition],
+  ["empty", emptyCondition],
+  ["notEmpty", notEmptyCondition],
+  ["includes", includesCondition],
+  ["typeIs", typeIsCondition],
+  ["changed", changedCondition],
+  ["cooldownReady", cooldownReadyCondition]
+]);
+
+// src/helpers/runner/applyResult.ts
+var applyResult = (result, state, mergeData) => {
+  if (result.status === "success" && result.context !== void 0) {
+    state.context = result.context;
+  }
+  if ("data" in result && result.data) {
+    state.data = mergeData(state.data, result.data);
+  }
+  state.patches.push(...result.patches);
+  state.events.push(...result.events);
+};
+
+// src/helpers/path/resolveValue.ts
+import { pick as pick3 } from "objwalk";
+
+// src/helpers/path/childPath.ts
+var childPath = (path, key) => typeof key === "number" ? `${path}[${key}]` : path ? `${path}.${key}` : key;
+
+// src/helpers/path/ResolutionError.ts
+var ResolutionError = class extends Error {
+  slapError;
+  constructor(slapError2) {
+    super(slapError2.message);
+    this.name = "ResolutionError";
+    this.slapError = slapError2;
+  }
+};
+
+// src/helpers/path/createResolutionError.ts
+var createResolutionError = (code, message, scope, path) => new ResolutionError(
+  slapError(code, message, {
+    ...scope.strategy ? { strategy: scope.strategy } : {},
+    path
+  })
+);
+
+// src/helpers/path/evaluateExpression.ts
+import { pick as pick2 } from "objwalk";
+
+// src/helpers/path/failExpression.ts
+var failExpression = (code, message, details) => {
+  throw new ResolutionError(slapError(code, message, details));
+};
+
+// src/helpers/path/finiteNumbers.ts
+var finiteNumbers = (operator, args, count, details) => {
+  const [minimum, maximum] = typeof count === "number" ? [count, count] : count;
+  if (args.length < minimum || args.length > maximum || args.some((value) => typeof value !== "number" || !Number.isFinite(value))) {
+    failExpression("EXPRESSION_INVALID_ARGUMENT", `Expression "${operator}" requires finite number arguments`, details);
+  }
+  return args;
+};
+
+// src/helpers/path/propertyValue.ts
+import { pick } from "objwalk";
+
+// src/helpers/path/protectedPickOptions.ts
+var protectedPickOptions = {
+  inherited: false,
+  ignore: ["__proto__", "prototype", "constructor"]
+};
+
+// src/helpers/path/propertyValue.ts
+var propertyValue = (target, key, details) => {
+  if (typeof target !== "object" && typeof target !== "function" || target === null || typeof key !== "string") {
+    failExpression("EXPRESSION_PATH_NOT_FOUND", "Expression property was not found", details);
+  }
+  const resolved = pick(target, key, protectedPickOptions);
+  if (resolved === void 0) {
+    failExpression("EXPRESSION_PATH_NOT_FOUND", "Expression property was not found", details);
+  }
+  return resolved;
+};
+
+// src/helpers/path/evaluateExpression.ts
+var evaluateExpression = (operator, args, custom, details) => {
+  if (operator === "add") {
+    return finiteNumbers(operator, args, [2, Infinity], details).reduce((a, b) => a + b);
+  }
+  if (operator === "subtract") {
+    const numbers = finiteNumbers(operator, args, 2, details);
+    const a = numbers[0];
+    const b = numbers[1];
+    return a - b;
+  }
+  if (operator === "multiply") {
+    return finiteNumbers(operator, args, [2, Infinity], details).reduce((a, b) => a * b);
+  }
+  if (operator === "divide" || operator === "modulo") {
+    const numbers = finiteNumbers(operator, args, 2, details);
+    const a = numbers[0];
+    const b = numbers[1];
+    if (b === 0) {
+      failExpression("EXPRESSION_DIVISION_BY_ZERO", `Expression "${operator}" cannot divide by zero`, details);
+    }
+    return operator === "divide" ? a / b : a % b;
+  }
+  if (operator === "min" || operator === "max") {
+    return Math[operator](...finiteNumbers(operator, args, [1, Infinity], details));
+  }
+  if (["abs", "round", "floor", "ceil"].includes(operator)) {
+    const value = finiteNumbers(operator, args, 1, details)[0];
+    return Math[operator](value);
+  }
+  if (operator === "clamp") {
+    const numbers = finiteNumbers(operator, args, 3, details);
+    const value = numbers[0];
+    const minimum = numbers[1];
+    const maximum = numbers[2];
+    if (minimum > maximum) {
+      failExpression("EXPRESSION_INVALID_ARGUMENT", 'Expression "clamp" minimum exceeds maximum', details);
+    }
+    return Math.min(Math.max(value, minimum), maximum);
+  }
+  if (operator === "at") {
+    if (args.length !== 2) {
+      failExpression("EXPRESSION_INVALID_ARGUMENT", 'Expression "at" requires two arguments', details);
+    }
+    const target = args[0];
+    const index = args[1];
+    if (!Array.isArray(target) || typeof index !== "number" || !Number.isInteger(index) || index < 0) {
+      failExpression(
+        "EXPRESSION_INVALID_ARGUMENT",
+        'Expression "at" requires an array and a non-negative integer',
+        details
+      );
+    }
+    const resolved = pick2(target, String(index), protectedPickOptions);
+    if (resolved === void 0) {
+      failExpression("EXPRESSION_PATH_NOT_FOUND", "Expression array index was not found", details);
+    }
+    return resolved;
+  }
+  if (operator === "property") {
+    if (args.length !== 2) {
+      failExpression("EXPRESSION_INVALID_ARGUMENT", 'Expression "property" requires two arguments', details);
+    }
+    return propertyValue(args[0], args[1], details);
+  }
+  if (operator === "get") {
+    if (args.length !== 2 || typeof args[1] !== "string") {
+      failExpression("EXPRESSION_INVALID_ARGUMENT", 'Expression "get" requires an object and a path string', details);
+    }
+    const resolved = pick2(args[0], args[1], protectedPickOptions);
+    if (resolved === void 0) {
+      return failExpression("EXPRESSION_PATH_NOT_FOUND", "Expression path was not found", details);
+    }
+    return resolved;
+  }
+  if (operator === "concat") {
+    if (args.some((value) => !["string", "number", "boolean", "bigint"].includes(typeof value))) {
+      failExpression(
+        "EXPRESSION_INVALID_ARGUMENT",
+        'Expression "concat" requires primitive string-compatible arguments',
+        details
+      );
+    }
+    return args.map(String).join("");
+  }
+  if (!Object.prototype.hasOwnProperty.call(custom, operator)) {
+    failExpression("EXPRESSION_OPERATOR_NOT_FOUND", `Expression operator "${operator}" is not registered`, details);
+  }
+  const customOperator = custom[operator];
+  try {
+    return customOperator(args);
+  } catch (cause) {
+    const causeType = cause instanceof Error ? "Error" : typeof cause;
+    throw new ResolutionError(
+      slapError("EXPRESSION_INVALID_ARGUMENT", `Expression operator "${operator}" rejected its arguments`, {
+        ...details,
+        cause: { type: causeType }
+      })
+    );
+  }
+};
+
+// src/helpers/path/pathReferenceRegex.ts
+var pathReferenceRegex = /^\$(context|data|input|variables)(?:\.([A-Za-z0-9_$.[\]-]+))?$/;
+
+// src/helpers/path/parseTemplate.ts
+var variablePattern = /^([A-Za-z_$][A-Za-z0-9_$]*)(?::-([^}]*))?$/;
+var dataPathPattern = /^[A-Za-z0-9_$.[\]-]+$/;
+var parseTemplate = (template) => {
+  const parts = [];
+  let literal = "";
+  let offset = 0;
+  const flushLiteral = () => {
+    if (literal) {
+      parts.push({ type: "literal", value: literal });
+      literal = "";
+    }
+  };
+  while (offset < template.length) {
+    if (template[offset] === "\\") {
+      let end = offset;
+      while (template[end] === "\\") {
+        end += 1;
+      }
+      const slashCount = end - offset;
+      const delimiter = template.startsWith("${", end) ? "${" : template.startsWith("{{", end) ? "{{" : void 0;
+      if (delimiter) {
+        literal += "\\".repeat(Math.floor(slashCount / 2));
+        if (slashCount % 2 === 1) {
+          literal += delimiter;
+          offset = end + delimiter.length;
+          continue;
+        }
+        offset = end;
+      } else {
+        literal += "\\".repeat(Math.ceil(slashCount / 2));
+        offset = end;
+        continue;
+      }
+    }
+    if (template.startsWith("${", offset)) {
+      const end = template.indexOf("}", offset + 2);
+      if (end < 0) {
+        return { ok: false };
+      }
+      const match = template.slice(offset + 2, end).match(variablePattern);
+      if (!match) {
+        return { ok: false };
+      }
+      flushLiteral();
+      parts.push({
+        type: "variable",
+        name: match[1],
+        ...match[2] === void 0 ? {} : { fallback: match[2] }
+      });
+      offset = end + 1;
+      continue;
+    }
+    if (template.startsWith("{{", offset)) {
+      const end = template.indexOf("}}", offset + 2);
+      if (end < 0) {
+        return { ok: false };
+      }
+      const path = template.slice(offset + 2, end).trim();
+      if (!dataPathPattern.test(path)) {
+        return { ok: false };
+      }
+      flushLiteral();
+      parts.push({ type: "data", path });
+      offset = end + 2;
+      continue;
+    }
+    literal += template[offset];
+    offset += 1;
+  }
+  if (literal || parts.length === 0) {
+    parts.push({ type: "literal", value: literal });
+  }
+  return { ok: true, parts };
+};
+
+// src/helpers/path/resolveValue.ts
+var resolveValue = (value, scope, path = scope.configPath ?? "") => {
+  if (typeof value === "string") {
+    const match = value.match(pathReferenceRegex);
+    if (!match) {
+      return value;
+    }
+    const root = match[1];
+    const nestedPath = match[2] ?? "";
+    if (root !== "variables") {
+      const source2 = scope[root];
+      if (!nestedPath) {
+        return source2;
+      }
+      if (!source2 || typeof source2 !== "object") {
+        return void 0;
+      }
+      return pick3(source2, nestedPath);
+    }
+    const source = scope.variables ?? {};
+    if (!nestedPath) {
+      return source;
+    }
+    const resolved = pick3(source, nestedPath, protectedPickOptions);
+    if (resolved === void 0) {
+      throw createResolutionError("VARIABLE_NOT_FOUND", "Variable reference was not found", scope, path);
+    }
+    return resolved;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => resolveValue(item, scope, childPath(path, index)));
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    if (Object.prototype.hasOwnProperty.call(record, "$expression")) {
+      if (!Array.isArray(record.$expression) || typeof record.$expression[0] !== "string") {
+        throw createResolutionError("EXPRESSION_INVALID_ARGUMENT", "Expression must contain an operator", scope, path);
+      }
+      const [operator, ...rawArgs] = record.$expression;
+      const args = rawArgs.map(
+        (argument, index) => resolveValue(argument, scope, childPath(childPath(path, "$expression"), index + 1))
+      );
+      return evaluateExpression(operator, args, scope.expressions ?? {}, {
+        ...scope.strategy ? { strategy: scope.strategy } : {},
+        path
+      });
+    }
+    if (typeof record.$template === "string") {
+      const parsed = parseTemplate(record.$template);
+      if (!parsed.ok) {
+        throw createResolutionError("TEMPLATE_INVALID", "Template syntax is invalid", scope, path);
+      }
+      return parsed.parts.map((part) => {
+        if (part.type === "literal") {
+          return part.value;
+        }
+        if (part.type === "data") {
+          const scopedPath = part.path.match(/^(context|data|input)\.(.+)$/);
+          const source = scopedPath ? scope[scopedPath[1]] : scope.data;
+          const resolved2 = pick3(source, scopedPath?.[2] ?? part.path);
+          return resolved2 == null ? "" : String(resolved2);
+        }
+        const resolved = pick3(scope.variables ?? {}, part.name, protectedPickOptions);
+        if (resolved === void 0 || resolved === null || part.fallback !== void 0 && resolved === "") {
+          if (part.fallback !== void 0) {
+            return part.fallback;
+          }
+          throw createResolutionError("VARIABLE_NOT_FOUND", "Template variable was not found", scope, path);
+        }
+        return String(resolved);
+      }).join("");
+    }
+    return Object.fromEntries(
+      Object.entries(record).map(([key, item]) => [key, resolveValue(item, scope, childPath(path, key))])
+    );
+  }
+  return value;
+};
+
+// src/helpers/runner/evaluateCondition.ts
+var evaluateCondition = (expression, registry, scope) => {
+  if (expression === void 0) {
+    return { ok: true, matched: true };
+  }
+  if (typeof expression === "boolean") {
+    return { ok: true, matched: expression };
+  }
+  const [operator, ...rawArgs] = expression;
+  if (operator === "and") {
+    for (const item of rawArgs) {
+      const result = evaluateCondition(item, registry, scope);
+      if (!result.ok || !result.matched) {
+        return result;
+      }
+    }
+    return { ok: true, matched: true };
+  }
+  if (operator === "or") {
+    for (const item of rawArgs) {
+      const result = evaluateCondition(item, registry, scope);
+      if (!result.ok) {
+        return result;
+      }
+      if (result.matched) {
+        return { ok: true, matched: true };
+      }
+    }
+    return { ok: true, matched: false };
+  }
+  if (operator === "not") {
+    const result = evaluateCondition(rawArgs[0], registry, scope);
+    return result.ok ? { ok: true, matched: !result.matched } : result;
+  }
+  const condition = registry.get(operator);
+  if (!condition) {
+    return {
+      ok: false,
+      error: slapError("CONDITION_NOT_FOUND", `Condition "${operator}" is not registered`, {
+        ...scope.strategy ? { strategy: scope.strategy } : {}
+      })
+    };
+  }
+  try {
+    const configPath = scope.strategy ? `strategies.${scope.strategy}.when` : "when";
+    const args = rawArgs.map((arg, index) => resolveValue(arg, { ...scope, configPath: `${configPath}[${index + 1}]` }));
+    return { ok: true, matched: Boolean(condition(scope, ...args)) };
+  } catch (cause) {
+    if (cause instanceof ResolutionError) {
+      return { ok: false, error: cause.slapError };
+    }
+    throw cause;
+  }
+};
+
+// src/helpers/runner/createRuntime.ts
+import { pick as pick4, set } from "objwalk";
+var createRuntime = (state, branches = {
+  executeThen: async () => ({ status: "success" }),
+  executeCatch: async () => void 0
+}) => {
+  const data = {
+    get: (path) => pick4(state.data, path),
+    set: (path, value) => {
+      if (!state.closed) {
+        set(state.data, path, value);
+      }
+    }
+  };
+  return {
+    get: (path) => pick4(state.context, path),
+    set: (path, value) => {
+      if (!state.closed) {
+        set(state.context, path, value);
+      }
+    },
+    data,
+    variables: {
+      get: (path) => pick4(state.variables, path, protectedPickOptions)
+    },
+    getData: (path) => {
+      console.warn("runtime.getData() is deprecated; use runtime.data.get() instead");
+      return data.get(path);
+    },
+    setData: (path, value) => {
+      console.warn("runtime.setData() is deprecated; use runtime.data.set() instead");
+      data.set(path, value);
+    },
+    resolve: (value) => resolveValue(value, state),
+    signal: state.signal,
+    executeThen: async () => state.closed ? { status: "stopped", reason: "Run is already finished" } : branches.executeThen(),
+    executeCatch: async () => state.closed ? void 0 : branches.executeCatch(),
+    emit: (event) => {
+      if (!state.closed) {
+        state.events.push(event);
+      }
+    },
+    patch: (patch) => {
+      if (!state.closed) {
+        state.patches.push(patch);
+      }
+    },
+    stop: (reason) => stopResult(reason),
+    fail: (reason, failureData) => ({
+      type: "fail",
+      ...reason ? { reason } : {},
+      ...failureData ? { data: failureData } : {}
+    })
+  };
+};
+
+// src/helpers/runner/executeNext.ts
+var executeNext = (item, depth, state, environment) => {
+  const id = typeof item === "string" ? item : item.strategy;
+  if (typeof item !== "string" && item.when) {
+    const runtime = createRuntime(state);
+    const condition = evaluateCondition(item.when, environment.conditionsRegistry, { ...state, runtime, strategy: id });
+    if (!condition.ok) {
+      return { status: "failed", error: condition.error, patches: [], events: [] };
+    }
+    if (!condition.matched) {
+      return {
+        status: "skipped",
+        reason: "next condition did not match",
+        patches: [],
+        events: []
+      };
+    }
+  }
+  const extraProps = typeof item === "string" ? {} : item.props ?? {};
+  return executeStrategy(id, extraProps, depth, state, environment);
+};
+
+// src/helpers/runner/cloneParallelValue.ts
+var cloneParallelValue = (value, seen = /* @__PURE__ */ new WeakMap()) => {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const existing = seen.get(value);
+  if (existing) {
+    return existing;
+  }
+  if (Array.isArray(value)) {
+    const clone2 = [];
+    seen.set(value, clone2);
+    for (const item of value) {
+      clone2.push(cloneParallelValue(item, seen));
+    }
+    return clone2;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    return value;
+  }
+  const clone = {};
+  seen.set(value, clone);
+  for (const [key, item] of Object.entries(value)) {
+    clone[key] = cloneParallelValue(item, seen);
+  }
+  return clone;
+};
+
+// src/helpers/runner/isPromiseLike.ts
+var isPromiseLike = (value) => Boolean(value && typeof value === "object" && "then" in value && typeof value.then === "function");
+
+// src/helpers/runner/executeSequence.ts
+var executeSequence = (items, depth, state, environment) => {
+  let index = 0;
+  const loop = () => {
+    if (index >= items.length) {
+      return { status: "success", patches: [], events: [] };
+    }
+    const result = executeNext(items[index++], depth + 1, state, environment);
+    const next = (value) => {
+      if (value.status !== "success") {
+        return value;
+      }
+      return loop();
+    };
+    return isPromiseLike(result) ? result.then(next) : next(result);
+  };
+  return loop();
+};
+
+// src/helpers/runner/skippedResult.ts
+var skippedResult = (reason, data) => ({
+  status: "skipped",
+  patches: [],
+  events: [],
+  ...reason ? { reason } : {},
+  ...data ? { data } : {}
+});
+
+// src/helpers/runner/successResult.ts
+var successResult = () => ({
+  status: "success",
+  patches: [],
+  events: []
+});
+
+// src/helpers/runner/executeParallel.ts
+var executeParallel = (items, depth, state, environment) => {
+  if (state.sync) {
+    return executeSequence(items, depth, state, environment);
+  }
+  const snapshots = items.map((item) => {
+    const child = {
+      ...state,
+      context: cloneParallelValue(state.context),
+      patches: [],
+      events: [],
+      data: cloneParallelValue(state.data)
+    };
+    return Promise.resolve(executeNext(item, depth + 1, child, environment)).then((result) => ({ result, child }));
+  });
+  return Promise.all(snapshots).then((results) => {
+    for (const { result } of results) {
+      if (result.status === "failed" || result.status === "stopped") {
+        return result;
+      }
+    }
+    for (const { child } of results) {
+      state.patches.push(...child.patches);
+      state.events.push(...child.events);
+      state.data = environment.mergeData(state.data, child.data);
+    }
+    return results.some(({ result }) => result.status === "success") ? successResult() : skippedResult("All parallel branches skipped");
+  });
+};
+
+// src/helpers/runner/executeSelector.ts
+var executeSelector = (items, depth, state, environment) => {
+  let index = 0;
+  const loop = () => {
+    if (index >= items.length) {
+      return { status: "skipped", reason: "No selector branch matched", patches: [], events: [] };
+    }
+    const result = executeNext(items[index++], depth + 1, state, environment);
+    const next = (value) => {
+      if (value.status === "skipped") {
+        return loop();
+      }
+      return value;
+    };
+    return isPromiseLike(result) ? result.then(next) : next(result);
+  };
+  return loop();
+};
+
+// src/helpers/runner/executeThen.ts
+var executeThen = (strategy, depth, state, environment) => {
+  const items = strategy.then ?? [];
+  if (items.length === 0) {
+    return { status: "success", patches: [], events: [] };
+  }
+  const mode = strategy.mode ?? "sequence";
+  if (mode === "selector") {
+    return executeSelector(items, depth, state, environment);
+  }
+  if (mode === "parallel") {
+    return executeParallel(items, depth, state, environment);
+  }
+  return executeSequence(items, depth, state, environment);
+};
+
+// src/helpers/errors/compactErrorStage.ts
+var compactErrorStage = (stage) => Object.fromEntries(Object.entries(stage).filter(([, value]) => value !== void 0));
+
+// src/helpers/errors/withErrorStage.ts
+var withErrorStage = (error, stage) => {
+  const nextError = {
+    ...error,
+    stage: compactErrorStage({
+      ...stage,
+      ...error.stage
+    })
+  };
+  const { strategy: errorStrategy, fn: errorFn } = error;
+  const { strategy: stageStrategy, fn: stageFn } = stage;
+  const strategy = errorStrategy ?? stageStrategy;
+  const fn = errorFn ?? stageFn;
+  if (strategy) {
+    nextError.strategy = strategy;
+  }
+  if (fn) {
+    nextError.fn = fn;
+  }
+  return nextError;
+};
+
+// src/helpers/runner/handleFailure.ts
+var handleFailure = (error, strategy, depth, state, environment) => {
+  const stagedError = withErrorStage(error, {
+    phase: error.stage?.phase ?? "action",
+    strategy: error.strategy,
+    fn: error.fn ?? strategy.fn,
+    mode: strategy.mode,
+    depth,
+    step: state.stepCounter.current
+  });
+  environment.options.onError?.({
+    error: stagedError,
+    context: state.context,
+    input: state.input,
+    data: state.data,
+    patches: state.patches,
+    events: state.events,
+    ...state.traceSink?.entries ? { trace: state.traceSink.entries() } : {}
+  });
+  state.reportedErrors.push(stagedError);
+  if (strategy.catch?.length) {
+    const caught = executeSequence(strategy.catch, depth, state, environment);
+    const stageCatchFailure = (result) => {
+      if (result.status === "failed") {
+        return {
+          ...result,
+          error: {
+            ...result.error,
+            stage: {
+              ...result.error.stage,
+              phase: "catch"
+            }
+          }
+        };
+      }
+      return result;
+    };
+    return isPromiseLike(caught) ? caught.then(stageCatchFailure) : stageCatchFailure(caught);
+  }
+  return { status: "failed", error: stagedError, patches: [], events: [] };
+};
+
+// src/helpers/runner/normalizeActionResult.ts
+var normalizeActionResult = (raw) => {
+  if (raw === false) {
+    return skippedResult();
+  }
+  if (raw == null) {
+    return successResult();
+  }
+  const patches = "patch" in raw && raw.patch !== void 0 ? [].concat(raw.patch) : [];
+  const events = "events" in raw && raw.events ? raw.events : [];
+  if (raw.type === "skip") {
+    return skippedResult(raw.reason, raw.data);
+  }
+  if (raw.type === "stop") {
+    return { status: "stopped", patches, events, ...raw.reason ? { reason: raw.reason } : {} };
+  }
+  if (raw.type === "fail") {
+    const suppliedError = raw.error && typeof raw.error === "object" && "code" in raw.error && "message" in raw.error ? raw.error : void 0;
+    return {
+      status: "failed",
+      error: suppliedError ?? slapError("ACTION_THROWN", raw.reason ?? "Action failed", { cause: raw.error }),
+      patches: [],
+      events: [],
+      ...raw.data ? { data: raw.data } : {},
+      ...raw.handled ? { handled: true } : {}
+    };
+  }
+  return {
+    status: "success",
+    patches,
+    events,
+    ...raw.context !== void 0 ? { context: raw.context } : {},
+    ...raw.data ? { data: raw.data } : {},
+    ...raw.continue !== void 0 ? { continue: raw.continue } : {}
+  };
+};
+
+// src/helpers/runner/pushTrace.ts
+var pushTrace = (state, step, depth, strategyId, strategy, status, props, dataBefore, startedAt, reason) => {
+  state.traceSink?.push({
+    step,
+    depth,
+    strategy: strategyId,
+    fn: strategy.fn,
+    mode: strategy.mode,
+    status,
+    input: state.input,
+    props,
+    dataBefore,
+    dataAfter: cloneData(state.data),
+    durationMs: Date.now() - startedAt,
+    ...reason ? { reason } : {}
+  });
+};
+
+// src/helpers/runner/traceReason.ts
+var traceReason = (result) => {
+  if (result.status === "failed") {
+    return result.error.message;
+  }
+  if (result.status === "success") {
+    return void 0;
+  }
+  return result.reason;
+};
+
+// src/helpers/runner/afterAction.ts
+var afterAction = (raw, id, strategy, depth, state, props, dataBefore, traceStep, startedAt, environment) => {
+  const result = normalizeActionResult(raw);
+  const reason = traceReason(result);
+  if (result.status === "failed") {
+    result.error = withErrorStage(result.error, {
+      phase: "action",
+      strategy: id,
+      fn: strategy.fn,
+      mode: strategy.mode,
+      depth,
+      step: traceStep
+    });
+  }
+  applyResult(result, state, environment.mergeData);
+  pushTrace(
+    state,
+    traceStep,
+    depth,
+    id,
+    strategy,
+    result.status === "success" ? "success" : result.status,
+    props,
+    dataBefore,
+    startedAt,
+    reason
+  );
+  if (result.status === "failed") {
+    return result.handled ? result : handleFailure(result.error, strategy, depth, state, environment);
+  }
+  if (result.status === "skipped" || result.status === "stopped" || strategy.terminal || result.continue === false) {
+    return result;
+  }
+  return executeThen(strategy, depth, state, environment);
+};
+
+// src/helpers/runner/runnerDefaults.ts
+var defaultMaxStepCount = 1e3;
+var defaultMaxDepth = 32;
+
+// src/helpers/runner/failLimit.ts
+var failLimit = (code, message, id) => ({
+  status: "failed",
+  error: slapError(code, message, { strategy: id, stage: { phase: "limit", strategy: id } }),
+  patches: [],
+  events: []
+});
+
+// src/helpers/trace/dependsOnVariables.ts
+var dependsOnVariables = (value) => {
+  if (typeof value === "string") {
+    return value === "$variables" || value.startsWith("$variables.");
+  }
+  if (Array.isArray(value)) {
+    return value.some(dependsOnVariables);
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.$template === "string") {
+      const parsed = parseTemplate(record.$template);
+      return parsed.ok && parsed.parts.some((part) => part.type === "variable");
+    }
+    return Object.values(record).some(dependsOnVariables);
+  }
+  return false;
+};
+
+// src/helpers/trace/redactVariableProps.ts
+var redactVariableProps = (raw, resolved) => {
+  if (typeof raw === "string" && (raw === "$variables" || raw.startsWith("$variables.")) || raw && typeof raw === "object" && !Array.isArray(raw) && (typeof raw.$template === "string" && dependsOnVariables(raw) || Object.prototype.hasOwnProperty.call(raw, "$expression") && dependsOnVariables(raw))) {
+    return "[REDACTED]";
+  }
+  if (Array.isArray(raw) && Array.isArray(resolved)) {
+    return raw.map((item, index) => redactVariableProps(item, resolved[index]));
+  }
+  if (raw && resolved && typeof raw === "object" && typeof resolved === "object") {
+    return Object.fromEntries(
+      Object.entries(raw).map(([key, item]) => [
+        key,
+        redactVariableProps(item, resolved[key])
+      ])
+    );
+  }
+  return resolved;
+};
+
+// src/helpers/runner/toRuntimeResult.ts
+var toRuntimeResult = (result) => {
+  if (result.status === "failed") {
+    return { status: "failed", error: result.error };
+  }
+  if (result.status === "stopped") {
+    return { status: "stopped", ..."reason" in result && result.reason ? { reason: result.reason } : {} };
+  }
+  if (result.status === "skipped") {
+    return { status: "skipped", ...result.reason ? { reason: result.reason } : {} };
+  }
+  return { status: "success" };
+};
+
+// src/helpers/runner/isTimedOut.ts
+var isTimedOut = (startedAt, timeout) => timeout !== void 0 && timeout > 0 && Date.now() - startedAt > timeout;
+
+// src/helpers/runner/raceTimeout.ts
+var raceTimeout = (promise, timeout, startedAt, onTimeout) => new Promise((resolve, reject) => {
+  const remaining = Math.max(timeout - (Date.now() - startedAt), 0);
+  const timer = setTimeout(() => resolve(onTimeout()), remaining);
+  void promise.then((result) => {
+    clearTimeout(timer);
+    resolve(result);
+  }).catch((cause) => {
+    clearTimeout(timer);
+    reject(cause);
+  });
+});
+
+// src/helpers/runner/timeoutResult.ts
+var timeoutResult = (timeout, strategy) => failLimit("TIMEOUT", `Slapflow run timed out after ${timeout}ms`, strategy);
+
+// src/helpers/runner/executeStrategy.ts
+var executeStrategy = (id, extraProps, depth, state, environment) => {
+  const config = environment.configRef.current;
+  if (!config) {
+    return {
+      status: "failed",
+      error: slapError("CONFIG_INVALID", "No config loaded", { stage: { phase: "entrypoint" } }),
+      patches: [],
+      events: []
+    };
+  }
+  const maxDepth = environment.options.maxDepth ?? defaultMaxDepth;
+  if (maxDepth !== -1 && depth > maxDepth) {
+    return failLimit("MAX_DEPTH", `Max depth exceeded at strategy "${id}"`, id);
+  }
+  const maxStepCount = environment.options.maxStepCount ?? environment.options.maxSteps ?? defaultMaxStepCount;
+  if (maxStepCount !== -1 && state.stepCounter.current >= maxStepCount) {
+    return failLimit("MAX_STEPS", `Max steps exceeded at strategy "${id}"`, id);
+  }
+  if (isTimedOut(state.startedAt, environment.options.timeout)) {
+    return timeoutResult(environment.options.timeout, id);
+  }
+  const strategy = config.strategies[id];
+  if (!strategy) {
+    return {
+      status: "failed",
+      error: slapError("STRATEGY_NOT_FOUND", `Strategy "${id}" is not defined`, {
+        strategy: id,
+        stage: { phase: "entrypoint", strategy: id, depth }
+      }),
+      patches: [],
+      events: []
+    };
+  }
+  const action = environment.actionsRegistry.get(strategy.fn);
+  if (!action) {
+    return {
+      status: "failed",
+      error: slapError("ACTION_NOT_FOUND", `Action "${strategy.fn}" is not registered`, {
+        strategy: id,
+        fn: strategy.fn,
+        stage: {
+          phase: "action",
+          strategy: id,
+          fn: strategy.fn,
+          mode: strategy.mode,
+          depth,
+          step: state.stepCounter.current + 1
+        }
+      }),
+      patches: [],
+      events: []
+    };
+  }
+  const rawProps = { ...strategy.props ?? {}, ...extraProps };
+  let props;
+  try {
+    props = resolveValue(rawProps, {
+      ...state,
+      strategy: id,
+      configPath: `strategies.${id}.props`
+    });
+  } catch (cause) {
+    if (!(cause instanceof ResolutionError)) {
+      throw cause;
+    }
+    return handleFailure(
+      withErrorStage(cause.slapError, {
+        phase: "action",
+        strategy: id,
+        fn: strategy.fn,
+        mode: strategy.mode,
+        depth,
+        step: state.stepCounter.current + 1
+      }),
+      strategy,
+      depth,
+      state,
+      environment
+    );
+  }
+  const traceProps = redactVariableProps(rawProps, props);
+  const runtime = createRuntime(state, {
+    executeThen: async () => toRuntimeResult(await executeThen(strategy, depth, state, environment)),
+    executeCatch: strategy.catch?.length ? async () => toRuntimeResult(await executeSequence(strategy.catch, depth, state, environment)) : async () => void 0
+  });
+  const dataBefore = cloneData(state.data);
+  const traceStep = state.stepCounter.current + 1;
+  const startedAt = Date.now();
+  const condition = evaluateCondition(strategy.when, environment.conditionsRegistry, {
+    ...state,
+    runtime,
+    strategy: id
+  });
+  if (!condition.ok) {
+    return handleFailure(
+      withErrorStage(condition.error, {
+        phase: "condition",
+        strategy: id,
+        fn: strategy.fn,
+        mode: strategy.mode,
+        depth,
+        step: traceStep
+      }),
+      strategy,
+      depth,
+      state,
+      environment
+    );
+  }
+  if (!condition.matched) {
+    pushTrace(state, traceStep, depth, id, strategy, "skipped", traceProps, dataBefore, startedAt);
+    return { status: "skipped", reason: "when condition did not match", patches: [], events: [] };
+  }
+  state.stepCounter.current += 1;
+  const invoke = () => action({ context: state.context, props, input: state.input, signal: state.signal, runtime });
+  const actionThrown = (cause) => {
+    if (isTimedOut(state.startedAt, environment.options.timeout)) {
+      return timeoutResult(environment.options.timeout, id);
+    }
+    return handleFailure(
+      cause instanceof ResolutionError ? withErrorStage(cause.slapError, {
+        phase: "action",
+        strategy: id,
+        fn: strategy.fn,
+        mode: strategy.mode,
+        depth,
+        step: traceStep
+      }) : slapError("ACTION_THROWN", `Action "${strategy.fn}" threw`, {
+        strategy: id,
+        fn: strategy.fn,
+        cause,
+        stage: { phase: "action", strategy: id, fn: strategy.fn, mode: strategy.mode, depth, step: traceStep }
+      }),
+      strategy,
+      depth,
+      state,
+      environment
+    );
+  };
+  try {
+    const raw = invoke();
+    if (isPromiseLike(raw)) {
+      if (state.sync) {
+        throw new SyncAsyncError(
+          slapError("ASYNC_IN_SYNC_RUN", `Strategy "${id}" returned a Promise`, {
+            strategy: id,
+            fn: strategy.fn,
+            stage: { phase: "action", strategy: id, fn: strategy.fn, mode: strategy.mode, depth, step: traceStep }
+          })
+        );
+      }
+      let timedOut = false;
+      const complete = raw.then((value) => {
+        if (timedOut || isTimedOut(state.startedAt, environment.options.timeout)) {
+          return timeoutResult(environment.options.timeout, id);
+        }
+        return afterAction(
+          value,
+          id,
+          strategy,
+          depth,
+          state,
+          traceProps,
+          dataBefore,
+          traceStep,
+          startedAt,
+          environment
+        );
+      }).catch((cause) => {
+        if (timedOut || isTimedOut(state.startedAt, environment.options.timeout)) {
+          return timeoutResult(environment.options.timeout, id);
+        }
+        return actionThrown(cause);
+      });
+      const timeout = environment.options.timeout;
+      if (timeout !== void 0 && timeout > 0) {
+        return raceTimeout(complete, timeout, state.startedAt, () => {
+          timedOut = true;
+          state.closed = true;
+          state.abort();
+          return timeoutResult(timeout, id);
+        });
+      }
+      return complete;
+    }
+    if (isTimedOut(state.startedAt, environment.options.timeout)) {
+      return timeoutResult(environment.options.timeout, id);
+    }
+    return afterAction(raw, id, strategy, depth, state, traceProps, dataBefore, traceStep, startedAt, environment);
+  } catch (cause) {
+    if (cause instanceof SyncAsyncError) {
+      throw cause;
+    }
+    return actionThrown(cause);
+  }
+};
+
+// src/helpers/runner/finishRunResult.ts
+var finishRunResult = (result, state, traceSink) => {
+  const runResult = {
+    status: result.status,
+    context: state.context,
+    data: state.data,
+    patches: state.patches,
+    events: state.events,
+    steps: state.stepCounter.current
+  };
+  if (result.status === "failed") {
+    runResult.error = result.error;
+  }
+  const entries = traceSink?.entries?.();
+  if (entries) {
+    runResult.trace = entries;
+  }
+  return runResult;
+};
+
+// src/helpers/runner/resolveEntrypoint.ts
+var resolveEntrypoint = (entrypoint, environment) => {
+  const config = environment.configRef.current;
+  if (!config) {
+    return { error: slapError("CONFIG_INVALID", "No config loaded", { stage: { phase: "entrypoint" } }) };
+  }
+  const id = config.entrypoints?.[entrypoint] ?? entrypoint;
+  if (!config.strategies[id]) {
+    return {
+      error: slapError("STRATEGY_NOT_FOUND", `Strategy "${id}" is not defined`, {
+        strategy: id,
+        stage: { phase: "entrypoint", entrypoint, strategy: id }
+      })
+    };
+  }
+  return { id };
+};
+
+// src/helpers/validation/runnerLimitWarnings.ts
+var runnerLimitWarnings = (options) => {
+  const warnings = [];
+  const maxStepCount = options.maxStepCount ?? options.maxSteps;
+  if (maxStepCount === -1) {
+    warnings.push({
+      code: "LIMIT_DISABLED",
+      message: "maxStepCount is disabled; cycles or unexpectedly long runs may execute indefinitely",
+      path: "options.maxStepCount"
+    });
+  }
+  if (options.maxDepth === -1) {
+    warnings.push({
+      code: "LIMIT_DISABLED",
+      message: "maxDepth is disabled; deeply nested strategies may exhaust the call stack",
+      path: "options.maxDepth"
+    });
+  }
+  return warnings;
+};
+
+// src/helpers/validation/getNextTarget.ts
+var getNextTarget = (next) => {
+  if (typeof next === "string") {
+    return next;
+  }
+  if (next && typeof next === "object" && "strategy" in next && typeof next.strategy === "string") {
+    return next.strategy;
+  }
+  return void 0;
+};
+
+// src/helpers/validation/detectCycles.ts
+var detectCycles = (config, errors, warnings) => {
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id, path) => {
+    if (visiting.has(id)) {
+      const cycle = [...path, id];
+      const hasTerminal = cycle.some((item) => config.strategies[item]?.terminal);
+      const issue = {
+        code: "CYCLE_DETECTED",
+        message: `Cycle detected: ${cycle.join(" -> ")}`,
+        strategy: id
+      };
+      (hasTerminal ? warnings : errors).push(issue);
+      return true;
+    }
+    if (visited.has(id)) {
+      return false;
+    }
+    visiting.add(id);
+    for (const branch of ["then", "catch"]) {
+      const nextItems = config.strategies[id]?.[branch];
+      for (const next of Array.isArray(nextItems) ? nextItems : []) {
+        const target = getNextTarget(next);
+        if (target && config.strategies[target]) {
+          visit(target, [...path, id]);
+        }
+      }
+    }
+    visiting.delete(id);
+    visited.add(id);
+    return false;
+  };
+  Object.keys(config.strategies ?? {}).forEach((id) => visit(id, []));
+};
+
+// src/helpers/validation/getNextItems.ts
+var getNextItems = (value) => Array.isArray(value) ? value : [];
+
+// src/helpers/validation/detectNestedLoops.ts
+var detectNestedLoops = (config, errors) => {
+  for (const [outerId, outer] of Object.entries(config.strategies)) {
+    if (outer.fn !== "core.loop") {
+      continue;
+    }
+    const visited = /* @__PURE__ */ new Set([outerId]);
+    const visit = (id, path) => {
+      const strategy = config.strategies[id];
+      if (!strategy) {
+        return;
+      }
+      if (strategy.fn === "core.loop") {
+        errors.push({
+          code: "NESTED_LOOP",
+          message: `Strategy "${id}" cannot run inside loop "${outerId}". Nested core.loop strategies are not supported.`,
+          strategy: id,
+          path: [...path, id].join(" -> ")
+        });
+        return;
+      }
+      if (visited.has(id)) {
+        return;
+      }
+      visited.add(id);
+      for (const branch of ["then", "catch"]) {
+        for (const next of getNextItems(strategy[branch])) {
+          const target = getNextTarget(next);
+          if (target) {
+            visit(target, [...path, `${id}.${branch}`]);
+          }
+        }
+      }
+    };
+    for (const branch of ["then", "catch"]) {
+      for (const next of getNextItems(outer[branch])) {
+        const target = getNextTarget(next);
+        if (target) {
+          visit(target, [`${outerId}.${branch}`]);
+        }
+      }
+    }
+  }
+};
+
+// src/helpers/validation/validationConstants.ts
+var validModes = /* @__PURE__ */ new Set(["sequence", "selector", "parallel"]);
+var controlConditions = /* @__PURE__ */ new Set(["and", "or", "not"]);
+
+// src/helpers/path/isPathReference.ts
+var isPathReference = (value) => typeof value === "string" && value.startsWith("$");
+
+// src/helpers/path/isValidPathReference.ts
+var isValidPathReference = (value) => pathReferenceRegex.test(value);
+
+// src/helpers/validation/validateRefs.ts
+var validateRefs = (value, strategy, path, errors) => {
+  if (typeof value === "string") {
+    if (isPathReference(value) && !isValidPathReference(value)) {
+      errors.push({ code: "PATH_INVALID", message: `Invalid path reference "${value}"`, strategy, path });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => validateRefs(item, strategy, `${path}.${index}`, errors));
+  }
+  if (value && typeof value === "object") {
+    Object.entries(value).forEach(([key, item]) => {
+      if (key === "$template" && typeof item === "string") {
+        if (!parseTemplate(item).ok) {
+          errors.push({
+            code: "TEMPLATE_INVALID",
+            message: "Template syntax is invalid",
+            strategy,
+            path: `${path}.${key}`
+          });
+        }
+      } else {
+        validateRefs(item, strategy, `${path}.${key}`, errors);
+      }
+    });
+  }
+};
+
+// src/helpers/validation/validateCondition.ts
+var validateCondition = (expression, strategy, path, conditionsRegistry, errors) => {
+  if (expression === void 0 || typeof expression === "boolean") {
+    return;
+  }
+  if (!Array.isArray(expression) || typeof expression[0] !== "string") {
+    errors.push({ code: "CONDITION_INVALID", message: "Condition expression is invalid", strategy, path });
+    return;
+  }
+  const [operator, ...args] = expression;
+  if (operator === "and" || operator === "or") {
+    args.forEach((arg, index) => validateCondition(arg, strategy, `${path}.${index + 1}`, conditionsRegistry, errors));
+    return;
+  }
+  if (operator === "not") {
+    validateCondition(args[0], strategy, `${path}.1`, conditionsRegistry, errors);
+    return;
+  }
+  if (!conditionsRegistry.has(operator) && !controlConditions.has(operator)) {
+    errors.push({
+      code: "CONDITION_NOT_FOUND",
+      message: `Condition "${operator}" is not registered`,
+      strategy,
+      path
+    });
+  }
+  args.forEach((arg, index) => validateRefs(arg, strategy, `${path}.${index + 1}`, errors));
+};
+
+// src/helpers/validation/validateNextList.ts
+var validateNextList = (config, list, path, strategy, conditionsRegistry, errors) => {
+  if (list === void 0) {
+    return;
+  }
+  if (!Array.isArray(list)) {
+    errors.push({ code: "NEXT_INVALID", message: "then/catch must be arrays", strategy, path });
+    return;
+  }
+  list.forEach((item, index) => {
+    const target = typeof item === "string" ? item : item && typeof item === "object" ? item.strategy : void 0;
+    if (typeof target !== "string" || !config.strategies[target]) {
+      errors.push({
+        code: "STRATEGY_NOT_FOUND",
+        message: `Next strategy "${String(target)}" is not defined`,
+        strategy,
+        path: `${path}.${index}`
+      });
+    } else if (item && typeof item === "object") {
+      const { props, when } = item;
+      validateCondition(when, strategy, `${path}.${index}.when`, conditionsRegistry, errors);
+      validateRefs(props, strategy, `${path}.${index}.props`, errors);
+    }
+  });
+};
+
+// src/helpers/validation/validateConfig.ts
+var validateConfig = (config, actionsRegistry, conditionsRegistry) => {
+  const errors = [];
+  const warnings = [];
+  if (!config || typeof config !== "object") {
+    return {
+      ok: false,
+      errors: [{ code: "CONFIG_INVALID", message: "Config must be an object" }],
+      warnings
+    };
+  }
+  if (!config.strategies || typeof config.strategies !== "object" || Array.isArray(config.strategies)) {
+    return {
+      ok: false,
+      errors: [{ code: "CONFIG_INVALID", message: "Config must include a strategies object", path: "strategies" }],
+      warnings
+    };
+  }
+  for (const [id, strategy] of Object.entries(config.strategies ?? {})) {
+    if (!strategy || typeof strategy !== "object") {
+      errors.push({ code: "STRATEGY_INVALID", message: "Strategy must be an object", strategy: id });
+      continue;
+    }
+    if (!strategy.fn || typeof strategy.fn !== "string") {
+      errors.push({ code: "FN_MISSING", message: "Strategy fn is required", strategy: id, path: `${id}.fn` });
+    } else if (!actionsRegistry.has(strategy.fn)) {
+      errors.push({
+        code: "ACTION_NOT_FOUND",
+        message: `Action "${strategy.fn}" is not registered`,
+        strategy: id,
+        path: `${id}.fn`
+      });
+    }
+    if (strategy.mode && !validModes.has(strategy.mode)) {
+      errors.push({ code: "MODE_INVALID", message: `Mode "${strategy.mode}" is invalid`, strategy: id });
+    }
+    validateNextList(config, strategy.then, `${id}.then`, id, conditionsRegistry, errors);
+    validateNextList(config, strategy.catch, `${id}.catch`, id, conditionsRegistry, errors);
+    validateCondition(strategy.when, id, `${id}.when`, conditionsRegistry, errors);
+    validateRefs(strategy.props, id, `${id}.props`, errors);
+  }
+  for (const [name, target] of Object.entries(config.entrypoints ?? {})) {
+    if (!config.strategies[target]) {
+      errors.push({
+        code: "STRATEGY_NOT_FOUND",
+        message: `Entrypoint "${name}" references missing strategy "${target}"`,
+        path: `entrypoints.${name}`
+      });
+    }
+  }
+  detectCycles(config, errors, warnings);
+  detectNestedLoops(config, errors);
+  return { ok: errors.length === 0, errors, warnings };
+};
+
+// src/helpers/runner/unsupportedVariablesError.ts
+var unsupportedVariablesError = () => new TypeError("Runtime variables support only primitives, arrays, and plain objects");
+
+// src/helpers/runner/cloneRuntimeVariableValue.ts
+var cloneRuntimeVariableValue = (value, seen) => {
+  if (typeof value === "function" || typeof value === "symbol" || typeof value === "undefined") {
+    throw unsupportedVariablesError();
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const existing = seen.get(value);
+  if (existing) {
+    return existing;
+  }
+  if (Array.isArray(value)) {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw unsupportedVariablesError();
+    }
+    const clone2 = new Array(value.length);
+    seen.set(value, clone2);
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+      if (key === "length") {
+        continue;
+      }
+      const index = Number(key);
+      if (!Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== key) {
+        throw unsupportedVariablesError();
+      }
+      if ("get" in descriptor || "set" in descriptor) {
+        throw unsupportedVariablesError();
+      }
+      Object.defineProperty(clone2, key, {
+        value: cloneRuntimeVariableValue(descriptor.value, seen),
+        enumerable: descriptor.enumerable ?? false,
+        configurable: false,
+        writable: false
+      });
+    }
+    return Object.freeze(clone2);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw unsupportedVariablesError();
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw unsupportedVariablesError();
+  }
+  const clone = Object.create(prototype);
+  seen.set(value, clone);
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if ("get" in descriptor || "set" in descriptor) {
+      throw unsupportedVariablesError();
+    }
+    Object.defineProperty(clone, key, {
+      value: cloneRuntimeVariableValue(descriptor.value, seen),
+      enumerable: descriptor.enumerable ?? false,
+      configurable: false,
+      writable: false
+    });
+  }
+  return Object.freeze(clone);
+};
+
+// src/helpers/runner/cloneRuntimeVariables.ts
+var cloneRuntimeVariables = (variables, seen = /* @__PURE__ */ new WeakMap()) => cloneRuntimeVariableValue(variables, seen);
+
+// src/helpers/runner/createRunCancellation.ts
+var createRunCancellation = (source) => {
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  if (source?.aborted) {
+    abort();
+  } else {
+    source?.addEventListener("abort", abort, { once: true });
+  }
+  return {
+    controller,
+    dispose: () => source?.removeEventListener("abort", abort)
+  };
+};
+
+// src/helpers/runner/createRunner.ts
+var createRunner = (options = {}) => {
+  const actionsRegistry = createActionsRegistry();
+  const conditionsRegistry = createConditionsRegistry();
+  const configRef = {};
+  const timeout = options.timeout ?? options.timeoutMs;
+  const runnerOptions = timeout === void 0 ? options : { ...options, timeout };
+  const mergeData = options.mergeData ?? ((current, next) => ({ ...current, ...next }));
+  const variables = cloneRuntimeVariables(options.variables ?? {});
+  if (options.timeoutMs !== void 0) {
+    console.warn("timeoutMs is deprecated; use timeout. It will be removed in a future major release.");
+  }
+  const environment = {
+    actionsRegistry,
+    conditionsRegistry,
+    configRef,
+    options: runnerOptions,
+    mergeData
+  };
+  const registerAction = (name, action) => {
+    actionsRegistry.set(name, action);
+  };
+  const registerActions = (items) => {
+    Object.entries(items).forEach(([name, action]) => registerAction(name, action));
+  };
+  const registerCondition = (name, condition) => {
+    conditionsRegistry.set(name, condition);
+  };
+  const registerConditions = (items) => {
+    Object.entries(items).forEach(([name, condition]) => registerCondition(name, condition));
+  };
+  const validateConfig2 = (target = configRef.current) => {
+    const result = validateConfig(target, actionsRegistry, conditionsRegistry);
+    return { ...result, warnings: [...result.warnings, ...runnerLimitWarnings(runnerOptions)] };
+  };
+  const loadConfig = (nextConfig) => {
+    configRef.current = nextConfig;
+    return validateConfig2(nextConfig);
+  };
+  const runInternal = (entrypoint, context, input, sync, runOptions) => {
+    const traceSink = options.trace === true ? createMemoryTraceSink() : options.trace || void 0;
+    const cancellation = createRunCancellation(runOptions.signal);
+    const state = {
+      context,
+      input,
+      data: {},
+      patches: [],
+      events: [],
+      stepCounter: { current: 0 },
+      startedAt: Date.now(),
+      sync,
+      signal: cancellation.controller.signal,
+      abort: () => cancellation.controller.abort(),
+      closed: false,
+      reportedErrors: [],
+      variables,
+      expressions: options.expressions ?? {},
+      ...traceSink ? { traceSink } : {}
+    };
+    const reportError = (result) => {
+      if (result.status !== "failed" || state.reportedErrors.includes(result.error)) {
+        return;
+      }
+      state.reportedErrors.push(result.error);
+      options.onError?.({
+        error: result.error,
+        context: state.context,
+        input: state.input,
+        data: state.data,
+        patches: state.patches,
+        events: state.events,
+        ...traceSink?.entries ? { trace: traceSink.entries() } : {}
+      });
+    };
+    const finish = (result) => {
+      state.closed = true;
+      cancellation.dispose();
+      return finishRunResult(result, state, traceSink || void 0);
+    };
+    const start = resolveEntrypoint(entrypoint, environment);
+    if ("error" in start) {
+      const result = { status: "failed", error: start.error, patches: [], events: [] };
+      reportError(result);
+      return finish(result);
+    }
+    const executed = executeStrategy(start.id, {}, 0, state, environment);
+    const done = (result) => {
+      reportError(result);
+      return finish(result);
+    };
+    return isPromiseLike(executed) ? executed.then(done) : done(executed);
+  };
+  const run = async (entrypoint, context, input = {}, runOptions = {}) => runInternal(entrypoint, context, input, false, runOptions);
+  const runSync = (entrypoint, context, input = {}, runOptions = {}) => {
+    const result = runInternal(entrypoint, context, input, true, runOptions);
+    if (isPromiseLike(result)) {
+      throw new SyncAsyncError(slapError("ASYNC_IN_SYNC_RUN", "runSync encountered an async action"));
+    }
+    return result;
+  };
+  return {
+    registerAction,
+    registerActions,
+    registerCondition,
+    registerConditions,
+    loadConfig,
+    validateConfig: validateConfig2,
+    run,
+    runSync
+  };
+};
+
+// src/helpers/chain/isInput.ts
+var isInput = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// src/helpers/chain/parseDomBinding.ts
+var parseDomBinding = (binding, prefix) => {
+  const source = binding.slice(prefix.length);
+  const separator = source.lastIndexOf(":");
+  return separator <= 0 || separator === source.length - 1 ? void 0 : { selector: source.slice(0, separator), eventType: source.slice(separator + 1) };
+};
+
+// src/flow.ts
+var busBindingPrefix = "[bus] ";
+var domBindingPrefix = "[dom] ";
+var defaultMaxQueueSize = 50;
+var createFlow = (definition, options) => {
+  const runner = createRunner(options);
+  const bus = options.bus ?? PubSub;
+  const unsubscribers = /* @__PURE__ */ new Set();
+  const lanes = /* @__PURE__ */ new Map();
+  const activeRuns = /* @__PURE__ */ new Set();
+  let runCount = 0;
+  runner.registerActions(definition.actions ?? {});
+  runner.registerConditions(definition.conditions ?? {});
+  const emitDiagnostic = (event, payload) => {
+    ;
+    bus.emit(event, payload);
+  };
+  const clearQueuedRuns = () => {
+    for (const [binding, lane] of lanes) {
+      for (const input of lane.queue) {
+        emitDiagnostic("slapflow.run.dropped", { binding, input, reason: "chain-stopped" });
+      }
+      lane.queue = [];
+      if (!lane.active) {
+        lanes.delete(binding);
+      }
+    }
+  };
+  const stop = (stopOptions = {}) => {
+    for (const unsubscribe of unsubscribers) {
+      unsubscribe();
+    }
+    unsubscribers.clear();
+    clearQueuedRuns();
+    if (stopOptions.force) {
+      for (const run of activeRuns) {
+        run.controller.abort();
+      }
+    }
+  };
+  const getContext = () => typeof options.context === "function" ? options.context() : options.context;
+  const getConcurrency = (target) => target.options?.concurrency ?? options.concurrency ?? {};
+  const startRun = (binding, target, input, key, lane, laneKey) => {
+    const controller = new AbortController();
+    const run = { controller, id: `run-${++runCount}` };
+    activeRuns.add(run);
+    if (lane) {
+      lane.active = run;
+    }
+    emitDiagnostic("slapflow.run.started", { binding, entrypoint: target.entrypoint, key, runId: run.id });
+    void runner.run(target.entrypoint, getContext(), input, { signal: controller.signal }).then((result) => {
+      const payload = { binding, entrypoint: target.entrypoint, key, runId: run.id };
+      if (controller.signal.aborted) {
+        emitDiagnostic("slapflow.run.cancelled", payload);
+      } else if (result.status === "failed") {
+        emitDiagnostic("slapflow.run.failed", { ...payload, error: result.error });
+        options.onRunnerError?.({
+          error: result.error,
+          result,
+          binding,
+          entrypoint: target.entrypoint,
+          runId: run.id,
+          ...key === void 0 ? {} : { key }
+        });
+      } else {
+        emitDiagnostic("slapflow.run.finished", { ...payload, status: result.status });
+      }
+    }).catch((error) => {
+      const payload = { binding, entrypoint: target.entrypoint, key, runId: run.id };
+      emitDiagnostic(controller.signal.aborted ? "slapflow.run.cancelled" : "slapflow.run.failed", {
+        ...payload,
+        ...controller.signal.aborted ? {} : { error }
+      });
+    }).finally(() => {
+      activeRuns.delete(run);
+      if (lane && lane.active === run) {
+        const nextInput = lane.queue.shift();
+        lane.active = void 0;
+        if (nextInput) {
+          startRun(binding, target, nextInput, key, lane, laneKey);
+        } else {
+          lanes.delete(laneKey);
+        }
+      }
+    });
+  };
+  const scheduleRun = (binding, target, input) => {
+    const concurrency = getConcurrency(target);
+    const mode = concurrency.mode ?? "parallel";
+    if (mode === "parallel") {
+      startRun(binding, target, input);
+    } else {
+      const key = concurrency.key?.(input) ?? "";
+      const laneKey = `${binding}:${key}`;
+      const lane = lanes.get(laneKey) ?? { queue: [] };
+      lanes.set(laneKey, lane);
+      if (!lane.active) {
+        startRun(binding, target, input, key, lane, laneKey);
+      } else if (mode === "latest") {
+        lane.active.controller.abort();
+        startRun(binding, target, input, key, lane, laneKey);
+      } else if (mode === "drop") {
+        emitDiagnostic("slapflow.run.dropped", { binding, entrypoint: target.entrypoint, key, reason: "run-active" });
+      } else {
+        const maxQueueSize = concurrency.maxQueueSize ?? defaultMaxQueueSize;
+        const queueIsFull = lane.queue.length >= maxQueueSize;
+        const dropsOldest = concurrency.overflow === "drop-oldest";
+        if (queueIsFull) {
+          emitDiagnostic("slapflow.queue.overflow", { binding, entrypoint: target.entrypoint, key, maxQueueSize });
+          if (dropsOldest) {
+            const dropped = lane.queue.shift();
+            emitDiagnostic("slapflow.run.dropped", {
+              binding,
+              entrypoint: target.entrypoint,
+              key,
+              reason: "queue-overflow",
+              ...dropped ? { input: dropped } : {}
+            });
+          } else {
+            emitDiagnostic("slapflow.run.dropped", {
+              binding,
+              entrypoint: target.entrypoint,
+              key,
+              reason: "queue-overflow"
+            });
+          }
+        }
+        if (!queueIsFull || dropsOldest) {
+          lane.queue.push(input);
+        }
+      }
+    }
+  };
+  const subscribeBusBinding = (binding, target) => {
+    const event = binding.slice(busBindingPrefix.length);
+    const unsubscribe = bus.on(event, (busEvent) => {
+      if (isInput(busEvent.parsed)) {
+        scheduleRun(binding, target, busEvent.parsed);
+      } else {
+        emitDiagnostic("slapflow.run.dropped", {
+          binding,
+          entrypoint: target.entrypoint,
+          reason: "input-not-object"
+        });
+      }
+    });
+    unsubscribers.add(unsubscribe);
+  };
+  const collectForm = (element) => {
+    const form = typeof HTMLFormElement !== "undefined" && element instanceof HTMLFormElement ? element : element.closest("form");
+    if (!form) {
+      return void 0;
+    }
+    const values = {};
+    for (const [name, value] of new FormData(form)) {
+      const current = values[name];
+      values[name] = current === void 0 ? value : Array.isArray(current) ? [...current, value] : [current, value];
+    }
+    return values;
+  };
+  const createDomInput = (event, element) => {
+    const value = "value" in element && typeof element.value === "string" ? element.value : void 0;
+    const form = collectForm(element);
+    const dataset = {};
+    if (element instanceof HTMLElement) {
+      for (const [key, item] of Object.entries(element.dataset)) {
+        if (item !== void 0) {
+          dataset[key] = item;
+        }
+      }
+    }
+    return {
+      type: event.type,
+      ...value === void 0 ? {} : { value },
+      dataset,
+      ...form ? { form } : {}
+    };
+  };
+  const subscribeDomBinding = (binding, target) => {
+    const parsed = parseDomBinding(binding, domBindingPrefix);
+    const root = options.root ?? (typeof document === "undefined" ? void 0 : document);
+    let active = false;
+    if (parsed && root) {
+      let unsubscribe = () => void 0;
+      const listener = (event) => {
+        const eventTarget = event.target;
+        if (typeof Element !== "undefined" && eventTarget instanceof Element) {
+          const element = eventTarget.closest(parsed.selector);
+          const belongsToRoot = !element || typeof Element === "undefined" || !(root instanceof Element) || root.contains(element);
+          if (element && belongsToRoot) {
+            const preventDefault = target.options?.preventDefault ?? event.type === "submit";
+            if (preventDefault) {
+              event.preventDefault();
+            }
+            if (target.options?.stopPropagation) {
+              event.stopPropagation();
+            }
+            const defaultInput = createDomInput(event, element);
+            const input = target.options?.input?.({ event, element, defaultInput }) ?? defaultInput;
+            scheduleRun(binding, target, input);
+            if (target.options?.once) {
+              unsubscribe();
+            }
+          }
+        }
+      };
+      const listenerOptions = target.options?.capture === void 0 ? void 0 : { capture: target.options.capture };
+      root.addEventListener(parsed.eventType, listener, listenerOptions);
+      unsubscribe = () => root.removeEventListener(parsed.eventType, listener, listenerOptions);
+      unsubscribers.add(unsubscribe);
+      active = true;
+    }
+    return active;
+  };
+  const start = () => {
+    stop();
+    const validation = runner.loadConfig(definition.config);
+    const active = [];
+    const inactive = [];
+    if (validation.ok) {
+      const bindings = Object.entries(definition.events ?? {});
+      for (const [binding, target] of bindings) {
+        if (binding.startsWith(busBindingPrefix)) {
+          subscribeBusBinding(binding, target);
+          active.push(binding);
+        } else if (binding.startsWith(domBindingPrefix)) {
+          if (subscribeDomBinding(binding, target)) {
+            active.push(binding);
+          } else {
+            inactive.push({ binding, reason: "dom-unavailable" });
+          }
+        } else {
+          inactive.push({ binding, reason: "unsupported-source" });
+        }
+      }
+    }
+    return { active, inactive, validation };
+  };
+  return { runner, start, stop };
+};
+
+// src/ws.ts
+var openState = 1;
+var maxSeenEvents = 1e3;
+var createWS = (options) => {
+  const inboundTopics = new Set(options.inboundTopics ?? []);
+  const outboundTopics = new Set(options.outboundTopics ?? []);
+  const seenEventIds = /* @__PURE__ */ new Set();
+  const outboundUnsubscribers = /* @__PURE__ */ new Set();
+  const socketUnsubscribers = /* @__PURE__ */ new Set();
+  let socket;
+  let retryTimer;
+  let retryAttempt = 0;
+  let started = false;
+  let currentStatus = "idle";
+  const diagnosticsBus = options.bus;
+  const emitDiagnostic = (topic, payload) => {
+    diagnosticsBus.emit(topic, payload, {
+      ...options.origin ? { origin: options.origin } : {}
+    });
+  };
+  const rememberEvent = (id) => {
+    seenEventIds.add(id);
+    if (seenEventIds.size > maxSeenEvents) {
+      const oldest = seenEventIds.values().next();
+      if (!oldest.done) {
+        seenEventIds.delete(oldest.value);
+      }
+    }
+  };
+  const clearSocket = () => {
+    for (const unsubscribe of socketUnsubscribers) {
+      unsubscribe();
+    }
+    socketUnsubscribers.clear();
+    socket = void 0;
+  };
+  const scheduleRetry = (reason, error) => {
+    const maxAttempts = options.retry?.maxAttempts;
+    if (maxAttempts !== void 0 && retryAttempt >= maxAttempts) {
+      currentStatus = "stopped";
+      emitDiagnostic("slapflow.ws.disconnected", { reason: "retry-limit-reached", attempt: retryAttempt });
+    } else {
+      const delay = getRetryDelay(retryAttempt, options.retry ?? {});
+      const attempt = retryAttempt + 1;
+      const retry = () => {
+        retryTimer = void 0;
+        connect();
+      };
+      currentStatus = "retrying";
+      retryAttempt = attempt;
+      retryTimer = setTimeout(retry, delay);
+      emitDiagnostic("slapflow.ws.retrying", {
+        reason,
+        delay,
+        attempt,
+        ...error === void 0 ? {} : { error: String(error) }
+      });
+    }
+  };
+  const connect = () => {
+    if (started && !socket) {
+      currentStatus = "connecting";
+      emitDiagnostic("slapflow.ws.connecting", { attempt: retryAttempt });
+      try {
+        const current = options.createSocket();
+        socket = current;
+        const listen = (type, listener) => {
+          current.addEventListener(type, listener);
+          socketUnsubscribers.add(() => current.removeEventListener(type, listener));
+        };
+        const disconnect = (reason) => {
+          if (socket === current) {
+            clearSocket();
+            if (started) {
+              scheduleRetry(reason);
+            }
+          }
+        };
+        listen("open", () => {
+          if (socket === current) {
+            retryAttempt = 0;
+            currentStatus = "connected";
+            emitDiagnostic("slapflow.ws.connected", {});
+          }
+        });
+        listen("close", () => disconnect("close"));
+        listen("error", () => disconnect("error"));
+        listen("message", (event) => {
+          const data = event.data;
+          if (typeof data === "string") {
+            try {
+              const busEvent = JSON.parse(data);
+              if (busEvent.topic && inboundTopics.has(busEvent.topic)) {
+                if (busEvent.id) {
+                  rememberEvent(busEvent.id);
+                }
+                if (!options.bus.dispatch(busEvent)) {
+                  emitDiagnostic("slapflow.ws.message.rejected", { reason: "invalid-envelope", topic: busEvent.topic });
+                }
+              } else {
+                emitDiagnostic("slapflow.ws.message.rejected", { reason: "topic-not-allowed", topic: busEvent.topic });
+              }
+            } catch (error) {
+              emitDiagnostic("slapflow.ws.message.rejected", { reason: "message-parse-failed", error: String(error) });
+            }
+          } else {
+            emitDiagnostic("slapflow.ws.message.rejected", { reason: "message-not-string" });
+          }
+        });
+      } catch (error) {
+        scheduleRetry("socket-create-failed", error);
+      }
+    }
+  };
+  const start = () => {
+    if (!started) {
+      started = true;
+      for (const topic of outboundTopics) {
+        const unsubscribe = options.bus.on(topic, (event) => {
+          if (!seenEventIds.delete(event.id) && event.origin !== options.origin && socket?.readyState === openState) {
+            socket.send(JSON.stringify(event));
+          }
+        });
+        outboundUnsubscribers.add(unsubscribe);
+      }
+      connect();
+    }
+  };
+  const stop = () => {
+    started = false;
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+    }
+    retryTimer = void 0;
+    for (const unsubscribe of outboundUnsubscribers) {
+      unsubscribe();
+    }
+    outboundUnsubscribers.clear();
+    const current = socket;
+    clearSocket();
+    current?.close();
+    currentStatus = "stopped";
+    emitDiagnostic("slapflow.ws.disconnected", { reason: "stopped" });
+  };
+  const reconnect = () => {
+    if (started) {
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+      }
+      const current = socket;
+      retryTimer = void 0;
+      clearSocket();
+      current?.close();
+      connect();
+    }
+  };
+  return { start, stop, reconnect, status: () => currentStatus };
+};
+
+// src/catchError.ts
+var catchError = (callback) => new Promise((resolve, reject) => {
+  try {
+    resolve(callback());
+  } catch (error) {
+    reject(error);
+  }
+});
+export {
+  PubSub,
+  catchError,
+  createActionsRegistry,
+  createConditionsRegistry,
+  createFlow,
+  createMemoryTraceSink,
+  createPubSub,
+  createWS,
+  defineConfig,
+  defineErrorReporter
+};