slapflow 1.0.2 → 1.1.0

package/README.md

@@ -14,6 +14,12 @@ Slapflow takes care of orchestration, concurrency, cancellation, and diagnostics
 - **Make async behavior deliberate.** Choose `parallel`, `latest`, `queue`, or `drop` for each event source. Actions receive an `AbortSignal` when cancellation matters.
 - **Use the same flow in more than one place.** The chain can start from a typed bus, DOM event, API callback, timer, worker, or WebSocket message.
 
+### When to use Slapflow
+
+Slapflow orchestrates a control flow that lives and finishes inside a single process. Reach for it when a scenario spans several steps, branches, and failure paths and you want it in one place rather than spread across handlers and callbacks.
+
+**What it is not:** a web framework (no routing, no middleware stack — pair it with Express, Hono, or Next.js routes) or a job queue (no built-in persistence, no distributed workers). It is also not a durable workflow engine: a chain runs inside a live process and stops with it — a `core.loop` can spin indefinitely while the process runs, but unlike Temporal there is no state that survives a crash or restart unless your application prevails it. It is closest to a lightweight, in-process state machine: decisions, ordering, concurrency, and cancellation live in a chain, while your application keeps the domain state and side effects.
+
 ## Installation
 
 ```bash
@@ -163,6 +169,7 @@ const config = {
 
 ## Where to go next
 
+- See [slapflow-studio](https://github.com/khalilov/slapflow-studio), a working application built entirely on Slapflow.
 - Read the complete [technical specification](SPEC.md) for the runner API, built-in actions and conditions, expressions, validation, safety limits, transport behavior, and lifecycle semantics.
 - Russian documentation: [README-RU.md](README-RU.md) and [SPEC-RU.md](SPEC-RU.md).
 

package/SPEC-RU.md

@@ -45,8 +45,14 @@ type Config = {
   version?: 1
   strategies: Record<string, Strategy>
   entrypoints?: Record<string, string>
+  guards?: Record<string, ConditionExpression>
 }
 
+type ConditionExpression =
+  | boolean
+  | [operator: string, ...args: unknown[]]
+  | ['guard', name: string]
+
 type Strategy = {
   fn: string
   props?: Record<string, unknown>
@@ -113,6 +119,21 @@ type ErrorStage = {
 
 Если ошибка обработана через `catch`, `onError` всё равно вызывается для исходного сбоя, а итоговый `run` может завершиться со статусом `success`.
 
+## Нормализация возврата действия
+
+Возвращаемое значение действия нормализуется в один итог. Соответствие:
+
+| Возврат                                           | Итог                                                         |
+| ------------------------------------------------- | ------------------------------------------------------------ |
+| `undefined` / `null`                              | `success`                                                    |
+| `false`                                           | `skipped`                                                    |
+| `{ type: 'skip', reason?, data? }`                | `skipped` (селектор пробует следующую ветку)                 |
+| `{ type: 'stop', reason?, patch?, events? }`      | `stopped` (цепочка останавливается без ошибки)               |
+| `{ type: 'fail', reason?, data?, error? }`        | `failed` (запускается `catch`, затем `onError`)              |
+| `{ context?, data?, patch?, events?, continue? }` | `success`; `continue: false` прерывает оставшиеся `then`-цели |
+
+Брошенное исключение трактуется как `fail`. Возврат `false` и `{ type: 'skip' }` эквивалентны.
+
 ## Модель реестров
 
 Исполнитель использует собственные реестры:
@@ -225,6 +246,18 @@ export const config = {
 
 `parallel` запускает цели `then` независимо. Простые объекты и массивы контекста и runtime data копируются для каждой ветки; инфраструктурные значения вроде функций, DOM-узлов и экземпляров классов остаются ссылками. Safety limits, включая `maxStepCount`, остаются общими для всего запуска. Полученные патчи и события возвращаются вызывающей стороне; исполнитель их не применяет.
 
+### Прерывание цепочки
+
+Не-`success` итог шага меняет дальнейшее поведение в зависимости от режима:
+
+| Итог     | `sequence`                | `selector`                 |
+| -------- | ------------------------- | -------------------------- |
+| `skipped`| **прерывает остаток**      | пробует следующую ветку    |
+
+`sequence` — режим по умолчанию, и он прерывает оставшиеся `then`-цели на *любом* не-`success` (`skipped`, `stopped`, `failed`) — не только на сбое. Условный шаг внутри последовательности — это, таким образом, скрытый ранний выход для всего остатка. Если пропуск шага не должен рвать цепочку, заверните его в селектор с запасным `core.noop`.
+
+`terminal: true` останавливает `then`-цепочку после этой стратегии даже при `success`; `continue: false` в `ActionSuccess` даёт тот же эффект.
+
 ## Вспомогательные средства среды выполнения
 
 ```ts
@@ -261,6 +294,29 @@ type Runtime = {
 
 Чтение и запись путей во время выполнения реализованы непосредственно через `objwalk`.
 
+## Guards
+
+Переиспользуемые выражения `when` живут в карте `guards` на `Config` и подключаются к `when` стратегии (или шага `then`/`catch`) узлом `['guard', имя]`:
+
+```ts
+const config = {
+  guards: {
+    'has-colony': ['truthy', '$data.colonyId'],
+    'same-colony': ['eq', '$input.colonyId', '$context.colonyId'],
+  },
+  strategies: {
+    'colony.join': {
+      fn: 'colony.join',
+      when: ['and', ['guard', 'has-colony'], ['not', ['guard', 'same-colony']]],
+    },
+  },
+}
+```
+
+Guard — это обычное `ConditionExpression`, и сам может ссылаться на другие guards. Ссылки раскрываются один раз при загрузке конфигурации (`loadConfig`), до того как рантайм что-либо вычисляет, поэтому рантайм никогда не видит узел `['guard', ...]`. Guards раскрываются рекурсивно через `and`/`or`/`not`; ссылка на несуществующий guard даёт ошибку валидации `GUARD_NOT_FOUND`, а взаимные ссылки — `GUARD_CYCLE`. Значение guard должно быть выражением-условием, а не строкой `$path`.
+
+Guards существуют, чтобы критерий истинности жил в одном месте, а не дублировался по стратегиям; это вычисляемые данные, а не зарегистрированный код (в отличие от `registerCondition`, который регистрирует функцию-оператор).
+
 ## Проверка конфигурации
 
 `validateConfig` проверяет:
@@ -270,7 +326,8 @@ type Runtime = {
 - отсутствующие стратегии в `then`, `catch` и `entrypoints`;
 - недопустимые режимы;
 - недопустимые ссылки на пути;
-- циклы без завершающего шага.
+- циклы без завершающего шага;
+- ссылки на guards (`GUARD_NOT_FOUND`, `GUARD_CYCLE`, `GUARD_INVALID`).
 
 ## Трассировка
 
@@ -308,11 +365,14 @@ unsubscribe()
 
 ```ts
 type Bus<TEvents extends object = Record<string, unknown>> = {
-  on<TEvent extends keyof TEvents>(
-    event: TEvent,
-    handler: (event: BusEvent<TEvents[TEvent]>) => void
-  ): () => void
-  off<TEvent extends keyof TEvents>(event: TEvent, handler?: (event: BusEvent<TEvents[TEvent]>) => void): void
+  on: {
+    <TEvent extends keyof TEvents>(event: TEvent, handler: (event: BusEvent<TEvents[TEvent]>) => void): () => void
+    (event: EventPattern, handler: (event: BusEvent<unknown>) => void): () => void
+  }
+  off: {
+    <TEvent extends keyof TEvents>(event: TEvent, handler?: (event: BusEvent<TEvents[TEvent]>) => void): void
+    (event: EventPattern, handler?: (event: BusEvent<unknown>) => void): void
+  }
   emit<TEvent extends keyof TEvents>(
     topic: TEvent,
     payload: TEvents[TEvent],
@@ -320,6 +380,8 @@ type Bus<TEvents extends object = Record<string, unknown>> = {
   ): BusEvent<TEvents[TEvent]>
 }
 
+type EventPattern = `${string}*${string}`
+
 type BusEvent<TPayload> = {
   id: string
   topic: string
@@ -332,6 +394,18 @@ type BusEvent<TPayload> = {
 
 `emit` создаёт конверт и сериализует полезную нагрузку один раз до запуска подписчиков. Идентификаторы событий — непрозрачные 12-символьные буквенно-цифровые runtime-ID для корреляции и подавления эха. Они не криптографически стойкие: не используйте их для access token, подписей, публичных ссылок или иных security-sensitive задач. `on` возвращает функцию отписки. `off(event, handler)` удаляет один обработчик, а `off(event)` очищает канал. Ошибка одного подписчика не блокирует остальных; `createPubSub({ onError })` получает ошибку и исходное событие. При ошибке сериализации шина передаёт `{ error }` в качестве `parsed` и тело ошибки в качестве `serialized`, после чего вызывает `onError` с исходной причиной.
 
+### Подписка по шаблону
+
+На тему можно подписаться по шаблону, где `*` соответствует ровно одному сегменту, разделённому точкой. Шаблонный символ не пересекает границу `.`.
+
+```ts
+bus.on('hub.user.*', ({ parsed }) => {})       // hub.user.created, hub.user.deleted
+bus.on('hub.*.created', ({ parsed }) => {})    // hub.user.created, hub.team.created
+bus.on('hub.*.export', ({ parsed }) => {})     // НЕ hub.user.audit.export (один сегмент)
+```
+
+Подписки с точным именем остаются O(1); шаблоны обрабатываются отдельно, поэтому регистрации без `*` не несут накладных затрат на сравнение. Обработчик шаблона получает `parsed` как `unknown` — сужайте тип перед использованием. Шаблоны работают в `bus.on`/`bus.off`, а также в `inboundTopics`/`outboundTopics` у `createWS`.
+
 ## Поток
 
 `createFlow` объединяет конфигурацию, действия, условия, поставщик контекста и привязки событий. Функция создаёт исполнитель (доступный через `flow.runner`) и поддерживает жизненный цикл `start`/`stop`.
@@ -432,7 +506,7 @@ const ws = createWS({
 ws.start()
 ```
 
-Входящие темы проходят через явный список разрешений. Мост разбирает JSON-конверт и вызывает `bus.dispatch(event)`, сохраняя `id`, `occurredAt`, `origin`, `parsed` и `serialized`; принятые входящие идентификаторы запоминаются и не отправляются обратно наружу. Исходящие темы отправляют полный JSON-конверт события, поэтому удалённый мост может передать его в шину, не создавая новый идентификатор. `maxAttempts` ограничивает reconnect; без него повторы идут бесконечно. `start`, `stop`, `reconnect` и `status` управляют жизненным циклом транспорта. Диагностические события: `slapflow.ws.connecting`, `slapflow.ws.connected`, `slapflow.ws.disconnected`, `slapflow.ws.retrying` и `slapflow.ws.message.rejected`.
+Входящие темы проходят через явный список разрешений. Каждая запись может быть точной темой или шаблоном, где `*` соответствует одному сегменту, разделённому точкой. Мост разбирает JSON-конверт и вызывает `bus.dispatch(event)`, сохраняя `id`, `occurredAt`, `origin`, `parsed` и `serialized`; принятые входящие идентификаторы запоминаются и не отправляются обратно наружу. Исходящие темы отправляют полный JSON-конверт события, поэтому удалённый мост может передать его в шину, не создавая новый идентификатор. `maxAttempts` ограничивает reconnect; без него повторы идут бесконечно. `start`, `stop`, `reconnect` и `status` управляют жизненным циклом транспорта. Диагностические события: `slapflow.ws.connecting`, `slapflow.ws.connected`, `slapflow.ws.disconnected`, `slapflow.ws.retrying` и `slapflow.ws.message.rejected`.
 
 ## Ограничения безопасности
 

package/SPEC.md

@@ -45,8 +45,14 @@ type Config = {
   version?: 1
   strategies: Record<string, Strategy>
   entrypoints?: Record<string, string>
+  guards?: Record<string, ConditionExpression>
 }
 
+type ConditionExpression =
+  | boolean
+  | [operator: string, ...args: unknown[]]
+  | ['guard', name: string]
+
 type Strategy = {
   fn: string
   props?: Record<string, unknown>
@@ -113,6 +119,21 @@ type ErrorStage = {
 
 If an error is recovered through `catch`, `onError` is still invoked for the original failure and the final `run` may finish with `success`.
 
+## Action Return Normalization
+
+An action's return value is normalized into one outcome. The mapping:
+
+| Return                                            | Outcome                                                        |
+| ------------------------------------------------- | -------------------------------------------------------------- |
+| `undefined` / `null`                              | `success`                                                      |
+| `false`                                           | `skipped`                                                      |
+| `{ type: 'skip', reason?, data? }`                | `skipped` (a selector tries the next branch)                   |
+| `{ type: 'stop', reason?, patch?, events? }`      | `stopped` (the chain halts without error)                      |
+| `{ type: 'fail', reason?, data?, error? }`        | `failed` (`catch` runs, then `onError`)                        |
+| `{ context?, data?, patch?, events?, continue? }` | `success`; `continue: false` halts the remaining `then` targets |
+
+A thrown exception is treated as `fail`. Returning `false` and `{ type: 'skip' }` are equivalent.
+
 ## Registry Model
 
 The runner uses runner-scoped registries:
@@ -225,6 +246,18 @@ export const config = {
 
 `parallel` runs `then` targets independently. Plain objects and arrays in runtime context and data are cloned for each branch; infrastructure values such as functions, DOM nodes, and class instances remain references. Safety limits, including `maxStepCount`, remain shared by the whole run. Resulting patches and events are returned to the caller; the runner does not apply them.
 
+### Chain interruption
+
+A non-`success` outcome at a step changes what happens next, depending on the mode:
+
+| Outcome   | `sequence`             | `selector`               |
+| --------- | ---------------------- | ------------------------ |
+| `skipped` | **interrupts the rest** | tries the next branch    |
+
+`sequence` is the default mode and interrupts the remaining `then` targets on *any* non-`success` (`skipped`, `stopped`, `failed`) — not only on failure. A conditional step inside a sequence is therefore a hidden early exit for the whole remainder. When skipping a step must not break the chain, wrap it in a selector with a `core.noop` fallback.
+
+`terminal: true` stops the `then` chain after that strategy even on `success`; `continue: false` in `ActionSuccess` has the same effect.
+
 ## Runtime Helpers
 
 ```ts
@@ -261,6 +294,29 @@ type Runtime = {
 
 Runtime path get/set is implemented directly through `objwalk`.
 
+## Guards
+
+Reusable `when` expressions live in the `guards` map on `Config` and are referenced from a strategy's `when` (or a `then`/`catch` step's `when`) with the `['guard', name]` node:
+
+```ts
+const config = {
+  guards: {
+    'has-colony': ['truthy', '$data.colonyId'],
+    'same-colony': ['eq', '$input.colonyId', '$context.colonyId'],
+  },
+  strategies: {
+    'colony.join': {
+      fn: 'colony.join',
+      when: ['and', ['guard', 'has-colony'], ['not', ['guard', 'same-colony']]],
+    },
+  },
+}
+```
+
+A guard is a plain `ConditionExpression` and may itself reference other guards. References are expanded once when the config is loaded (`loadConfig`), before the runtime evaluates anything, so the runtime never sees a `['guard', ...]` node. Guards are resolved recursively through `and`/`or`/`not`; a reference to an undefined guard is a `GUARD_NOT_FOUND` validation error, and mutually referencing guards produce `GUARD_CYCLE`. A guard value must be a condition expression, not a `$path` string.
+
+Guards exist so a truth criterion can live in one place instead of being duplicated across strategies; they are evaluated data, not registered code (unlike `registerCondition`, which registers an operator function).
+
 ## Validation
 
 `validateConfig` validates:
@@ -270,7 +326,8 @@ Runtime path get/set is implemented directly through `objwalk`.
 - missing strategies in `then`, `catch`, and `entrypoints`;
 - invalid modes;
 - invalid path references;
-- cycles without a terminal step.
+- cycles without a terminal step;
+- guard references (`GUARD_NOT_FOUND`, `GUARD_CYCLE`, `GUARD_INVALID`).
 
 ## Trace
 
@@ -308,11 +365,14 @@ unsubscribe()
 
 ```ts
 type Bus<TEvents extends object = Record<string, unknown>> = {
-  on<TEvent extends keyof TEvents>(
-    event: TEvent,
-    handler: (event: BusEvent<TEvents[TEvent]>) => void
-  ): () => void
-  off<TEvent extends keyof TEvents>(event: TEvent, handler?: (event: BusEvent<TEvents[TEvent]>) => void): void
+  on: {
+    <TEvent extends keyof TEvents>(event: TEvent, handler: (event: BusEvent<TEvents[TEvent]>) => void): () => void
+    (event: EventPattern, handler: (event: BusEvent<unknown>) => void): () => void
+  }
+  off: {
+    <TEvent extends keyof TEvents>(event: TEvent, handler?: (event: BusEvent<TEvents[TEvent]>) => void): void
+    (event: EventPattern, handler?: (event: BusEvent<unknown>) => void): void
+  }
   emit<TEvent extends keyof TEvents>(
     topic: TEvent,
     payload: TEvents[TEvent],
@@ -320,6 +380,8 @@ type Bus<TEvents extends object = Record<string, unknown>> = {
   ): BusEvent<TEvents[TEvent]>
 }
 
+type EventPattern = `${string}*${string}`
+
 type BusEvent<TPayload> = {
   id: string
   topic: string
@@ -332,6 +394,18 @@ type BusEvent<TPayload> = {
 
 `emit` creates an envelope and serializes the payload once before subscribers run. Event identifiers are opaque 12-character alphanumeric runtime IDs for correlation and echo suppression. They are not cryptographically secure and must not be used for access tokens, signatures, public links, or any security-sensitive purpose. `on` returns an unsubscribe function. `off(event, handler)` removes one handler, while `off(event)` clears the channel. An error in one subscriber does not block the others; `createPubSub({ onError })` receives the error and original event. On serialization failure, the bus delivers `{ error }` as `parsed` and the error body as `serialized`, then calls `onError` with the original cause.
 
+### Wildcard subscriptions
+
+A topic may be subscribed by pattern, using `*` to match exactly one dot-delimited segment. A wildcard does not cross a `.` boundary.
+
+```ts
+bus.on('hub.user.*', ({ parsed }) => {})       // hub.user.created, hub.user.deleted
+bus.on('hub.*.created', ({ parsed }) => {})    // hub.user.created, hub.team.created
+bus.on('hub.*.export', ({ parsed }) => {})     // NOT hub.user.audit.export (wildcard spans one segment)
+```
+
+Exact-name subscriptions stay O(1); wildcard patterns are matched separately, so registrations without `*` pay no matching cost. A wildcard handler receives `parsed` as `unknown` — narrow it before use. Wildcards work in `bus.on`/`bus.off` and in `inboundTopics`/`outboundTopics` of `createWS`.
+
 ## Flow
 
 `createFlow` combines configuration, actions, conditions, a context provider, and event bindings. It creates a runner (accessible via `flow.runner`) and supports the `start`/`stop` lifecycle.
@@ -432,7 +506,7 @@ const ws = createWS({
 ws.start()
 ```
 
-Inbound topics pass an explicit allowlist. The bridge parses a JSON envelope and calls `bus.dispatch(event)`, preserving `id`, `occurredAt`, `origin`, `parsed`, and `serialized`; it remembers accepted inbound IDs and does not send them back outbound. Outbound topics send the complete event envelope as JSON, so the remote bridge can dispatch it without recreating its identity. `maxAttempts` limits reconnects; omitting it retries indefinitely. `start`, `stop`, `reconnect`, and `status` manage the transport lifecycle. Diagnostics: `slapflow.ws.connecting`, `slapflow.ws.connected`, `slapflow.ws.disconnected`, `slapflow.ws.retrying`, and `slapflow.ws.message.rejected`.
+Inbound topics pass an explicit allowlist. Each entry may be an exact topic or a wildcard pattern, where `*` matches one dot-delimited segment. The bridge parses a JSON envelope and calls `bus.dispatch(event)`, preserving `id`, `occurredAt`, `origin`, `parsed`, and `serialized`; it remembers accepted inbound IDs and does not send them back outbound. Outbound topics send the complete event envelope as JSON, so the remote bridge can dispatch it without recreating its identity. `maxAttempts` limits reconnects; omitting it retries indefinitely. `start`, `stop`, `reconnect`, and `status` manage the transport lifecycle. Diagnostics: `slapflow.ws.connecting`, `slapflow.ws.connected`, `slapflow.ws.disconnected`, `slapflow.ws.retrying`, and `slapflow.ws.message.rejected`.
 
 ## Safety Limits
 

package/dist/index.cjs

@@ -87,6 +87,19 @@ var isBusEvent = (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/matchesTopic.ts
+var matchesTopic = (topic, pattern) => {
+  if (!pattern.includes("*")) {
+    return topic === pattern;
+  }
+  const topicParts = topic.split(".");
+  const patternParts = pattern.split(".");
+  if (topicParts.length !== patternParts.length) {
+    return false;
+  }
+  return patternParts.every((part, index) => part === "*" || part === topicParts[index]);
+};
+
 // src/helpers/pubSub/serializeError.ts
 var serializeError = (error) => ({
   error: error instanceof Error ? error.message : String(error)
@@ -95,6 +108,14 @@ var serializeError = (error) => ({
 // src/pubSub.ts
 var createPubSub = (options = {}) => {
   const subscribers = /* @__PURE__ */ new Map();
+  const wildcardSubscribers = /* @__PURE__ */ new Map();
+  const runHandler = (event, handler) => {
+    try {
+      handler(event);
+    } catch (error) {
+      options.onError?.({ type: "subscriber", event, error });
+    }
+  };
   const dispatch = (event) => {
     let dispatchedEvent;
     if (!isBusEvent(event)) {
@@ -108,10 +129,13 @@ var createPubSub = (options = {}) => {
       const handlers = subscribers.get(event.topic);
       if (handlers) {
         for (const handler of [...handlers]) {
-          try {
-            handler(event);
-          } catch (error) {
-            options.onError?.({ type: "subscriber", event, error });
+          runHandler(event, handler);
+        }
+      }
+      for (const [pattern, wildcardHandlers] of wildcardSubscribers) {
+        if (matchesTopic(event.topic, pattern)) {
+          for (const handler of [...wildcardHandlers]) {
+            runHandler(event, handler);
           }
         }
       }
@@ -120,23 +144,24 @@ var createPubSub = (options = {}) => {
     return dispatchedEvent;
   };
   const on = (event, handler) => {
-    const handlers = subscribers.get(event) ?? /* @__PURE__ */ new Set();
-    const listener = handler;
-    handlers.add(listener);
-    subscribers.set(event, handlers);
+    const registry = event.includes("*") ? wildcardSubscribers : subscribers;
+    const handlers = registry.get(event) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    registry.set(event, handlers);
     return () => off(event, handler);
   };
   const off = (event, handler) => {
+    const registry = event.includes("*") ? wildcardSubscribers : subscribers;
     if (handler) {
-      const handlers = subscribers.get(event);
+      const handlers = registry.get(event);
       if (handlers) {
         handlers.delete(handler);
         if (handlers.size === 0) {
-          subscribers.delete(event);
+          registry.delete(event);
         }
       }
     } else {
-      subscribers.delete(event);
+      registry.delete(event);
     }
   };
   const emit = (topic, payload, emitOptions = {}) => {
@@ -1833,6 +1858,12 @@ var validateCondition = (expression, strategy, path, conditionsRegistry, errors)
     return;
   }
   const [operator, ...args] = expression;
+  if (operator === "guard") {
+    if (args.length !== 1 || typeof args[0] !== "string") {
+      errors.push({ code: "CONDITION_INVALID", message: "Guard reference must be a single string name", strategy, path });
+    }
+    return;
+  }
   if (operator === "and" || operator === "or") {
     args.forEach((arg, index) => validateCondition(arg, strategy, `${path}.${index + 1}`, conditionsRegistry, errors));
     return;
@@ -1878,6 +1909,80 @@ var validateNextList = (config, list, path, strategy, conditionsRegistry, errors
   });
 };
 
+// src/helpers/validation/resolveGuards.ts
+var isGuardRef = (expression) => Array.isArray(expression) && expression.length === 2 && expression[0] === "guard" && typeof expression[1] === "string";
+var resolveRef = (config, name, visiting, path) => {
+  if (visiting.includes(name)) {
+    return { issue: { code: "GUARD_CYCLE", message: `Guard "${name}" is part of a reference cycle`, guard: name, path } };
+  }
+  const guard = config.guards?.[name];
+  if (guard === void 0) {
+    return { issue: { code: "GUARD_NOT_FOUND", message: `Guard "${name}" is not defined`, guard: name, path } };
+  }
+  return resolveExpression(config, guard, [...visiting, name], path);
+};
+var resolveExpression = (config, expression, visiting, path) => {
+  if (isGuardRef(expression)) {
+    return resolveRef(config, expression[1], visiting, path);
+  }
+  if (!Array.isArray(expression) || typeof expression[0] !== "string") {
+    return { expression };
+  }
+  const [operator, ...args] = expression;
+  if (operator === "and" || operator === "or") {
+    const resolved = [];
+    for (let index = 0; index < args.length; index += 1) {
+      const result = resolveExpression(config, args[index], visiting, `${path}.${index + 1}`);
+      if (result.issue) {
+        return result;
+      }
+      resolved.push(result.expression);
+    }
+    return { expression: [operator, ...resolved] };
+  }
+  if (operator === "not") {
+    const result = resolveExpression(config, args[0], visiting, `${path}.1`);
+    if (result.issue) {
+      return result;
+    }
+    return { expression: ["not", result.expression] };
+  }
+  return { expression };
+};
+var resolveGuards = (config) => {
+  const issues = [];
+  const resolveWhen = (when, path) => {
+    if (when === void 0) {
+      return void 0;
+    }
+    const result = resolveExpression(config, when, [], path);
+    if (result.issue) {
+      issues.push(result.issue);
+      return when;
+    }
+    return result.expression;
+  };
+  const resolveNext = (next, prefix) => next.map((item, index) => {
+    if (typeof item === "string" || !item || typeof item !== "object" || item.when === void 0) {
+      return item;
+    }
+    const target = item;
+    const when = resolveWhen(target.when, `${prefix}.${index}.when`);
+    return when === void 0 ? item : { ...target, when };
+  });
+  const strategies = {};
+  for (const [id, strategy] of Object.entries(config.strategies)) {
+    const when = strategy.when === void 0 ? void 0 : resolveWhen(strategy.when, `${id}.when`);
+    strategies[id] = {
+      ...strategy,
+      ...when !== void 0 ? { when } : {},
+      ...strategy.then ? { then: resolveNext(strategy.then, `${id}.then`) } : {},
+      ...strategy.catch ? { catch: resolveNext(strategy.catch, `${id}.catch`) } : {}
+    };
+  }
+  return { config: { ...config, strategies }, issues };
+};
+
 // src/helpers/validation/validateConfig.ts
 var validateConfig = (config, actionsRegistry, conditionsRegistry) => {
   const errors = [];
@@ -1896,6 +2001,22 @@ var validateConfig = (config, actionsRegistry, conditionsRegistry) => {
       warnings
     };
   }
+  if (config.guards !== void 0) {
+    if (typeof config.guards !== "object" || Array.isArray(config.guards)) {
+      errors.push({ code: "GUARD_INVALID", message: "Config guards must be an object", path: "guards" });
+    } else {
+      for (const [name, expression] of Object.entries(config.guards)) {
+        validateCondition(expression, name, `guards.${name}`, conditionsRegistry, errors);
+      }
+    }
+  }
+  for (const issue of resolveGuards(config).issues) {
+    errors.push({
+      code: issue.code,
+      message: issue.message,
+      ...issue.path ? { path: issue.path } : {}
+    });
+  }
   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 });
@@ -2051,7 +2172,7 @@ var createRunner = (options = {}) => {
     return { ...result, warnings: [...result.warnings, ...runnerLimitWarnings(runnerOptions)] };
   };
   const loadConfig = (nextConfig) => {
-    configRef.current = nextConfig;
+    configRef.current = resolveGuards(nextConfig).config;
     return validateConfig2(nextConfig);
   };
   const runInternal = (entrypoint, context, input, sync, runOptions) => {
@@ -2393,6 +2514,14 @@ var createWS = (options) => {
   let started = false;
   let currentStatus = "idle";
   const diagnosticsBus = options.bus;
+  const isInboundTopic = (topic) => {
+    for (const pattern of inboundTopics) {
+      if (matchesTopic(topic, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  };
   const emitDiagnostic = (topic, payload) => {
     diagnosticsBus.emit(topic, payload, {
       ...options.origin ? { origin: options.origin } : {}
@@ -2470,7 +2599,7 @@ var createWS = (options) => {
           if (typeof data === "string") {
             try {
               const busEvent = JSON.parse(data);
-              if (busEvent.topic && inboundTopics.has(busEvent.topic)) {
+              if (busEvent.topic && isInboundTopic(busEvent.topic)) {
                 if (busEvent.id) {
                   rememberEvent(busEvent.id);
                 }

package/dist/index.d.cts

@@ -4,6 +4,7 @@ type Config = {
     version?: 1;
     strategies: Record<string, Strategy>;
     entrypoints?: Record<string, string>;
+    guards?: Record<string, ConditionExpression>;
 };
 type Strategy = {
     fn: string;
@@ -23,7 +24,7 @@ type Next = string | {
     props?: Props;
     when?: ConditionExpression;
 };
-type ConditionExpression = boolean | [operator: string, ...args: unknown[]];
+type ConditionExpression = boolean | [operator: string, ...args: unknown[]] | ['guard', name: string];
 type Action<TContext, TPatch = unknown> = (args: ActionArgs<TContext>) => ActionResult<TContext, TPatch> | Promise<ActionResult<TContext, TPatch>>;
 type ActionArgs<TContext> = {
     context: TContext;
@@ -77,6 +78,7 @@ type SlapEvent = {
 };
 type EventMap = Record<string, unknown>;
 type EventName<TEvents extends object> = Extract<keyof TEvents, string>;
+type EventPattern = `${string}*${string}`;
 type BusEvent<TPayload = unknown> = {
     id: string;
     topic: string;
@@ -104,8 +106,14 @@ type BusOptions<TEvents extends object> = {
     onError?: (event: BusErrorEvent<TEvents>) => void;
 };
 type Bus<TEvents extends object = EventMap> = {
-    on<TEvent extends EventName<TEvents>>(event: TEvent, handler: EventHandler<TEvents, TEvent>): () => void;
-    off<TEvent extends EventName<TEvents>>(event: TEvent, handler?: EventHandler<TEvents, TEvent>): void;
+    on: {
+        <TEvent extends EventName<TEvents>>(event: TEvent, handler: EventHandler<TEvents, TEvent>): () => void;
+        (event: EventPattern, handler: (event: BusEvent<unknown>) => void): () => void;
+    };
+    off: {
+        <TEvent extends EventName<TEvents>>(event: TEvent, handler?: EventHandler<TEvents, TEvent>): void;
+        (event: EventPattern, handler?: (event: BusEvent<unknown>) => void): void;
+    };
     emit<TEvent extends EventName<TEvents>>(topic: TEvent, payload: TEvents[TEvent], options?: BusEmitOptions): BusEvent<TEvents[TEvent]>;
     dispatch(event: unknown): BusEvent | undefined;
 };
@@ -127,8 +135,8 @@ type WSRetryOptions = RetryOptions;
 type WSOptions<TEvents extends object = EventMap> = {
     bus: Bus<TEvents>;
     createSocket: () => WSSocket;
-    inboundTopics?: EventName<TEvents>[];
-    outboundTopics?: EventName<TEvents>[];
+    inboundTopics?: (EventName<TEvents> | EventPattern)[];
+    outboundTopics?: (EventName<TEvents> | EventPattern)[];
     origin?: string;
     retry?: WSRetryOptions;
 };
@@ -376,4 +384,4 @@ declare const createActionsRegistry: <TContext, TPatch>() => ActionsRegistry<TCo
 type ConditionsRegistry<TContext> = Map<string, ConditionFn<TContext>>;
 declare const createConditionsRegistry: <TContext>() => ConditionsRegistry<TContext>;
 
-export { type Action, type ActionArgs, type ActionFail, type ActionResult, type ActionSkip, type ActionStop, type ActionSuccess, type ActionsRegistry, type BindingEventMap, type Bus, type BusBinding, type BusBindingKey, type BusBindings, type BusEmitOptions, type BusErrorEvent, type BusEvent, type BusOptions, type ConcurrencyMode, type ConcurrencyOptions, type ConditionExpression, type ConditionFn, type ConditionsRegistry, type Config, type DomBinding, type DomBindingKey, type DomBindings, type DomForm, type DomInput, type ErrorReporter, type ErrorReporterHandlers, type ErrorStage, type EventHandler, type EventMap, type EventName, type ExpressionOperator, type FetchResponseType, type Flow, type FlowDefinition, type FlowOptions, type InactiveBinding, type Input, type Mode, type Next, type Props, PubSub, type QueueOverflow, type RetryOptions, type RunOptions, type RunResult, type Runner, type RunnerErrorEvent, type RunnerOptions, type Runtime, type SlapError, type SlapErrorEvent, type SlapEvent, type StartResult, type Strategy, type TraceEntry, type TraceSink, type ValidationIssue, type ValidationResult, type VariableValue, type Variables, type WS, type WSOptions, type WSRetryOptions, type WSSocket, type WSStatus, catchError, createActionsRegistry, createConditionsRegistry, createFlow, createMemoryTraceSink, createPubSub, createWS, defineConfig, defineErrorReporter };
+export { type Action, type ActionArgs, type ActionFail, type ActionResult, type ActionSkip, type ActionStop, type ActionSuccess, type ActionsRegistry, type BindingEventMap, type Bus, type BusBinding, type BusBindingKey, type BusBindings, type BusEmitOptions, type BusErrorEvent, type BusEvent, type BusOptions, type ConcurrencyMode, type ConcurrencyOptions, type ConditionExpression, type ConditionFn, type ConditionsRegistry, type Config, type DomBinding, type DomBindingKey, type DomBindings, type DomForm, type DomInput, type ErrorReporter, type ErrorReporterHandlers, type ErrorStage, type EventHandler, type EventMap, type EventName, type EventPattern, type ExpressionOperator, type FetchResponseType, type Flow, type FlowDefinition, type FlowOptions, type InactiveBinding, type Input, type Mode, type Next, type Props, PubSub, type QueueOverflow, type RetryOptions, type RunOptions, type RunResult, type Runner, type RunnerErrorEvent, type RunnerOptions, type Runtime, type SlapError, type SlapErrorEvent, type SlapEvent, type StartResult, type Strategy, type TraceEntry, type TraceSink, type ValidationIssue, type ValidationResult, type VariableValue, type Variables, type WS, type WSOptions, type WSRetryOptions, type WSSocket, type WSStatus, catchError, createActionsRegistry, createConditionsRegistry, createFlow, createMemoryTraceSink, createPubSub, createWS, defineConfig, defineErrorReporter };

package/dist/index.d.ts

@@ -4,6 +4,7 @@ type Config = {
     version?: 1;
     strategies: Record<string, Strategy>;
     entrypoints?: Record<string, string>;
+    guards?: Record<string, ConditionExpression>;
 };
 type Strategy = {
     fn: string;
@@ -23,7 +24,7 @@ type Next = string | {
     props?: Props;
     when?: ConditionExpression;
 };
-type ConditionExpression = boolean | [operator: string, ...args: unknown[]];
+type ConditionExpression = boolean | [operator: string, ...args: unknown[]] | ['guard', name: string];
 type Action<TContext, TPatch = unknown> = (args: ActionArgs<TContext>) => ActionResult<TContext, TPatch> | Promise<ActionResult<TContext, TPatch>>;
 type ActionArgs<TContext> = {
     context: TContext;
@@ -77,6 +78,7 @@ type SlapEvent = {
 };
 type EventMap = Record<string, unknown>;
 type EventName<TEvents extends object> = Extract<keyof TEvents, string>;
+type EventPattern = `${string}*${string}`;
 type BusEvent<TPayload = unknown> = {
     id: string;
     topic: string;
@@ -104,8 +106,14 @@ type BusOptions<TEvents extends object> = {
     onError?: (event: BusErrorEvent<TEvents>) => void;
 };
 type Bus<TEvents extends object = EventMap> = {
-    on<TEvent extends EventName<TEvents>>(event: TEvent, handler: EventHandler<TEvents, TEvent>): () => void;
-    off<TEvent extends EventName<TEvents>>(event: TEvent, handler?: EventHandler<TEvents, TEvent>): void;
+    on: {
+        <TEvent extends EventName<TEvents>>(event: TEvent, handler: EventHandler<TEvents, TEvent>): () => void;
+        (event: EventPattern, handler: (event: BusEvent<unknown>) => void): () => void;
+    };
+    off: {
+        <TEvent extends EventName<TEvents>>(event: TEvent, handler?: EventHandler<TEvents, TEvent>): void;
+        (event: EventPattern, handler?: (event: BusEvent<unknown>) => void): void;
+    };
     emit<TEvent extends EventName<TEvents>>(topic: TEvent, payload: TEvents[TEvent], options?: BusEmitOptions): BusEvent<TEvents[TEvent]>;
     dispatch(event: unknown): BusEvent | undefined;
 };
@@ -127,8 +135,8 @@ type WSRetryOptions = RetryOptions;
 type WSOptions<TEvents extends object = EventMap> = {
     bus: Bus<TEvents>;
     createSocket: () => WSSocket;
-    inboundTopics?: EventName<TEvents>[];
-    outboundTopics?: EventName<TEvents>[];
+    inboundTopics?: (EventName<TEvents> | EventPattern)[];
+    outboundTopics?: (EventName<TEvents> | EventPattern)[];
     origin?: string;
     retry?: WSRetryOptions;
 };
@@ -376,4 +384,4 @@ declare const createActionsRegistry: <TContext, TPatch>() => ActionsRegistry<TCo
 type ConditionsRegistry<TContext> = Map<string, ConditionFn<TContext>>;
 declare const createConditionsRegistry: <TContext>() => ConditionsRegistry<TContext>;
 
-export { type Action, type ActionArgs, type ActionFail, type ActionResult, type ActionSkip, type ActionStop, type ActionSuccess, type ActionsRegistry, type BindingEventMap, type Bus, type BusBinding, type BusBindingKey, type BusBindings, type BusEmitOptions, type BusErrorEvent, type BusEvent, type BusOptions, type ConcurrencyMode, type ConcurrencyOptions, type ConditionExpression, type ConditionFn, type ConditionsRegistry, type Config, type DomBinding, type DomBindingKey, type DomBindings, type DomForm, type DomInput, type ErrorReporter, type ErrorReporterHandlers, type ErrorStage, type EventHandler, type EventMap, type EventName, type ExpressionOperator, type FetchResponseType, type Flow, type FlowDefinition, type FlowOptions, type InactiveBinding, type Input, type Mode, type Next, type Props, PubSub, type QueueOverflow, type RetryOptions, type RunOptions, type RunResult, type Runner, type RunnerErrorEvent, type RunnerOptions, type Runtime, type SlapError, type SlapErrorEvent, type SlapEvent, type StartResult, type Strategy, type TraceEntry, type TraceSink, type ValidationIssue, type ValidationResult, type VariableValue, type Variables, type WS, type WSOptions, type WSRetryOptions, type WSSocket, type WSStatus, catchError, createActionsRegistry, createConditionsRegistry, createFlow, createMemoryTraceSink, createPubSub, createWS, defineConfig, defineErrorReporter };
+export { type Action, type ActionArgs, type ActionFail, type ActionResult, type ActionSkip, type ActionStop, type ActionSuccess, type ActionsRegistry, type BindingEventMap, type Bus, type BusBinding, type BusBindingKey, type BusBindings, type BusEmitOptions, type BusErrorEvent, type BusEvent, type BusOptions, type ConcurrencyMode, type ConcurrencyOptions, type ConditionExpression, type ConditionFn, type ConditionsRegistry, type Config, type DomBinding, type DomBindingKey, type DomBindings, type DomForm, type DomInput, type ErrorReporter, type ErrorReporterHandlers, type ErrorStage, type EventHandler, type EventMap, type EventName, type EventPattern, type ExpressionOperator, type FetchResponseType, type Flow, type FlowDefinition, type FlowOptions, type InactiveBinding, type Input, type Mode, type Next, type Props, PubSub, type QueueOverflow, type RetryOptions, type RunOptions, type RunResult, type Runner, type RunnerErrorEvent, type RunnerOptions, type Runtime, type SlapError, type SlapErrorEvent, type SlapEvent, type StartResult, type Strategy, type TraceEntry, type TraceSink, type ValidationIssue, type ValidationResult, type VariableValue, type Variables, type WS, type WSOptions, type WSRetryOptions, type WSSocket, type WSStatus, catchError, createActionsRegistry, createConditionsRegistry, createFlow, createMemoryTraceSink, createPubSub, createWS, defineConfig, defineErrorReporter };

package/dist/index.js

@@ -52,6 +52,19 @@ var isBusEvent = (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/matchesTopic.ts
+var matchesTopic = (topic, pattern) => {
+  if (!pattern.includes("*")) {
+    return topic === pattern;
+  }
+  const topicParts = topic.split(".");
+  const patternParts = pattern.split(".");
+  if (topicParts.length !== patternParts.length) {
+    return false;
+  }
+  return patternParts.every((part, index) => part === "*" || part === topicParts[index]);
+};
+
 // src/helpers/pubSub/serializeError.ts
 var serializeError = (error) => ({
   error: error instanceof Error ? error.message : String(error)
@@ -60,6 +73,14 @@ var serializeError = (error) => ({
 // src/pubSub.ts
 var createPubSub = (options = {}) => {
   const subscribers = /* @__PURE__ */ new Map();
+  const wildcardSubscribers = /* @__PURE__ */ new Map();
+  const runHandler = (event, handler) => {
+    try {
+      handler(event);
+    } catch (error) {
+      options.onError?.({ type: "subscriber", event, error });
+    }
+  };
   const dispatch = (event) => {
     let dispatchedEvent;
     if (!isBusEvent(event)) {
@@ -73,10 +94,13 @@ var createPubSub = (options = {}) => {
       const handlers = subscribers.get(event.topic);
       if (handlers) {
         for (const handler of [...handlers]) {
-          try {
-            handler(event);
-          } catch (error) {
-            options.onError?.({ type: "subscriber", event, error });
+          runHandler(event, handler);
+        }
+      }
+      for (const [pattern, wildcardHandlers] of wildcardSubscribers) {
+        if (matchesTopic(event.topic, pattern)) {
+          for (const handler of [...wildcardHandlers]) {
+            runHandler(event, handler);
           }
         }
       }
@@ -85,23 +109,24 @@ var createPubSub = (options = {}) => {
     return dispatchedEvent;
   };
   const on = (event, handler) => {
-    const handlers = subscribers.get(event) ?? /* @__PURE__ */ new Set();
-    const listener = handler;
-    handlers.add(listener);
-    subscribers.set(event, handlers);
+    const registry = event.includes("*") ? wildcardSubscribers : subscribers;
+    const handlers = registry.get(event) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    registry.set(event, handlers);
     return () => off(event, handler);
   };
   const off = (event, handler) => {
+    const registry = event.includes("*") ? wildcardSubscribers : subscribers;
     if (handler) {
-      const handlers = subscribers.get(event);
+      const handlers = registry.get(event);
       if (handlers) {
         handlers.delete(handler);
         if (handlers.size === 0) {
-          subscribers.delete(event);
+          registry.delete(event);
         }
       }
     } else {
-      subscribers.delete(event);
+      registry.delete(event);
     }
   };
   const emit = (topic, payload, emitOptions = {}) => {
@@ -1798,6 +1823,12 @@ var validateCondition = (expression, strategy, path, conditionsRegistry, errors)
     return;
   }
   const [operator, ...args] = expression;
+  if (operator === "guard") {
+    if (args.length !== 1 || typeof args[0] !== "string") {
+      errors.push({ code: "CONDITION_INVALID", message: "Guard reference must be a single string name", strategy, path });
+    }
+    return;
+  }
   if (operator === "and" || operator === "or") {
     args.forEach((arg, index) => validateCondition(arg, strategy, `${path}.${index + 1}`, conditionsRegistry, errors));
     return;
@@ -1843,6 +1874,80 @@ var validateNextList = (config, list, path, strategy, conditionsRegistry, errors
   });
 };
 
+// src/helpers/validation/resolveGuards.ts
+var isGuardRef = (expression) => Array.isArray(expression) && expression.length === 2 && expression[0] === "guard" && typeof expression[1] === "string";
+var resolveRef = (config, name, visiting, path) => {
+  if (visiting.includes(name)) {
+    return { issue: { code: "GUARD_CYCLE", message: `Guard "${name}" is part of a reference cycle`, guard: name, path } };
+  }
+  const guard = config.guards?.[name];
+  if (guard === void 0) {
+    return { issue: { code: "GUARD_NOT_FOUND", message: `Guard "${name}" is not defined`, guard: name, path } };
+  }
+  return resolveExpression(config, guard, [...visiting, name], path);
+};
+var resolveExpression = (config, expression, visiting, path) => {
+  if (isGuardRef(expression)) {
+    return resolveRef(config, expression[1], visiting, path);
+  }
+  if (!Array.isArray(expression) || typeof expression[0] !== "string") {
+    return { expression };
+  }
+  const [operator, ...args] = expression;
+  if (operator === "and" || operator === "or") {
+    const resolved = [];
+    for (let index = 0; index < args.length; index += 1) {
+      const result = resolveExpression(config, args[index], visiting, `${path}.${index + 1}`);
+      if (result.issue) {
+        return result;
+      }
+      resolved.push(result.expression);
+    }
+    return { expression: [operator, ...resolved] };
+  }
+  if (operator === "not") {
+    const result = resolveExpression(config, args[0], visiting, `${path}.1`);
+    if (result.issue) {
+      return result;
+    }
+    return { expression: ["not", result.expression] };
+  }
+  return { expression };
+};
+var resolveGuards = (config) => {
+  const issues = [];
+  const resolveWhen = (when, path) => {
+    if (when === void 0) {
+      return void 0;
+    }
+    const result = resolveExpression(config, when, [], path);
+    if (result.issue) {
+      issues.push(result.issue);
+      return when;
+    }
+    return result.expression;
+  };
+  const resolveNext = (next, prefix) => next.map((item, index) => {
+    if (typeof item === "string" || !item || typeof item !== "object" || item.when === void 0) {
+      return item;
+    }
+    const target = item;
+    const when = resolveWhen(target.when, `${prefix}.${index}.when`);
+    return when === void 0 ? item : { ...target, when };
+  });
+  const strategies = {};
+  for (const [id, strategy] of Object.entries(config.strategies)) {
+    const when = strategy.when === void 0 ? void 0 : resolveWhen(strategy.when, `${id}.when`);
+    strategies[id] = {
+      ...strategy,
+      ...when !== void 0 ? { when } : {},
+      ...strategy.then ? { then: resolveNext(strategy.then, `${id}.then`) } : {},
+      ...strategy.catch ? { catch: resolveNext(strategy.catch, `${id}.catch`) } : {}
+    };
+  }
+  return { config: { ...config, strategies }, issues };
+};
+
 // src/helpers/validation/validateConfig.ts
 var validateConfig = (config, actionsRegistry, conditionsRegistry) => {
   const errors = [];
@@ -1861,6 +1966,22 @@ var validateConfig = (config, actionsRegistry, conditionsRegistry) => {
       warnings
     };
   }
+  if (config.guards !== void 0) {
+    if (typeof config.guards !== "object" || Array.isArray(config.guards)) {
+      errors.push({ code: "GUARD_INVALID", message: "Config guards must be an object", path: "guards" });
+    } else {
+      for (const [name, expression] of Object.entries(config.guards)) {
+        validateCondition(expression, name, `guards.${name}`, conditionsRegistry, errors);
+      }
+    }
+  }
+  for (const issue of resolveGuards(config).issues) {
+    errors.push({
+      code: issue.code,
+      message: issue.message,
+      ...issue.path ? { path: issue.path } : {}
+    });
+  }
   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 });
@@ -2016,7 +2137,7 @@ var createRunner = (options = {}) => {
     return { ...result, warnings: [...result.warnings, ...runnerLimitWarnings(runnerOptions)] };
   };
   const loadConfig = (nextConfig) => {
-    configRef.current = nextConfig;
+    configRef.current = resolveGuards(nextConfig).config;
     return validateConfig2(nextConfig);
   };
   const runInternal = (entrypoint, context, input, sync, runOptions) => {
@@ -2358,6 +2479,14 @@ var createWS = (options) => {
   let started = false;
   let currentStatus = "idle";
   const diagnosticsBus = options.bus;
+  const isInboundTopic = (topic) => {
+    for (const pattern of inboundTopics) {
+      if (matchesTopic(topic, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  };
   const emitDiagnostic = (topic, payload) => {
     diagnosticsBus.emit(topic, payload, {
       ...options.origin ? { origin: options.origin } : {}
@@ -2435,7 +2564,7 @@ var createWS = (options) => {
           if (typeof data === "string") {
             try {
               const busEvent = JSON.parse(data);
-              if (busEvent.topic && inboundTopics.has(busEvent.topic)) {
+              if (busEvent.topic && isInboundTopic(busEvent.topic)) {
                 if (busEvent.id) {
                   rememberEvent(busEvent.id);
                 }

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "slapflow",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Chain actions behavior runtime",
   "license": "ISC",
   "author": "Sergey Khalilov",
   "keywords": [
     "behavior",
     "workflow",
+    "orchestration",
+    "state-machine",
+    "event-driven",
+    "concurrency",
+    "cancellation",
+    "pubsub",
+    "fetch",
+    "websocket",
     "action-runner",
     "rules-engine",
     "typescript"