chain-functions-behavior 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1559 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PubSubBehavior: () => PubSubBehavior,
+  catchError: () => catchError,
+  createBehaviorRunner: () => createBehaviorRunner,
+  createBehaviorWs: () => createBehaviorWs,
+  createChainBehavior: () => createChainBehavior,
+  createMemoryTraceSink: () => createMemoryTraceSink,
+  createPubSubBehavior: () => createPubSubBehavior,
+  defineBehaviorConfig: () => defineBehaviorConfig,
+  defineErrorReporter: () => defineErrorReporter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/helpers/config/defineBehaviorConfig.ts
+var defineBehaviorConfig = (config) => config;
+
+// src/helpers/errors/behaviorError.ts
+var behaviorError = (code, message, extras = {}) => ({ code, message, ...extras });
+
+// src/helpers/errors/defineErrorReporter.ts
+var defineErrorReporter = (handlers) => typeof handlers === "function" ? handlers : handlers.report;
+
+// src/errors.ts
+var BehaviorSyncAsyncError = class extends Error {
+  behaviorError;
+  constructor(error) {
+    super(error.message);
+    this.name = "BehaviorSyncAsyncError";
+    this.behaviorError = error;
+  }
+};
+
+// src/helpers/actions/coreDelay.ts
+var coreDelay = () => async ({ props }) => {
+  const ms = Math.max(0, Number(props.ms ?? 0));
+  await new Promise((resolve) => setTimeout(resolve, ms));
+  return void 0;
+};
+
+// src/helpers/actions/coreEmit.ts
+var coreEmit = () => ({ props, runtime }) => {
+  const type = props.type;
+  if (typeof type === "string") {
+    runtime.emit({ type, payload: props.payload });
+  }
+  return void 0;
+};
+
+// src/helpers/actions/coreFail.ts
+var coreFail = () => ({ props, runtime }) => runtime.fail(String(props.reason ?? "failed"), props.data);
+
+// 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);
+  }
+  return void 0;
+};
+
+// src/helpers/actions/coreSetData.ts
+var coreSetData = () => ({ props, runtime }) => {
+  const path = props.path;
+  if (typeof path === "string") {
+    runtime.setData(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.sequence", coreNoop()],
+  ["core.selector", coreNoop()],
+  ["core.parallel", coreNoop()],
+  ["core.set", coreSetData()],
+  ["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/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],
+  ["changed", changedCondition],
+  ["cooldownReady", cooldownReadyCondition]
+]);
+
+// src/helpers/trace/createMemoryTraceSink.ts
+var createMemoryTraceSink = () => {
+  const items = [];
+  return {
+    push: (entry) => {
+      items.push(entry);
+    },
+    entries: () => [...items]
+  };
+};
+
+// 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
+var import_objwalk = require("objwalk");
+
+// src/helpers/path/pathReferenceRegex.ts
+var pathReferenceRegex = /^\$(context|data|input)(?:\.([A-Za-z0-9_$.[\]-]+))?$/;
+
+// src/helpers/path/resolveValue.ts
+var resolveValue = (value, scope) => {
+  if (typeof value === "string") {
+    const match = value.match(pathReferenceRegex);
+    if (!match) {
+      return value;
+    }
+    const root = match[1];
+    const path = match[2] ?? "";
+    const source = scope[root];
+    if (!path) {
+      return source;
+    }
+    if (!source || typeof source !== "object") {
+      return void 0;
+    }
+    return (0, import_objwalk.pick)(source, path);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveValue(item, scope));
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.$template === "string") {
+      return record.$template.replace(/\{\{\s*([A-Za-z0-9_$.[\]-]+)\s*\}\}/g, (_, key) => {
+        const resolved = resolveValue(`$data.${key}`, scope);
+        return resolved == null ? "" : String(resolved);
+      });
+    }
+    return Object.fromEntries(Object.entries(record).map(([key, item]) => [key, resolveValue(item, scope)]));
+  }
+  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: behaviorError("CONDITION_NOT_FOUND", `Condition "${operator}" is not registered`, {
+        ...scope.strategy ? { strategy: scope.strategy } : {}
+      })
+    };
+  }
+  const args = rawArgs.map((arg) => resolveValue(arg, scope));
+  return { ok: true, matched: Boolean(condition(scope, ...args)) };
+};
+
+// src/helpers/runner/createRuntime.ts
+var import_objwalk2 = require("objwalk");
+var runtimePick = (source, path) => {
+  if (!path) {
+    return source;
+  }
+  if (!source || typeof source !== "object") {
+    return void 0;
+  }
+  return (0, import_objwalk2.pick)(source, path);
+};
+var createRuntime = (state) => ({
+  get: (path) => runtimePick(state.context, path),
+  getData: (path) => runtimePick(state.data, path),
+  setData: (path, value) => {
+    (0, import_objwalk2.set)(state.data, path, value);
+  },
+  resolve: (value) => resolveValue(value, state),
+  signal: state.signal,
+  emit: (event) => state.events.push(event),
+  patch: (patch) => state.patches.push(patch),
+  stop: (reason) => reason ? { type: "stop", reason } : { type: "stop" },
+  fail: (reason, data) => ({
+    type: "fail",
+    ...reason ? { reason } : {},
+    ...data ? { data } : {}
+  })
+});
+
+// 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/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, patches: [], events: [], data: { ...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);
+      state.steps = Math.max(state.steps, child.steps);
+    }
+    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/withErrorStage.ts
+var compactStage = (stage) => Object.fromEntries(Object.entries(stage).filter(([, value]) => value !== void 0));
+var withErrorStage = (error, stage) => {
+  const nextError = {
+    ...error,
+    stage: compactStage({
+      ...stage,
+      ...error.stage
+    })
+  };
+  const strategy = error.strategy ?? stage.strategy;
+  const fn = error.fn ?? stage.fn;
+  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.steps
+  });
+  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) {
+    return executeSequence(strategy.catch, depth, state, environment);
+  }
+  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") {
+    return {
+      status: "failed",
+      error: behaviorError("ACTION_THROWN", raw.reason ?? "Action failed", { cause: raw.error }),
+      patches: [],
+      events: [],
+      ...raw.data ? { data: raw.data } : {}
+    };
+  }
+  return {
+    status: "success",
+    patches,
+    events,
+    ...raw.context !== void 0 ? { context: raw.context } : {},
+    ...raw.data ? { data: raw.data } : {}
+  };
+};
+
+// src/helpers/trace/cloneData.ts
+var cloneData = (data) => ({ ...data });
+
+// 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/afterAction.ts
+var afterAction = (raw, id, strategy, depth, state, props, dataBefore, traceStep, startedAt, environment) => {
+  const result = normalizeActionResult(raw);
+  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);
+  const reason = result.status === "failed" ? result.error.message : "reason" in result ? result.reason : void 0;
+  pushTrace(
+    state,
+    traceStep,
+    depth,
+    id,
+    strategy,
+    result.status === "success" ? "success" : result.status,
+    props,
+    dataBefore,
+    startedAt,
+    reason
+  );
+  if (result.status === "failed") {
+    return handleFailure(result.error, strategy, depth, state, environment);
+  }
+  if (result.status === "skipped" || result.status === "stopped") {
+    return result;
+  }
+  if (strategy.terminal) {
+    return result;
+  }
+  return executeThen(strategy, depth, state, environment);
+};
+
+// src/helpers/runner/runnerDefaults.ts
+var defaultMaxSteps = 100;
+var defaultMaxDepth = 32;
+
+// src/helpers/runner/failLimit.ts
+var failLimit = (code, message, id) => ({
+  status: "failed",
+  error: behaviorError(code, message, { strategy: id, stage: { phase: "limit", strategy: id } }),
+  patches: [],
+  events: []
+});
+
+// src/helpers/runner/executeStrategy.ts
+var executeStrategy = (id, extraProps, depth, state, environment) => {
+  const config = environment.configRef.current;
+  if (!config) {
+    return {
+      status: "failed",
+      error: behaviorError("CONFIG_INVALID", "No behavior config loaded", { stage: { phase: "entrypoint" } }),
+      patches: [],
+      events: []
+    };
+  }
+  if (depth > (environment.options.maxDepth ?? defaultMaxDepth)) {
+    return failLimit("MAX_DEPTH", `Max depth exceeded at strategy "${id}"`, id);
+  }
+  if (state.steps >= (environment.options.maxSteps ?? defaultMaxSteps)) {
+    return failLimit("MAX_STEPS", `Max steps exceeded at strategy "${id}"`, id);
+  }
+  if (environment.options.timeoutMs && Date.now() - state.startedAt > environment.options.timeoutMs) {
+    return failLimit("TIMEOUT", `Behavior run timed out after ${environment.options.timeoutMs}ms`, id);
+  }
+  const strategy = config.strategies[id];
+  if (!strategy) {
+    return {
+      status: "failed",
+      error: behaviorError("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: behaviorError("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.steps + 1 }
+      }),
+      patches: [],
+      events: []
+    };
+  }
+  const props = resolveValue({ ...strategy.props ?? {}, ...extraProps }, state);
+  const runtime = createRuntime(state);
+  const dataBefore = cloneData(state.data);
+  const traceStep = state.steps + 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", props, dataBefore, startedAt);
+    return { status: "skipped", reason: "when condition did not match", patches: [], events: [] };
+  }
+  state.steps += 1;
+  const invoke = () => action({ context: state.context, props, input: state.input, signal: state.signal, runtime });
+  try {
+    const raw = invoke();
+    if (isPromiseLike(raw)) {
+      if (state.sync) {
+        throw new BehaviorSyncAsyncError(
+          behaviorError("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 }
+          })
+        );
+      }
+      return raw.then(
+        (value) => afterAction(value, id, strategy, depth, state, props, dataBefore, traceStep, startedAt, environment)
+      ).catch(
+        (cause) => handleFailure(
+          behaviorError("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
+        )
+      );
+    }
+    return afterAction(raw, id, strategy, depth, state, props, dataBefore, traceStep, startedAt, environment);
+  } catch (cause) {
+    if (cause instanceof BehaviorSyncAsyncError) {
+      throw cause;
+    }
+    return handleFailure(
+      behaviorError("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
+    );
+  }
+};
+
+// 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.steps
+  };
+  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: behaviorError("CONFIG_INVALID", "No behavior config loaded", { stage: { phase: "entrypoint" } }) };
+  }
+  const id = config.entrypoints?.[entrypoint] ?? entrypoint;
+  if (!config.strategies[id]) {
+    return {
+      error: behaviorError("STRATEGY_NOT_FOUND", `Strategy "${id}" is not defined`, {
+        strategy: id,
+        stage: { phase: "entrypoint", entrypoint, strategy: id }
+      })
+    };
+  }
+  return { id };
+};
+
+// 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 next of config.strategies[id]?.then ?? []) {
+      const target = typeof next === "string" ? next : next.strategy;
+      if (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/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]) => 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, 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?.strategy;
+    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}`
+      });
+    }
+  });
+};
+
+// src/helpers/validation/validateBehaviorConfig.ts
+var validateBehaviorConfig = (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") {
+    errors.push({ code: "CONFIG_INVALID", message: "Config must include strategies", path: "strategies" });
+  }
+  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, errors);
+    validateNextList(config, strategy.catch, `${id}.catch`, id, 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);
+  return { ok: errors.length === 0, errors, warnings };
+};
+
+// src/helpers/runner/createBehaviorRunner.ts
+var createBehaviorRunner = (options = {}) => {
+  const actionsRegistry = createActionsRegistry();
+  const conditionsRegistry = createConditionsRegistry();
+  const configRef = {};
+  const mergeData = options.mergeData ?? ((current, next) => ({ ...current, ...next }));
+  const environment = {
+    actionsRegistry,
+    conditionsRegistry,
+    configRef,
+    options,
+    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 validateConfig = (target = configRef.current) => validateBehaviorConfig(target, actionsRegistry, conditionsRegistry);
+  const loadConfig = (nextConfig) => {
+    configRef.current = nextConfig;
+    return validateConfig(nextConfig);
+  };
+  const runInternal = (entrypoint, context, input, sync, runOptions) => {
+    const traceSink = options.trace === true ? createMemoryTraceSink() : options.trace || void 0;
+    const state = {
+      context,
+      input,
+      data: {},
+      patches: [],
+      events: [],
+      steps: 0,
+      startedAt: Date.now(),
+      sync,
+      signal: runOptions.signal ?? new AbortController().signal,
+      reportedErrors: [],
+      ...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) => 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 BehaviorSyncAsyncError(behaviorError("ASYNC_IN_SYNC_RUN", "runSync encountered an async action"));
+    }
+    return result;
+  };
+  return {
+    registerAction,
+    registerActions,
+    registerCondition,
+    registerConditions,
+    loadConfig,
+    validateConfig,
+    run,
+    runSync
+  };
+};
+
+// src/pubSub.ts
+var import_nanoid = require("nanoid");
+var serializeError = (error) => ({
+  error: error instanceof Error ? error.message : String(error)
+});
+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");
+};
+var createPubSubBehavior = (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 behavior 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: (0, import_nanoid.nanoid)(),
+        topic,
+        occurredAt: Date.now(),
+        ...emitOptions.origin ? { origin: emitOptions.origin } : {},
+        parsed: payload,
+        serialized
+      };
+    } catch (error) {
+      const parsed = serializeError(error);
+      event = {
+        id: (0, import_nanoid.nanoid)(),
+        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 PubSubBehavior = createPubSubBehavior();
+
+// src/chainBehavior.ts
+var busBindingPrefix = "[bus] ";
+var domBindingPrefix = "[dom] ";
+var defaultMaxQueueSize = 50;
+var createChainBehavior = (definition, options) => {
+  const runner = createBehaviorRunner(options);
+  const bus = options.bus ?? PubSubBehavior;
+  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("cfb.run.dropped", { binding, input, reason: "behavior-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) => {
+    const controller = new AbortController();
+    const run = { controller, id: `run-${++runCount}` };
+    activeRuns.add(run);
+    if (lane) {
+      lane.active = run;
+    }
+    emitDiagnostic("cfb.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("cfb.run.cancelled", payload);
+      } else if (result.status === "failed") {
+        emitDiagnostic("cfb.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("cfb.run.finished", { ...payload, status: result.status });
+      }
+    }).catch((error) => {
+      const payload = { binding, entrypoint: target.entrypoint, key, runId: run.id };
+      emitDiagnostic(controller.signal.aborted ? "cfb.run.cancelled" : "cfb.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);
+        } else {
+          lanes.delete(key);
+        }
+      }
+    });
+  };
+  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);
+      } else if (mode === "latest") {
+        lane.active.controller.abort();
+        startRun(binding, target, input, key, lane);
+      } else if (mode === "drop") {
+        emitDiagnostic("cfb.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("cfb.queue.overflow", { binding, entrypoint: target.entrypoint, key, maxQueueSize });
+          if (dropsOldest) {
+            const dropped = lane.queue.shift();
+            emitDiagnostic("cfb.run.dropped", {
+              binding,
+              entrypoint: target.entrypoint,
+              key,
+              reason: "queue-overflow",
+              ...dropped ? { input: dropped } : {}
+            });
+          } else {
+            emitDiagnostic("cfb.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) => {
+      scheduleRun(binding, target, busEvent.parsed);
+    });
+    unsubscribers.add(unsubscribe);
+  };
+  const parseDomBinding = (binding) => {
+    const source = binding.slice(domBindingPrefix.length);
+    const separator = source.lastIndexOf(":");
+    if (separator <= 0 || separator === source.length - 1) {
+      return void 0;
+    }
+    return { selector: source.slice(0, separator), eventType: source.slice(separator + 1) };
+  };
+  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);
+    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 createBehaviorWs = (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 getRetryDelay = () => {
+    const initialDelay = options.retry?.initialDelay ?? 500;
+    const maxDelay = options.retry?.maxDelay ?? 1e4;
+    const multiplier = options.retry?.multiplier ?? 2;
+    const base = Math.min(initialDelay * multiplier ** retryAttempt, maxDelay);
+    return options.retry?.jitter === false ? base : Math.round(base * (0.5 + Math.random() * 0.5));
+  };
+  const connect = () => {
+    if (started && !socket) {
+      currentStatus = "connecting";
+      emitDiagnostic("cfb.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) {
+              const delay = getRetryDelay();
+              const attempt = retryAttempt + 1;
+              const retry = () => {
+                retryTimer = void 0;
+                connect();
+              };
+              currentStatus = "retrying";
+              retryAttempt = attempt;
+              retryTimer = setTimeout(retry, delay);
+              emitDiagnostic("cfb.ws.retrying", { reason, delay, attempt });
+            }
+          }
+        };
+        listen("open", () => {
+          if (socket === current) {
+            retryAttempt = 0;
+            currentStatus = "connected";
+            emitDiagnostic("cfb.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("cfb.ws.message.rejected", { reason: "invalid-envelope", topic: busEvent.topic });
+                }
+              } else {
+                emitDiagnostic("cfb.ws.message.rejected", { reason: "topic-not-allowed", topic: busEvent.topic });
+              }
+            } catch (error) {
+              emitDiagnostic("cfb.ws.message.rejected", { reason: "message-parse-failed", error: String(error) });
+            }
+          } else {
+            emitDiagnostic("cfb.ws.message.rejected", { reason: "message-not-string" });
+          }
+        });
+      } catch (error) {
+        const delay = getRetryDelay();
+        const attempt = retryAttempt + 1;
+        const retry = () => {
+          retryTimer = void 0;
+          connect();
+        };
+        currentStatus = "retrying";
+        retryAttempt = attempt;
+        retryTimer = setTimeout(retry, delay);
+        emitDiagnostic("cfb.ws.retrying", { reason: "socket-create-failed", delay, attempt, error: String(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(event.serialized);
+          }
+        });
+        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("cfb.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);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PubSubBehavior,
+  catchError,
+  createBehaviorRunner,
+  createBehaviorWs,
+  createChainBehavior,
+  createMemoryTraceSink,
+  createPubSubBehavior,
+  defineBehaviorConfig,
+  defineErrorReporter
+});