flowneer 0.1.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stephan Langeveld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,13 @@
 # Flowneer
 
+<p>
+  <a href="https://www.npmjs.com/package/flowneer"><img src="https://badges.ws/npm/v/flowneer" /></a>
+  <a href="https://deno.bundlejs.com/badge?q=flowneer"><img src="https://deno.bundlejs.com/badge?q=flowneer" /></a>
+  <a href="https://www.npmjs.com/package/flowneer"><img src="https://badges.ws/npm/l/flowneer" /></a>
+  <a href="https://www.npmjs.com/package/flowneer"><img src="https://badges.ws/npm/dt/flowneer" /></a>
+  <a href="https://deepwiki.com/Fanna1119/flowneer"><img src="https://deepwiki.com/badge.svg" /></a>
+</p>
+
 A tiny, zero-dependency fluent flow builder for TypeScript. Chain steps, branch on conditions, loop, batch-process, and run tasks in parallel — all through a single `FlowBuilder` class. Extend it with plugins.
 
 ## Install
@@ -121,7 +129,7 @@ await new FlowBuilder<SumState>()
 // → [2, 4, 6]
 ```
 
-### `parallel(fns, options?)`
+### `parallel(fns, options?, reducer?)`
 
 Run multiple functions concurrently against the same shared state.
 
@@ -155,6 +163,67 @@ await new FlowBuilder<FetchState>()
 // → Fetched 100 posts and 10 users
 ```
 
+When a `reducer` is provided each fn receives its own **shallow clone** of `shared`, preventing concurrent write races. After all fns settle the reducer merges the drafts back into the original:
+
+```typescript
+interface ScoreState {
+  value: number;
+}
+
+await new FlowBuilder<ScoreState>()
+  .parallel(
+    [
+      async (s) => {
+        s.value += 10;
+      },
+      async (s) => {
+        s.value += 20;
+      },
+    ],
+    undefined,
+    (original, drafts) => {
+      // drafts[0].value === 10, drafts[1].value === 20 (each started at 0)
+      original.value = drafts.reduce((sum, d) => sum + d.value, 0);
+    },
+  )
+  .run({ value: 0 });
+// original.value === 30
+```
+
+See [`withAtomicUpdates`](#withatomicupdates) for the plugin shorthand.
+
+### `label(name)`
+
+Insert a named marker in the step chain. Labels are no-ops during normal execution — they exist only as jump targets.
+
+Any `NodeFn` can return `"→labelName"` to jump back (or forward) to that label, enabling iterative refinement and reflection loops without nesting:
+
+```typescript
+interface RefineState {
+  draft: string;
+  passes: number;
+  quality: number;
+}
+
+await new FlowBuilder<RefineState>()
+  .startWith(async (s) => {
+    s.draft = await generateDraft(s);
+  })
+  .label("refine")
+  .then(async (s) => {
+    s.quality = await scoreDraft(s.draft);
+    if (s.quality < 0.8) {
+      s.draft = await improveDraft(s.draft);
+      s.passes++;
+      return "→refine"; // jump back to the label
+    }
+  })
+  .then(async (s) => console.log("Final draft after", s.passes, "passes"))
+  .run({ draft: "", passes: 0, quality: 0 });
+```
+
+> **Tip:** Pair with [`withCycles`](#withcycles) to cap the maximum number of jumps.
+
 ### `run(shared, params?, options?)`
 
 Execute the flow. Optionally pass a `params` object that every step receives as a second argument.
@@ -210,12 +279,89 @@ FlowError: Flow failed at loop (step 1): exploded on tick 2
 FlowError: Flow failed at batch (step 0): bad item: 3
 ```
 
+### `InterruptError`
+
+`InterruptError` is a special error that **bypasses `FlowError` wrapping** — it propagates directly to the caller. Use it for human-in-the-loop and approval patterns (via [`withInterrupts`](#withinterrupts)).
+
+```typescript
+import { FlowBuilder, InterruptError } from "flowneer";
+
+try {
+  await flow.run(shared);
+} catch (err) {
+  if (err instanceof InterruptError) {
+    // err.savedShared is a deep clone of state at the interrupt point
+    const approval = await askHuman(err.savedShared);
+    if (approval) await flow.run(shared); // resume from scratch or use withReplay
+  }
+}
+```
+
 ## Plugins
 
 The core is intentionally small. Use `FlowBuilder.use(plugin)` to add chain methods.
 
 A plugin is an object of functions that get copied onto `FlowBuilder.prototype`. Each function receives the builder as `this` and should return `this` for chaining.
 
+### Available plugins
+
+| Category          | Plugin                    | Method                                    | Description                                                                                              |
+| ----------------- | ------------------------- | ----------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| **Observability** | `withHistory`             | `.withHistory()`                          | Appends a shallow state snapshot after each step to `shared.__history`                                   |
+|                   | `withTiming`              | `.withTiming()`                           | Records wall-clock duration (ms) of each step in `shared.__timings[index]`                               |
+|                   | `withVerbose`             | `.withVerbose()`                          | Prints the full `shared` object to stdout after each step                                                |
+|                   | `withInterrupts`          | `.interruptIf(condition)`                 | Pauses the flow by throwing an `InterruptError` (with a deep-clone of `shared`) when condition is true   |
+| **Persistence**   | `withCheckpoint`          | `.withCheckpoint(store)`                  | Saves `shared` to a store after each successful step                                                     |
+|                   | `withAuditLog`            | `.withAuditLog(store)`                    | Writes an immutable deep-clone audit entry to a store after every step (success and error)               |
+|                   | `withReplay`              | `.withReplay(fromStep)`                   | Skips all steps before `fromStep`; combine with `.withCheckpoint()` to resume a failed flow              |
+|                   | `withVersionedCheckpoint` | `.withVersionedCheckpoint(store)`         | Saves diff-based versioned checkpoints with parent pointers after each step that changes state           |
+|                   |                           | `.resumeFrom(version, store)`             | Resolves a version id and skips all steps up to and including the saved step index                       |
+| **Resilience**    | `withCircuitBreaker`      | `.withCircuitBreaker(opts?)`              | Opens the circuit after `maxFailures` consecutive failures and rejects all steps until `resetMs` elapses |
+|                   | `withFallback`            | `.withFallback(fn)`                       | Catches any step error and calls `fn` instead of propagating, allowing the flow to continue              |
+|                   | `withTimeout`             | `.withTimeout(ms)`                        | Aborts any step that exceeds `ms` milliseconds with a descriptive error                                  |
+|                   | `withCycles`              | `.withCycles(maxJumps?)`                  | Throws if total step executions exceed `maxJumps` (default 100) — guards against infinite goto loops     |
+| **Messaging**     | `withChannels`            | `.withChannels()`                         | Initialises a `Map`-based message-channel system on `shared.__channels`                                  |
+| **LLM**           | `withCostTracker`         | `.withCostTracker()`                      | Accumulates per-step `shared.__stepCost` values into `shared.__cost` after each step                     |
+|                   | `withRateLimit`           | `.withRateLimit({ intervalMs })`          | Enforces a minimum gap of `intervalMs` ms between steps to avoid hammering rate-limited APIs             |
+|                   | `withTokenBudget`         | `.withTokenBudget(limit)`                 | Aborts the flow before any step where `shared.tokensUsed >= limit`                                       |
+| **Dev**           | `withDryRun`              | `.withDryRun()`                           | Skips all step bodies while still firing hooks — useful for validating observability wiring              |
+|                   | `withMocks`               | `.withMocks(map)`                         | Replaces step bodies at specified indices with mock functions; all other steps run normally              |
+|                   | `withStepLimit`           | `.withStepLimit(max?)`                    | Throws after `max` total step executions (default 1000); counter resets on each `run()` call             |
+|                   | `withAtomicUpdates`       | `.parallelAtomic(fns, reducer, options?)` | Sugar over `parallel()` with a reducer — each fn runs on an isolated draft, reducer merges results       |
+
+Plugins are imported from `flowneer/plugins` (or their individual subpath) and registered once with `FlowBuilder.use()`:
+
+```typescript
+import { withTiming, withCostTracker } from "flowneer/plugins";
+
+FlowBuilder.use(withTiming);
+FlowBuilder.use(withCostTracker);
+```
+
+Messaging utilities are standalone functions — no need to register them as a plugin method:
+
+```typescript
+import {
+  withChannels,
+  sendTo,
+  receiveFrom,
+  peekChannel,
+} from "flowneer/plugins/messaging";
+
+FlowBuilder.use(withChannels);
+
+const flow = new FlowBuilder()
+  .withChannels()
+  .startWith(async (s) => {
+    sendTo(s, "results", { score: 42 });
+  })
+  .then(async (s) => {
+    const msgs = receiveFrom(s, "results"); // [{ score: 42 }]
+  });
+```
+
+---
+
 ### Writing a plugin
 
 ```typescript
@@ -257,23 +403,33 @@ const flow = new FlowBuilder<MyState>()
 
 ### Lifecycle hooks
 
-Plugins register hooks via `_setHooks()`. Three hook points are available:
+Plugins register hooks via `_setHooks()`. The following hook points are available:
+
+| Hook             | Called                                                    | Arguments                               |
+| ---------------- | --------------------------------------------------------- | --------------------------------------- |
+| `beforeFlow`     | Once before the first step                                | `(shared, params)`                      |
+| `beforeStep`     | Before each step executes                                 | `(meta, shared, params)`                |
+| `wrapStep`       | Wraps step execution — call `next()` to run the step body | `(meta, next, shared, params)`          |
+| `afterStep`      | After each step completes                                 | `(meta, shared, params)`                |
+| `wrapParallelFn` | Wraps each individual fn inside a `parallel()` step       | `(meta, fnIndex, next, shared, params)` |
+| `onError`        | When a step throws (before re-throwing)                   | `(meta, error, shared, params)`         |
+| `afterFlow`      | After the flow finishes (success or failure)              | `(shared, params)`                      |
 
-| Hook         | Called                                       | Arguments                       |
-| ------------ | -------------------------------------------- | ------------------------------- |
-| `beforeStep` | Before each step executes                    | `(meta, shared, params)`        |
-| `afterStep`  | After each step completes                    | `(meta, shared, params)`        |
-| `onError`    | When a step throws (before re-throwing)      | `(meta, error, shared, params)` |
-| `afterFlow`  | After the flow finishes (success or failure) | `(shared, params)`              |
+Multiple `wrapStep` (or `wrapParallelFn`) registrations compose — the first registered is the outermost wrapper. Omitting `next()` skips the step body entirely (used by `withDryRun`, `withMocks`, `withReplay`).
 
 ### What plugins are for
 
-| Concern                     | Example plugin  | Hook it uses                           |
-| --------------------------- | --------------- | -------------------------------------- |
-| Observability / tracing     | `observePlugin` | `beforeStep` + `afterStep` + `onError` |
-| Persistence / checkpointing | `persistPlugin` | `afterStep`                            |
-| Timing / metrics            | custom          | `beforeStep` + `afterStep`             |
-| Cleanup / teardown          | custom          | `afterFlow`                            |
+| Concern                      | Plugin / hook                 | Hook(s) used                        |
+| ---------------------------- | ----------------------------- | ----------------------------------- |
+| Observability / tracing      | `withHistory`, `withTiming`   | `beforeStep` + `afterStep`          |
+| Persistence / checkpointing  | `withCheckpoint`              | `afterStep`                         |
+| Versioned persistence        | `withVersionedCheckpoint`     | `beforeFlow` + `afterStep`          |
+| Step/execution skip          | `withDryRun`, `withReplay`    | `wrapStep`                          |
+| Safe parallel isolation      | `withAtomicUpdates`           | `wrapParallelFn` (via core reducer) |
+| Human-in-the-loop / approval | `withInterrupts`              | `then()` + `InterruptError`         |
+| Message passing              | `withChannels`                | `beforeFlow`                        |
+| Infinite-loop protection     | `withCycles`, `withStepLimit` | `afterStep` / `beforeStep`          |
+| Cleanup / teardown           | custom                        | `afterFlow`                         |
 
 See [examples/observePlugin.ts](examples/observePlugin.ts) and [examples/persistPlugin.ts](examples/persistPlugin.ts) for complete implementations.
 
@@ -380,15 +536,82 @@ const orchestrator = new FlowBuilder<AnalysisState>()
 
 All three sub-agents share the same `shared` object and run concurrently. Avoid writing to the same key from parallel sub-agents — writes are not synchronised.
 
+To eliminate race conditions entirely, pass a `reducer` as the third argument to `.parallel()`, or use `.parallelAtomic()` from [`withAtomicUpdates`](#withatomicupdates). Each sub-agent then operates on its own isolated draft and the reducer decides how to merge.
+
+### Iterative refinement with `label` + goto
+
+Use `label` / `→label` return values for reflection loops that don't need nesting:
+
+```typescript
+const reactAgent = new FlowBuilder<AgentState>()
+  .startWith(think)
+  .label("act")
+  .then(async (s) => {
+    const result = await callTool(s.toolCall);
+    s.observations.push(result);
+    s.done = await shouldStop(s);
+    if (!s.done) return "→act";
+  })
+  .then(formatOutput);
+```
+
+### Human-in-the-loop with `interruptIf`
+
+```typescript
+import { withInterrupts, InterruptError } from "flowneer/plugins/observability";
+FlowBuilder.use(withInterrupts);
+
+const flow = new FlowBuilder<DraftState>()
+  .startWith(generateDraft)
+  .interruptIf((s) => s.requiresApproval) // pauses here
+  .then(publishDraft);
+
+try {
+  await flow.run(state);
+} catch (err) {
+  if (err instanceof InterruptError) {
+    // err.savedShared holds state at the pause point
+    await showReviewUI(err.savedShared);
+  }
+}
+```
+
 ## Project structure
 
 ```
-Flowneer.ts       Core — FlowBuilder, FlowError, types (~380 lines)
-index.ts          Public exports
+Flowneer.ts              Core — FlowBuilder, FlowError, InterruptError, types
+index.ts                 Public exports
+plugins/
+  observability/
+    withHistory.ts       State snapshot history
+    withTiming.ts        Per-step wall-clock timing
+    withVerbose.ts       Stdout logging
+    withInterrupts.ts    Human-in-the-loop / approval gates
+  persistence/
+    withCheckpoint.ts    Post-step state saves
+    withAuditLog.ts      Immutable audit trail
+    withReplay.ts        Skip-to-step for crash recovery
+    withVersionedCheckpoint.ts  Diff-based versioned saves + resumeFrom
+  resilience/
+    withCircuitBreaker.ts
+    withFallback.ts
+    withTimeout.ts
+    withCycles.ts        Guard against infinite goto loops
+  llm/
+    withCostTracker.ts
+    withRateLimit.ts
+    withTokenBudget.ts
+  messaging/
+    withChannels.ts      Map-based message channels (sendTo / receiveFrom)
+  dev/
+    withDryRun.ts
+    withMocks.ts
+    withStepLimit.ts     Cap total step executions
+    withAtomicUpdates.ts parallelAtomic() shorthand
 examples/
-  assistantFlow.ts   Interactive LLM assistant with branching
-  observePlugin.ts   Tracing plugin example
-  persistPlugin.ts   Checkpoint plugin example
+  assistantFlow.ts       Interactive LLM assistant with branching
+  observePlugin.ts       Tracing plugin example
+  persistPlugin.ts       Checkpoint plugin example
 ```
 
 ## License

package/dist/index.d.ts

@@ -42,12 +42,18 @@ interface ParallelStep<S, P extends Record<string, unknown>> {
     retries: number;
     delaySec: number;
     timeoutMs: number;
+    reducer?: (shared: S, drafts: S[]) => void;
 }
-type Step<S, P extends Record<string, unknown>> = FnStep<S, P> | BranchStep<S, P> | LoopStep<S, P> | BatchStep<S, P> | ParallelStep<S, P>;
+interface LabelStep {
+    type: "label";
+    name: string;
+}
+type Step<S, P extends Record<string, unknown>> = FnStep<S, P> | BranchStep<S, P> | LoopStep<S, P> | BatchStep<S, P> | ParallelStep<S, P> | LabelStep;
 /** Metadata exposed to hooks — intentionally minimal to avoid coupling. */
 interface StepMeta {
     index: number;
     type: Step<any, any>["type"];
+    label?: string;
 }
 /** Lifecycle hooks that plugins can register. */
 interface FlowHooks<S = any, P extends Record<string, unknown> = Record<string, unknown>> {
@@ -61,6 +67,11 @@ interface FlowHooks<S = any, P extends Record<string, unknown> = Record<string,
      */
     wrapStep?: (meta: StepMeta, next: () => Promise<void>, shared: S, params: P) => Promise<void>;
     afterStep?: (meta: StepMeta, shared: S, params: P) => void | Promise<void>;
+    /**
+     * Wraps individual functions within a `.parallel()` step.
+     * `fnIndex` is the position within the fns array.
+     */
+    wrapParallelFn?: (meta: StepMeta, fnIndex: number, next: () => Promise<void>, shared: S, params: P) => Promise<void>;
     onError?: (meta: StepMeta, error: unknown, shared: S, params: P) => void;
     afterFlow?: (shared: S, params: P) => void | Promise<void>;
 }
@@ -82,6 +93,14 @@ declare class FlowError extends Error {
     readonly cause: unknown;
     constructor(step: string, cause: unknown);
 }
+/**
+ * Thrown by `interruptIf` to pause a flow.
+ * Catch this in your runner to save `savedShared` and resume later.
+ */
+declare class InterruptError extends Error {
+    readonly savedShared: unknown;
+    constructor(shared: unknown);
+}
 /**
  * Fluent builder for composable flows.
  *
@@ -119,8 +138,17 @@ declare class FlowBuilder<S = any, P extends Record<string, unknown> = Record<st
     /**
      * Append a parallel step.
      * Runs all `fns` concurrently against the same shared state.
+     *
+     * When `reducer` is provided each fn receives its own shallow clone of
+     * `shared`; after all fns complete the reducer merges the drafts back
+     * into the original shared object — preventing concurrent mutation races.
+     */
+    parallel(fns: NodeFn<S, P>[], options?: NodeOptions, reducer?: (shared: S, drafts: S[]) => void): this;
+    /**
+     * Insert a named label. Labels are no-op markers that can be jumped to
+     * from any `NodeFn` by returning `"→labelName"`.
      */
-    parallel(fns: NodeFn<S, P>[], options?: NodeOptions): this;
+    label(name: string): this;
     /** Execute the flow. */
     run(shared: S, params?: P, options?: RunOptions): Promise<void>;
     protected _execute(shared: S, params: P, signal?: AbortSignal): Promise<void>;
@@ -130,4 +158,4 @@ declare class FlowBuilder<S = any, P extends Record<string, unknown> = Record<st
     private _withTimeout;
 }
 
-export { FlowBuilder, FlowError, type FlowHooks, type FlowneerPlugin, type NodeFn, type NodeOptions, type RunOptions, type StepMeta };
+export { FlowBuilder, FlowError, type FlowHooks, type FlowneerPlugin, InterruptError, type NodeFn, type NodeOptions, type RunOptions, type StepMeta };

package/dist/index.js

@@ -11,6 +11,14 @@ var FlowError = class extends Error {
     this.cause = cause;
   }
 };
+var InterruptError = class extends Error {
+  savedShared;
+  constructor(shared) {
+    super("Flow interrupted");
+    this.name = "InterruptError";
+    this.savedShared = shared;
+  }
+};
 var FlowBuilder = class _FlowBuilder {
   steps = [];
   _hooksList = [];
@@ -78,10 +86,29 @@ var FlowBuilder = class _FlowBuilder {
   /**
    * Append a parallel step.
    * Runs all `fns` concurrently against the same shared state.
+   *
+   * When `reducer` is provided each fn receives its own shallow clone of
+   * `shared`; after all fns complete the reducer merges the drafts back
+   * into the original shared object — preventing concurrent mutation races.
    */
-  parallel(fns, options) {
+  parallel(fns, options, reducer) {
     const { retries = 1, delaySec = 0, timeoutMs = 0 } = options ?? {};
-    this.steps.push({ type: "parallel", fns, retries, delaySec, timeoutMs });
+    this.steps.push({
+      type: "parallel",
+      fns,
+      retries,
+      delaySec,
+      timeoutMs,
+      reducer
+    });
+    return this;
+  }
+  /**
+   * Insert a named label. Labels are no-op markers that can be jumped to
+   * from any `NodeFn` by returning `"→labelName"`.
+   */
+  label(name) {
+    this.steps.push({ type: "label", name });
     return this;
   }
   /** Execute the flow. */
@@ -98,22 +125,32 @@ var FlowBuilder = class _FlowBuilder {
   // Internal execution
   // -----------------------------------------------------------------------
   async _execute(shared, params, signal) {
+    const labels = /* @__PURE__ */ new Map();
+    for (let j = 0; j < this.steps.length; j++) {
+      const s = this.steps[j];
+      if (s.type === "label") labels.set(s.name, j);
+    }
     for (let i = 0; i < this.steps.length; i++) {
       signal?.throwIfAborted();
       const step = this.steps[i];
+      if (step.type === "label") continue;
       const meta = { index: i, type: step.type };
       try {
         for (const h of this._hooksList)
           await h.beforeStep?.(meta, shared, params);
+        let gotoTarget;
         const runBody = async () => {
           switch (step.type) {
-            case "fn":
-              await this._retry(
+            case "fn": {
+              const result = await this._retry(
                 step.retries,
                 step.delaySec,
                 () => step.fn(shared, params)
               );
+              if (typeof result === "string" && result.startsWith("\u2192"))
+                gotoTarget = result.slice(1);
               break;
+            }
             case "branch": {
               const action = await this._retry(
                 step.retries,
@@ -122,12 +159,15 @@ var FlowBuilder = class _FlowBuilder {
               );
               const key = action ? String(action) : "default";
               const fn = step.branches[key] ?? step.branches["default"];
-              if (fn)
-                await this._retry(
+              if (fn) {
+                const branchResult = await this._retry(
                   step.retries,
                   step.delaySec,
                   () => fn(shared, params)
                 );
+                if (typeof branchResult === "string" && branchResult.startsWith("\u2192"))
+                  gotoTarget = branchResult.slice(1);
+              }
               break;
             }
             case "loop":
@@ -151,17 +191,49 @@ var FlowBuilder = class _FlowBuilder {
               else shared.__batchItem = prev;
               break;
             }
-            case "parallel":
-              await Promise.all(
-                step.fns.map(
-                  (fn) => this._retry(
-                    step.retries,
-                    step.delaySec,
-                    () => fn(shared, params)
-                  )
-                )
-              );
+            case "parallel": {
+              const pfnWrappers = this._hooksList.map((h) => h.wrapParallelFn).filter((w) => w != null);
+              if (step.reducer) {
+                const drafts = [];
+                await Promise.all(
+                  step.fns.map(async (fn, fi) => {
+                    const draft = { ...shared };
+                    drafts[fi] = draft;
+                    const exec = () => this._retry(
+                      step.retries,
+                      step.delaySec,
+                      () => fn(draft, params)
+                    );
+                    const wrapped2 = pfnWrappers.reduceRight(
+                      (next, wrap) => () => wrap(meta, fi, next, draft, params),
+                      async () => {
+                        await exec();
+                      }
+                    );
+                    await wrapped2();
+                  })
+                );
+                step.reducer(shared, drafts);
+              } else {
+                await Promise.all(
+                  step.fns.map((fn, fi) => {
+                    const exec = () => this._retry(
+                      step.retries,
+                      step.delaySec,
+                      () => fn(shared, params)
+                    );
+                    const wrapped2 = pfnWrappers.reduceRight(
+                      (next, wrap) => () => wrap(meta, fi, next, shared, params),
+                      async () => {
+                        await exec();
+                      }
+                    );
+                    return wrapped2();
+                  })
+                );
+              }
               break;
+            }
           }
         };
         const { timeoutMs } = step;
@@ -174,11 +246,18 @@ var FlowBuilder = class _FlowBuilder {
         await wrapped();
         for (const h of this._hooksList)
           await h.afterStep?.(meta, shared, params);
+        if (gotoTarget) {
+          const target = labels.get(gotoTarget);
+          if (target === void 0)
+            throw new Error(`goto target label "${gotoTarget}" not found`);
+          i = target;
+        }
       } catch (err) {
+        if (err instanceof InterruptError) throw err;
         for (const h of this._hooksList) h.onError?.(meta, err, shared, params);
         if (err instanceof FlowError) throw err;
-        const label = step.type === "fn" ? `step ${i}` : `${step.type} (step ${i})`;
-        throw new FlowError(label, err);
+        const stepLabel = step.type === "fn" ? `step ${i}` : `${step.type} (step ${i})`;
+        throw new FlowError(stepLabel, err);
       }
     }
   }
@@ -214,5 +293,6 @@ var FlowBuilder = class _FlowBuilder {
 };
 export {
   FlowBuilder,
-  FlowError
+  FlowError,
+  InterruptError
 };

package/dist/plugins/dev/index.d.ts

@@ -22,4 +22,24 @@ declare module "../../Flowneer" {
 }
 declare const withMocks: FlowneerPlugin;
 
-export { withDryRun, withMocks };
+declare module "../../Flowneer" {
+    interface FlowBuilder<S, P> {
+        /** Throw if total step executions exceed `max` (default 1000). */
+        withStepLimit(max?: number): this;
+    }
+}
+declare const withStepLimit: FlowneerPlugin;
+
+declare module "../../Flowneer" {
+    interface FlowBuilder<S, P> {
+        /**
+         * Safe parallel execution with a reducer.
+         * Each fn receives its own shallow draft of `shared`.
+         * After all fns complete, `reducer(shared, drafts)` merges results.
+         */
+        parallelAtomic(fns: NodeFn<S, P>[], reducer: (shared: S, drafts: S[]) => void, options?: NodeOptions): this;
+    }
+}
+declare const withAtomicUpdates: FlowneerPlugin;
+
+export { withAtomicUpdates, withDryRun, withMocks, withStepLimit };

package/dist/plugins/dev/index.js

@@ -25,7 +25,33 @@ var withMocks = {
     return this;
   }
 };
+
+// plugins/dev/withStepLimit.ts
+var withStepLimit = {
+  withStepLimit(max = 1e3) {
+    let count = 0;
+    this._setHooks({
+      beforeFlow: () => {
+        count = 0;
+      },
+      beforeStep: () => {
+        if (++count > max)
+          throw new Error(`step limit exceeded: ${count} > ${max}`);
+      }
+    });
+    return this;
+  }
+};
+
+// plugins/dev/withAtomicUpdates.ts
+var withAtomicUpdates = {
+  parallelAtomic(fns, reducer, options) {
+    return this.parallel(fns, options, reducer);
+  }
+};
 export {
+  withAtomicUpdates,
   withDryRun,
-  withMocks
+  withMocks,
+  withStepLimit
 };

package/dist/plugins/index.d.ts

@@ -1,6 +1,7 @@
-export { withHistory, withTiming, withVerbose } from './observability/index.js';
-export { CircuitBreakerOptions, withCircuitBreaker, withFallback, withTimeout } from './resilience/index.js';
-export { AuditEntry, AuditLogStore, CheckpointStore, withAuditLog, withCheckpoint, withReplay } from './persistence/index.js';
+export { withHistory, withInterrupts, withTiming, withVerbose } from './observability/index.js';
+export { CircuitBreakerOptions, withCircuitBreaker, withCycles, withFallback, withTimeout } from './resilience/index.js';
+export { AuditEntry, AuditLogStore, CheckpointStore, VersionedCheckpointEntry, VersionedCheckpointStore, withAuditLog, withCheckpoint, withReplay, withVersionedCheckpoint } from './persistence/index.js';
 export { RateLimitOptions, withCostTracker, withRateLimit, withTokenBudget } from './llm/index.js';
-export { withDryRun, withMocks } from './dev/index.js';
+export { withAtomicUpdates, withDryRun, withMocks, withStepLimit } from './dev/index.js';
+export { StreamSubscriber, emit, peekChannel, receiveFrom, sendTo, withChannels, withStream } from './messaging/index.js';
 import '../index.js';

package/dist/plugins/index.js

@@ -50,14 +50,43 @@ var withVerbose = {
   }
 };
 
+// Flowneer.ts
+var InterruptError = class extends Error {
+  savedShared;
+  constructor(shared) {
+    super("Flow interrupted");
+    this.name = "InterruptError";
+    this.savedShared = shared;
+  }
+};
+
+// plugins/observability/withInterrupts.ts
+var withInterrupts = {
+  interruptIf(condition) {
+    const interruptFn = async (shared, params) => {
+      const shouldInterrupt = await condition(shared, params);
+      if (shouldInterrupt) {
+        throw new InterruptError(JSON.parse(JSON.stringify(shared)));
+      }
+    };
+    return this.then(interruptFn);
+  }
+};
+
 // plugins/resilience/withFallback.ts
 var withFallback = {
   withFallback(fn) {
     this._setHooks({
-      wrapStep: async (_meta, next, shared, params) => {
+      wrapStep: async (meta, next, shared, params) => {
         try {
           await next();
-        } catch {
+        } catch (e) {
+          shared.__fallbackError = {
+            stepIndex: meta.index,
+            stepType: meta.type,
+            message: e instanceof Error ? e.message : String(e),
+            stack: e instanceof Error ? e.stack : void 0
+          };
           await fn(shared, params);
         }
       }
@@ -103,15 +132,44 @@ var withCircuitBreaker = {
 var withTimeout = {
   withTimeout(ms) {
     this._setHooks({
-      wrapStep: (meta, next) => Promise.race([
-        next(),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error(`step ${meta.index} timed out after ${ms}ms`)),
-            ms
+      wrapStep: (meta, next) => {
+        let handle;
+        return Promise.race([
+          next().finally(() => clearTimeout(handle)),
+          new Promise(
+            (_, reject) => handle = setTimeout(
+              () => reject(
+                new Error(`step ${meta.index} timed out after ${ms}ms`)
+              ),
+              ms
+            )
           )
-        )
-      ])
+        ]);
+      }
+    });
+    return this;
+  }
+};
+
+// plugins/resilience/withCycles.ts
+var withCycles = {
+  withCycles(maxJumps = 100) {
+    let jumps = 0;
+    this._setHooks({
+      beforeFlow: () => {
+        jumps = 0;
+      },
+      beforeStep: (meta) => {
+        if (meta.type === "fn" || meta.type === "branch") {
+        }
+      },
+      afterStep: (_meta, shared) => {
+        jumps++;
+        if (jumps > maxJumps)
+          throw new Error(
+            `cycle limit exceeded: ${jumps} step executions > maxJumps(${maxJumps})`
+          );
+      }
     });
     return this;
   }
@@ -169,6 +227,68 @@ var withReplay = {
   }
 };
 
+// plugins/persistence/withVersionedCheckpoint.ts
+function diffObjects(prev, curr) {
+  const diff = {};
+  for (const key of Object.keys(curr)) {
+    if (JSON.stringify(prev[key]) !== JSON.stringify(curr[key])) {
+      diff[key] = curr[key];
+    }
+  }
+  for (const key of Object.keys(prev)) {
+    if (!(key in curr)) {
+      diff[key] = void 0;
+    }
+  }
+  return diff;
+}
+var versionCounter = 0;
+var withVersionedCheckpoint = {
+  withVersionedCheckpoint(store) {
+    let prevSnapshot = {};
+    let lastVersion = null;
+    this._setHooks({
+      beforeFlow: (shared) => {
+        prevSnapshot = JSON.parse(JSON.stringify(shared));
+        lastVersion = null;
+      },
+      afterStep: async (meta, shared) => {
+        const curr = JSON.parse(JSON.stringify(shared));
+        const diff = diffObjects(prevSnapshot, curr);
+        if (Object.keys(diff).length === 0) return;
+        const version = `v${++versionCounter}`;
+        const entry = {
+          version,
+          stepIndex: meta.index,
+          diff,
+          parentVersion: lastVersion,
+          timestamp: Date.now()
+        };
+        await store.save(entry);
+        lastVersion = version;
+        prevSnapshot = curr;
+      }
+    });
+    return this;
+  },
+  resumeFrom(version, store) {
+    let resolvedStep = null;
+    let resolved = false;
+    this._setHooks({
+      wrapStep: async (meta, next) => {
+        if (!resolved) {
+          const result = await store.resolve(version);
+          resolvedStep = result.stepIndex;
+          resolved = true;
+        }
+        if (resolvedStep !== null && meta.index <= resolvedStep) return;
+        await next();
+      }
+    });
+    return this;
+  }
+};
+
 // plugins/llm/withTokenBudget.ts
 var withTokenBudget = {
   withTokenBudget(limit) {
@@ -247,19 +367,104 @@ var withMocks = {
     return this;
   }
 };
+
+// plugins/dev/withStepLimit.ts
+var withStepLimit = {
+  withStepLimit(max = 1e3) {
+    let count = 0;
+    this._setHooks({
+      beforeFlow: () => {
+        count = 0;
+      },
+      beforeStep: () => {
+        if (++count > max)
+          throw new Error(`step limit exceeded: ${count} > ${max}`);
+      }
+    });
+    return this;
+  }
+};
+
+// plugins/dev/withAtomicUpdates.ts
+var withAtomicUpdates = {
+  parallelAtomic(fns, reducer, options) {
+    return this.parallel(fns, options, reducer);
+  }
+};
+
+// plugins/messaging/withChannels.ts
+function sendTo(shared, channel, message) {
+  const channels = shared.__channels ?? /* @__PURE__ */ new Map();
+  if (!shared.__channels) shared.__channels = channels;
+  const queue = channels.get(channel) ?? [];
+  if (!channels.has(channel)) channels.set(channel, queue);
+  queue.push(message);
+}
+function receiveFrom(shared, channel) {
+  const channels = shared.__channels;
+  if (!channels) return [];
+  const queue = channels.get(channel);
+  if (!queue || queue.length === 0) return [];
+  const messages = [...queue];
+  queue.length = 0;
+  return messages;
+}
+function peekChannel(shared, channel) {
+  const channels = shared.__channels;
+  if (!channels) return [];
+  return [...channels.get(channel) ?? []];
+}
+var withChannels = {
+  withChannels() {
+    this._setHooks({
+      beforeFlow: (shared) => {
+        if (!shared.__channels) {
+          shared.__channels = /* @__PURE__ */ new Map();
+        }
+      }
+    });
+    return this;
+  }
+};
+
+// plugins/messaging/withStream.ts
+var withStream = {
+  withStream(subscriber) {
+    this._setHooks({
+      beforeFlow: (shared) => {
+        shared.__stream = subscriber;
+      }
+    });
+    return this;
+  }
+};
+function emit(shared, chunk) {
+  shared.__stream?.(chunk);
+}
 export {
+  emit,
+  peekChannel,
+  receiveFrom,
+  sendTo,
+  withAtomicUpdates,
   withAuditLog,
+  withChannels,
   withCheckpoint,
   withCircuitBreaker,
   withCostTracker,
+  withCycles,
   withDryRun,
   withFallback,
   withHistory,
+  withInterrupts,
   withMocks,
   withRateLimit,
   withReplay,
+  withStepLimit,
+  withStream,
   withTimeout,
   withTiming,
   withTokenBudget,
-  withVerbose
+  withVerbose,
+  withVersionedCheckpoint
 };

package/dist/plugins/messaging/index.d.ts

@@ -0,0 +1,56 @@
+import { FlowneerPlugin } from '../../index.js';
+
+/** Send a message to a named channel on `shared.__channels`. */
+declare function sendTo<S extends Record<string, any>>(shared: S, channel: string, message: unknown): void;
+/** Receive (drain) all pending messages from a named channel. */
+declare function receiveFrom<T = unknown>(shared: Record<string, any>, channel: string): T[];
+/** Peek at pending messages without draining. */
+declare function peekChannel<T = unknown>(shared: Record<string, any>, channel: string): T[];
+declare module "../../Flowneer" {
+    interface FlowBuilder<S, P> {
+        /**
+         * Initialise a `Map`-based message channel system on `shared.__channels`.
+         * Nodes communicate via `sendTo(shared, ch, msg)` / `receiveFrom(shared, ch)`.
+         */
+        withChannels(): this;
+    }
+}
+declare const withChannels: FlowneerPlugin;
+
+/** Callback invoked each time a step calls `emit()`. */
+type StreamSubscriber<T = unknown> = (chunk: T) => void;
+declare module "../../Flowneer" {
+    interface FlowBuilder<S, P> {
+        /**
+         * Registers a streaming subscriber for this flow.
+         * Steps call `emit(shared, chunk)` to push data to the subscriber in real-time.
+         * The subscriber is stored on `shared.__stream` before the first step runs
+         * so it is automatically inherited by sub-flows (loop, batch, etc.).
+         *
+         * @example
+         * const flow = new FlowBuilder<MyState>()
+         *   .withStream((chunk) => console.log("[stream]", chunk))
+         *   // ...
+         *
+         * // Inside a step:
+         * emit(s, { type: "draft", content: s.draft });
+         */
+        withStream<T = unknown>(subscriber: StreamSubscriber<T>): this;
+    }
+}
+declare const withStream: FlowneerPlugin;
+/**
+ * Push a chunk to the subscriber registered via `.withStream()`.
+ * Safe to call unconditionally — silently no-ops when no subscriber is registered.
+ *
+ * @example
+ * async function refineDraft(s: MyState) {
+ *   // ... produce s.draft ...
+ *   emit(s, { type: "draft", round: s.round, content: s.draft });
+ * }
+ */
+declare function emit<T = unknown>(shared: {
+    __stream?: StreamSubscriber<T>;
+}, chunk: T): void;
+
+export { type StreamSubscriber, emit, peekChannel, receiveFrom, sendTo, withChannels, withStream };

package/dist/plugins/messaging/index.js

@@ -0,0 +1,57 @@
+// plugins/messaging/withChannels.ts
+function sendTo(shared, channel, message) {
+  const channels = shared.__channels ?? /* @__PURE__ */ new Map();
+  if (!shared.__channels) shared.__channels = channels;
+  const queue = channels.get(channel) ?? [];
+  if (!channels.has(channel)) channels.set(channel, queue);
+  queue.push(message);
+}
+function receiveFrom(shared, channel) {
+  const channels = shared.__channels;
+  if (!channels) return [];
+  const queue = channels.get(channel);
+  if (!queue || queue.length === 0) return [];
+  const messages = [...queue];
+  queue.length = 0;
+  return messages;
+}
+function peekChannel(shared, channel) {
+  const channels = shared.__channels;
+  if (!channels) return [];
+  return [...channels.get(channel) ?? []];
+}
+var withChannels = {
+  withChannels() {
+    this._setHooks({
+      beforeFlow: (shared) => {
+        if (!shared.__channels) {
+          shared.__channels = /* @__PURE__ */ new Map();
+        }
+      }
+    });
+    return this;
+  }
+};
+
+// plugins/messaging/withStream.ts
+var withStream = {
+  withStream(subscriber) {
+    this._setHooks({
+      beforeFlow: (shared) => {
+        shared.__stream = subscriber;
+      }
+    });
+    return this;
+  }
+};
+function emit(shared, chunk) {
+  shared.__stream?.(chunk);
+}
+export {
+  emit,
+  peekChannel,
+  receiveFrom,
+  sendTo,
+  withChannels,
+  withStream
+};

package/dist/plugins/observability/index.d.ts

@@ -27,4 +27,19 @@ declare module "../../Flowneer" {
 }
 declare const withVerbose: FlowneerPlugin;
 
-export { withHistory, withTiming, withVerbose };
+declare module "../../Flowneer" {
+    interface FlowBuilder<S, P> {
+        /**
+         * Insert an interrupt point.
+         * If `condition(shared, params)` returns true, the flow throws
+         * an `InterruptError` carrying a deep clone of `shared`.
+         *
+         * Catch `InterruptError` in your runner to implement human-in-the-loop,
+         * approval gates, or external-resume patterns.
+         */
+        interruptIf(condition: (shared: S, params: P) => boolean | Promise<boolean>): this;
+    }
+}
+declare const withInterrupts: FlowneerPlugin;
+
+export { withHistory, withInterrupts, withTiming, withVerbose };

package/dist/plugins/observability/index.js

@@ -49,8 +49,32 @@ var withVerbose = {
     return this;
   }
 };
+
+// Flowneer.ts
+var InterruptError = class extends Error {
+  savedShared;
+  constructor(shared) {
+    super("Flow interrupted");
+    this.name = "InterruptError";
+    this.savedShared = shared;
+  }
+};
+
+// plugins/observability/withInterrupts.ts
+var withInterrupts = {
+  interruptIf(condition) {
+    const interruptFn = async (shared, params) => {
+      const shouldInterrupt = await condition(shared, params);
+      if (shouldInterrupt) {
+        throw new InterruptError(JSON.parse(JSON.stringify(shared)));
+      }
+    };
+    return this.then(interruptFn);
+  }
+};
 export {
   withHistory,
+  withInterrupts,
   withTiming,
   withVerbose
 };

package/dist/plugins/persistence/index.d.ts

@@ -48,4 +48,40 @@ declare module "../../Flowneer" {
 }
 declare const withReplay: FlowneerPlugin;
 
-export { type AuditEntry, type AuditLogStore, type CheckpointStore, withAuditLog, withCheckpoint, withReplay };
+interface VersionedCheckpointEntry<S = any> {
+    version: string;
+    stepIndex: number;
+    /** JSON-serialisable diff — only keys that changed from the previous version. */
+    diff: Partial<S>;
+    parentVersion: string | null;
+    timestamp: number;
+}
+interface VersionedCheckpointStore<S = any> {
+    /** Save a versioned checkpoint. Implementation assigns version ids. */
+    save(entry: VersionedCheckpointEntry<S>): void | Promise<void>;
+    /** Resolve a version id to the full snapshot + step index. */
+    resolve(version: string): {
+        stepIndex: number;
+        snapshot: S;
+    } | Promise<{
+        stepIndex: number;
+        snapshot: S;
+    }>;
+}
+declare module "../../Flowneer" {
+    interface FlowBuilder<S, P> {
+        /**
+         * Save diff-based versioned checkpoints after each step.
+         * Each checkpoint records only the keys that changed, plus a parent pointer.
+         */
+        withVersionedCheckpoint(store: VersionedCheckpointStore<S>): this;
+        /**
+         * Resume execution from a previously saved version.
+         * Steps before the saved `stepIndex` are skipped.
+         */
+        resumeFrom(version: string, store: VersionedCheckpointStore<S>): this;
+    }
+}
+declare const withVersionedCheckpoint: FlowneerPlugin;
+
+export { type AuditEntry, type AuditLogStore, type CheckpointStore, type VersionedCheckpointEntry, type VersionedCheckpointStore, withAuditLog, withCheckpoint, withReplay, withVersionedCheckpoint };

package/dist/plugins/persistence/index.js

@@ -49,8 +49,71 @@ var withReplay = {
     return this;
   }
 };
+
+// plugins/persistence/withVersionedCheckpoint.ts
+function diffObjects(prev, curr) {
+  const diff = {};
+  for (const key of Object.keys(curr)) {
+    if (JSON.stringify(prev[key]) !== JSON.stringify(curr[key])) {
+      diff[key] = curr[key];
+    }
+  }
+  for (const key of Object.keys(prev)) {
+    if (!(key in curr)) {
+      diff[key] = void 0;
+    }
+  }
+  return diff;
+}
+var versionCounter = 0;
+var withVersionedCheckpoint = {
+  withVersionedCheckpoint(store) {
+    let prevSnapshot = {};
+    let lastVersion = null;
+    this._setHooks({
+      beforeFlow: (shared) => {
+        prevSnapshot = JSON.parse(JSON.stringify(shared));
+        lastVersion = null;
+      },
+      afterStep: async (meta, shared) => {
+        const curr = JSON.parse(JSON.stringify(shared));
+        const diff = diffObjects(prevSnapshot, curr);
+        if (Object.keys(diff).length === 0) return;
+        const version = `v${++versionCounter}`;
+        const entry = {
+          version,
+          stepIndex: meta.index,
+          diff,
+          parentVersion: lastVersion,
+          timestamp: Date.now()
+        };
+        await store.save(entry);
+        lastVersion = version;
+        prevSnapshot = curr;
+      }
+    });
+    return this;
+  },
+  resumeFrom(version, store) {
+    let resolvedStep = null;
+    let resolved = false;
+    this._setHooks({
+      wrapStep: async (meta, next) => {
+        if (!resolved) {
+          const result = await store.resolve(version);
+          resolvedStep = result.stepIndex;
+          resolved = true;
+        }
+        if (resolvedStep !== null && meta.index <= resolvedStep) return;
+        await next();
+      }
+    });
+    return this;
+  }
+};
 export {
   withAuditLog,
   withCheckpoint,
-  withReplay
+  withReplay,
+  withVersionedCheckpoint
 };

package/dist/plugins/resilience/index.d.ts

@@ -43,4 +43,16 @@ declare module "../../Flowneer" {
 }
 declare const withTimeout: FlowneerPlugin;
 
-export { type CircuitBreakerOptions, withCircuitBreaker, withFallback, withTimeout };
+declare module "../../Flowneer" {
+    interface FlowBuilder<S, P> {
+        /**
+         * Guard against infinite goto loops.
+         * Tracks total label jumps per `run()` and throws if `maxJumps` is exceeded.
+         * Default: 100.
+         */
+        withCycles(maxJumps?: number): this;
+    }
+}
+declare const withCycles: FlowneerPlugin;
+
+export { type CircuitBreakerOptions, withCircuitBreaker, withCycles, withFallback, withTimeout };

package/dist/plugins/resilience/index.js

@@ -2,10 +2,16 @@
 var withFallback = {
   withFallback(fn) {
     this._setHooks({
-      wrapStep: async (_meta, next, shared, params) => {
+      wrapStep: async (meta, next, shared, params) => {
         try {
           await next();
-        } catch {
+        } catch (e) {
+          shared.__fallbackError = {
+            stepIndex: meta.index,
+            stepType: meta.type,
+            message: e instanceof Error ? e.message : String(e),
+            stack: e instanceof Error ? e.stack : void 0
+          };
           await fn(shared, params);
         }
       }
@@ -51,21 +57,51 @@ var withCircuitBreaker = {
 var withTimeout = {
   withTimeout(ms) {
     this._setHooks({
-      wrapStep: (meta, next) => Promise.race([
-        next(),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error(`step ${meta.index} timed out after ${ms}ms`)),
-            ms
+      wrapStep: (meta, next) => {
+        let handle;
+        return Promise.race([
+          next().finally(() => clearTimeout(handle)),
+          new Promise(
+            (_, reject) => handle = setTimeout(
+              () => reject(
+                new Error(`step ${meta.index} timed out after ${ms}ms`)
+              ),
+              ms
+            )
           )
-        )
-      ])
+        ]);
+      }
+    });
+    return this;
+  }
+};
+
+// plugins/resilience/withCycles.ts
+var withCycles = {
+  withCycles(maxJumps = 100) {
+    let jumps = 0;
+    this._setHooks({
+      beforeFlow: () => {
+        jumps = 0;
+      },
+      beforeStep: (meta) => {
+        if (meta.type === "fn" || meta.type === "branch") {
+        }
+      },
+      afterStep: (_meta, shared) => {
+        jumps++;
+        if (jumps > maxJumps)
+          throw new Error(
+            `cycle limit exceeded: ${jumps} step executions > maxJumps(${maxJumps})`
+          );
+      }
     });
     return this;
   }
 };
 export {
   withCircuitBreaker,
+  withCycles,
   withFallback,
   withTimeout
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowneer",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Zero-dependency fluent flow builder for AI agents",
   "license": "MIT",
   "type": "module",
@@ -13,7 +13,8 @@
     "./plugins/resilience": "./dist/plugins/resilience/index.js",
     "./plugins/persistence": "./dist/plugins/persistence/index.js",
     "./plugins/llm": "./dist/plugins/llm/index.js",
-    "./plugins/dev": "./dist/plugins/dev/index.js"
+    "./plugins/dev": "./dist/plugins/dev/index.js",
+    "./plugins/messaging": "./dist/plugins/messaging/index.js"
   },
   "sideEffects": false,
   "files": [