@gesslar/actioneer 2.0.2 → 2.2.0

package/src/browser/lib/ActionRunner.js

@@ -1,4 +1,4 @@
-import {Promised, Data, Sass, Valid} from "@gesslar/toolkit"
+import {Promised, Data, Sass, Valid, Notify} from "@gesslar/toolkit"
 
 import {ACTIVITY} from "./Activity.js"
 import Piper from "./Piper.js"
@@ -7,10 +7,15 @@ import Piper from "./Piper.js"
  * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
  */
 
+/**
+ * @typedef {import("./ActionBuilder.js").default} ActionBuilder
+ */
+
 /**
  * @typedef {object} ActionRunnerOptions
  * @property {DebugFn} [debug] Logger function.
  */
+
 /**
  * Orchestrates execution of {@link ActionBuilder}-produced pipelines.
  *
@@ -31,6 +36,13 @@ export default class ActionRunner extends Piper {
    */
   #debug = () => {}
 
+  /**
+   * Event emitter for cross-runner communication (BREAK/CONTINUE signals).
+   *
+   * @type {typeof Notify}
+   */
+  #notify = Notify
+
   /**
    * Instantiate a runner over an optional action wrapper.
    *
@@ -58,108 +70,146 @@ export default class ActionRunner extends Piper {
   /**
    * Executes the configured action pipeline.
    * Builds the ActionWrapper on first run and caches it for subsequent calls.
-   * Supports WHILE, UNTIL, and SPLIT activity kinds.
+   * Supports WHILE, UNTIL, IF, SPLIT, BREAK, and CONTINUE activity kinds.
    *
    * @param {unknown} context - Seed value passed to the first activity.
+   * @param {import("./ActionWrapper.js").default|null} [parentWrapper] - Parent wrapper for BREAK/CONTINUE signaling.
    * @returns {Promise<unknown>} Final value produced by the pipeline.
    * @throws {Sass} When no activities are registered, conflicting activity kinds are used, or execution fails.
    */
-  async run(context) {
+  async run(context, parentWrapper=null) {
     if(!this.#actionWrapper)
       this.#actionWrapper = await this.#actionBuilder.build()
 
     const actionWrapper = this.#actionWrapper
-    const activities = actionWrapper.activities
-
-    for(const activity of activities) {
-      try {
-        // await timeout(500)
-
-        const kind = activity.kind
-
-        // If we have no kind, then it's just a once.
-        // Get it over and done with!
-        if(!kind) {
-          context = await this.#execute(activity, context)
-        } else {
-          // Validate that only one activity kind bit is set
-          // (kind & (kind - 1)) !== 0 means multiple bits are set
-          const multipleBitsSet = (kind & (kind - 1)) !== 0
-          if(multipleBitsSet)
-            throw Sass.new(
-              "For Kathy Griffin's sake! You can't combine activity kinds. " +
-              "Pick one: WHILE, UNTIL, or SPLIT!"
-            )
-
-          const {WHILE,UNTIL,SPLIT} = ACTIVITY
-          const kindWhile = kind & WHILE
-          const kindUntil = kind & UNTIL
-          const kindSplit = kind & SPLIT
-
-          if(kindWhile || kindUntil) {
-            const predicate = activity.pred
-
-            for(;;) {
-
-              if(kindWhile)
-                if(!await this.#hasPredicate(activity,predicate,context))
+    const activities = Array.from(actionWrapper.activities)
+
+    try {
+      for(
+        let cursor = 0, max = activities.length;
+        cursor < max && cursor !== -1;
+        cursor++
+      ) {
+        const activity = activities[cursor]
+
+        try {
+          const kind = activity.kind
+
+          // If we have no kind, then it's just a once.
+          // Get it over and done with!
+          if(!kind) {
+            context = await this.#execute(activity, context)
+          } else {
+            const {UNTIL, WHILE, IF, SPLIT, BREAK, CONTINUE} = ACTIVITY
+            const kindUntil = kind === UNTIL
+            const kindWhile = kind === WHILE
+            const kindIf = kind === IF
+            const kindSplit = kind === SPLIT
+            const kindBreak = kind === BREAK
+            const kindContinue = kind === CONTINUE
+
+            if(kindBreak || kindContinue) {
+              if(!parentWrapper)
+                throw Sass.new(`Invalid use of control flow outside of context.`)
+
+              if(await this.#evalPredicate(activity, context)) {
+                if(kindBreak) {
+                  this.#notify.emit("loop.break", parentWrapper)
                   break
-
-              context = await this.#execute(activity,context)
-
-              if(kindUntil)
-                if(await this.#hasPredicate(activity,predicate,context))
+                }
+
+                if(kindContinue)
+                  cursor = max
+              }
+            } else if(kindIf) {
+              if(await this.#evalPredicate(activity, context))
+                context = await this.#execute(activity, context)
+            } else if(kindWhile || kindUntil) {
+              // Simple if, no loop, only gainz.
+              for(;;) {
+                if(kindWhile)
+                  if(!await this.#evalPredicate(activity, context))
+                    break
+
+                let weWereOnABreak = false
+                const breakReceiver = this.#notify.on("loop.break", wrapper => {
+                  if(wrapper.id === actionWrapper.id) {
+                    weWereOnABreak = true
+                  }
+                })
+                context = await this.#execute(activity, context)
+                breakReceiver()
+                if(weWereOnABreak)
                   break
-            }
-          } else if(kindSplit) {
-            // SPLIT activity: parallel execution with splitter/rejoiner
-            // pattern
-            const {splitter, rejoiner} = activity
-
-            if(!splitter || !rejoiner)
-              throw Sass.new(
-                `SPLIT activity "${String(activity.name)}" requires both ` +
-                `splitter and rejoiner functions.`
+
+                if(kindUntil)
+                  if(await this.#evalPredicate(activity, context))
+                    break
+              }
+            } else if(kindSplit) {
+              // SPLIT activity: parallel execution with splitter/rejoiner
+              // pattern
+              const {splitter, rejoiner} = activity
+
+              if(!splitter || !rejoiner)
+                throw Sass.new(
+                  `SPLIT activity "${String(activity.name)}" requires both ` +
+                  `splitter and rejoiner functions.`
+                )
+
+              const original = context
+              const splitContexts = await splitter.call(
+                activity.action,
+                context
               )
 
-            const original = context
-            const splitContexts = await splitter.call(activity.action, context)
+              let settled
 
-            let settled
+              if(activity.opKind === "ActionBuilder") {
+                if(activity.action)
+                  activity.op.withAction(activity.action)
 
-            if(activity.opKind === "ActionBuilder") {
-              if(activity.action)
-                activity.op.withAction(activity.action)
+                if(activity.hooks)
+                  activity.op.withHooks(activity.hooks)
 
-              if(activity.hooks)
-                activity.op.withHooks(activity.hooks)
+                const runner = new this.constructor(activity.op, {
+                  debug: this.#debug, name: activity.name
+                })
 
-              const runner = new this.constructor(activity.op, {
-                debug: this.#debug, name: activity.name
-              })
+                settled = await runner.pipe(splitContexts)
+              } else {
+                // For plain functions, process each split context
+                settled = await Promised.settle(
+                  splitContexts.map(ctx => this.#execute(activity, ctx))
+                )
+              }
 
-              // pipe() returns settled results with concurrency control
-              settled = await runner.pipe(splitContexts)
-            } else {
-              // For plain functions, process each split context
-              settled = await Promised.settle(
-                splitContexts.map(ctx => this.#execute(activity, ctx))
+              const rejoined = await rejoiner.call(
+                activity.action,
+                original,
+                settled
               )
-            }
-
-            const rejoined = await rejoiner.call(
-              activity.action,
-              original,
-              settled
-            )
 
-            context = rejoined
-          } else {
-            context = await this.#execute(activity, context)
+              context = rejoined
+            } else {
+              context = await this.#execute(activity, context)
+            }
           }
+        } catch(error) {
+          throw Sass.new("ActionRunner running activity", error)
+        }
+      }
+    } finally {
+      // Execute done callback if registered - always runs, even on error
+      // Only run for top-level pipelines, not nested builders (inside loops)
+      if(actionWrapper.done && !parentWrapper) {
+        try {
+          context = await actionWrapper.done.call(
+            actionWrapper.action, context
+          )
+        } catch(error) {
+          throw Sass.new("ActionRunner running done callback", error)
         }
-      } catch(error) {
-        throw Sass.new("ActionRunner running activity", error)
       }
     }
 
@@ -201,11 +251,11 @@ export default class ActionRunner extends Piper {
       if(parallel) {
         return await runner.pipe(context)
       } else {
-        return await runner.run(context)
+        return await runner.run(context, activity.wrapper)
       }
     } else if(opKind === "Function") {
       try {
-        const result = await activity.run(context)
+        const result = await activity.run(context, activity.wrapper)
 
         if(Data.isType(result, "ActionBuilder")) {
           if(activity.action)
@@ -221,7 +271,7 @@ export default class ActionRunner extends Piper {
           if(parallel) {
             return await runner.pipe(context)
           } else {
-            return await runner.run(context)
+            return await runner.run(context, activity.wrapper)
           }
         } else {
           return result
@@ -237,18 +287,17 @@ export default class ActionRunner extends Piper {
   }
 
   /**
-   * Evaluate the predicate for WHILE/UNTIL activity kinds.
+   * Evaluate the predicate for WHILE/UNTIL/IF/BREAK/CONTINUE activity kinds.
    *
    * @param {import("./Activity.js").default} activity Activity currently executing.
-   * @param {(context: unknown) => boolean|Promise<boolean>} predicate Predicate to evaluate.
    * @param {unknown} context Current pipeline context.
-   * @returns {Promise<boolean>} True when the predicate allows another iteration.
+   * @returns {Promise<boolean>} True when the predicate condition is met.
    * @private
    */
-  async #hasPredicate(activity,predicate,context) {
-    Valid.type(predicate, "Function")
+  async #evalPredicate(activity, context) {
+    Valid.type(activity?.pred, "Function")
 
-    return !!(await predicate.call(activity.action, context))
+    return !!(await activity.pred.call(activity.action, context))
   }
 
   toString() {

package/src/browser/lib/ActionWrapper.js

@@ -11,7 +11,7 @@ import Activity from "./Activity.js"
  */
 
 /**
- * @typedef {Generator<Activity, void, unknown>} ActivityIterator
+ * @typedef {import("@gesslar/toolkit").Generator<Activity, void, unknown>} ActivityIterator
  */
 
 /**
@@ -24,6 +24,7 @@ export default class ActionWrapper {
    * @type {Map<string|symbol, WrappedActivityConfig>}
    */
   #activities = new Map()
+
   /**
    * Logger invoked for wrapper lifecycle events.
    *
@@ -31,17 +32,37 @@ export default class ActionWrapper {
    */
   #debug = () => {}
 
+  /** @type {import("./ActionHooks.js").default|null} */
   #hooks = null
+  /** @type {((context: unknown) => unknown|Promise<unknown>)|null} */
+  #done = null
+  /** @type {unknown} */
+  #action = null
+  /** @type {symbol} */
+  #id = Symbol(performance.now())
 
   /**
    * Create a wrapper from the builder payload.
    *
    * @param {{activities: Map<string|symbol, WrappedActivityConfig>, debug: (message: string, level?: number, ...args: Array<unknown>) => void}} init Builder payload containing activities + logger.
    */
-  constructor({activities,hooks,debug}) {
+  constructor({activities,hooks,debug,done: doneCallback,action}) {
     this.#debug = debug
     this.#hooks = hooks
-    this.#activities = activities
+    this.#done = doneCallback
+    this.#action = action
+
+    for(const [key, value] of activities) {
+      this.#activities.set(
+        key,
+        new Activity({
+          ...value,
+          hooks: this.#hooks,
+          wrapper: this
+        })
+      )
+    }
+
     this.#debug(
       "Instantiating ActionWrapper with %o activities.",
       2,
@@ -49,17 +70,40 @@ export default class ActionWrapper {
     )
   }
 
-  *#_activities() {
-    for(const [,activity] of this.#activities)
-      yield new Activity({...activity, hooks: this.#hooks})
+  /**
+   * Unique identifier for this wrapper instance.
+   * Used by BREAK/CONTINUE to match events to the correct loop.
+   *
+   * @returns {symbol} Unique symbol identifier
+   */
+  get id() {
+    return this.#id
   }
 
   /**
    * Iterator over the registered activities.
    *
-   * @returns {ActivityIterator} Lazy iterator yielding Activity instances.
+   * @returns {Iterator<Activity>} Iterator yielding Activity instances.
    */
   get activities() {
-    return this.#_activities()
+    return this.#activities.values()
+  }
+
+  /**
+   * Get the done callback if registered.
+   *
+   * @returns {((context: unknown) => unknown|Promise<unknown>)|null} Done callback or null.
+   */
+  get done() {
+    return this.#done
+  }
+
+  /**
+   * Get the action instance.
+   *
+   * @returns {unknown|null} Action instance or null.
+   */
+  get action() {
+    return this.#action
   }
 }

package/src/browser/lib/Activity.js

@@ -8,14 +8,20 @@ import {Data} from "@gesslar/toolkit"
  *
  * @readonly
  * @enum {number}
- * @property {number} WHILE - Execute activity while predicate returns true (2)
- * @property {number} UNTIL - Execute activity until predicate returns true (4)
- * @property {number} SPLIT - Execute activity with split/rejoin pattern for parallel execution (8)
+ * @property {number} WHILE - Execute activity while predicate returns true 1
+ * @property {number} UNTIL - Execute activity until predicate returns true 2
+ * @property {number} SPLIT - Execute activity with split/rejoin pattern for parallel execution 3
+ * @property {number} IF - Execute activity if predicate returns true 4
+ * @property {number} BREAK - Break out of a WHILE/UNTIL if predicate returns true 5
+ * @property {number} CONTINUE - Returns to the top of a WHILE/UNTIL if predicate returns true 6
  */
 export const ACTIVITY = Object.freeze({
-  WHILE: 1<<1,
-  UNTIL: 1<<2,
-  SPLIT: 1<<3,
+  WHILE: 1,
+  UNTIL: 2,
+  SPLIT: 3,
+  IF: 4,
+  BREAK: 5,
+  CONTINUE: 6,
 })
 
 export default class Activity {
@@ -37,6 +43,10 @@ export default class Activity {
   #rejoiner = null
   /** @type {((context: unknown) => unknown)|null} */
   #splitter = null
+  /** @type {import("./ActionWrapper.js").default|null} */
+  #wrapper = null
+  /** @type {symbol} */
+  #id = Symbol(performance.now())
 
   /**
    * Construct an Activity definition wrapper.
@@ -50,8 +60,9 @@ export default class Activity {
    * @param {ActionHooks} [init.hooks] - Optional hooks instance
    * @param {(context: unknown) => unknown} [init.splitter] - Optional splitter function for SPLIT activities
    * @param {(originalContext: unknown, splitResults: unknown) => unknown} [init.rejoiner] - Optional rejoiner function for SPLIT activities
+   * @param {import("./ActionWrapper.js").default} [init.wrapper] - Optional wrapper containing this activity
    */
-  constructor({action,name,op,kind,pred,hooks,splitter,rejoiner}) {
+  constructor({action,name,op,kind,pred,hooks,splitter,rejoiner,wrapper}) {
     this.#action = action
     this.#hooks = hooks
     this.#kind = kind
@@ -60,6 +71,16 @@ export default class Activity {
     this.#pred = pred
     this.#rejoiner = rejoiner
     this.#splitter = splitter
+    this.#wrapper = wrapper ?? null
+  }
+
+  /**
+   * Unique identifier for this activity instance.
+   *
+   * @returns {symbol} Unique symbol identifier
+   */
+  get id() {
+    return this.#id
   }
 
   /**
@@ -81,7 +102,7 @@ export default class Activity {
   }
 
   /**
-   * The predicate function for WHILE/UNTIL flows.
+   * The predicate function for WHILE/UNTIL/IF flows.
    *
    * @returns {(context: unknown) => boolean|Promise<boolean>|undefined} - Predicate used to continue/stop loops
    */
@@ -143,6 +164,16 @@ export default class Activity {
     return this.#action
   }
 
+  /**
+   * Get the ActionWrapper containing this activity.
+   * Used by BREAK/CONTINUE to signal the parent loop.
+   *
+   * @returns {import("./ActionWrapper.js").default|null} The wrapper or null
+   */
+  get wrapper() {
+    return this.#wrapper ?? null
+  }
+
   /**
    * Execute the activity with before/after hooks.
    *

package/src/browser/lib/Piper.js

@@ -109,7 +109,7 @@ export default class Piper {
     }
 
     const setupResult = await Promised.settle(
-      [...this.#lifeCycle.get("setup")].map(e => e())
+      [...this.#lifeCycle.get("setup")].map(e => Promise.resolve(e()))
     )
 
     this.#processResult("Setting up the pipeline.", setupResult)
@@ -127,7 +127,7 @@ export default class Piper {
     } finally {
       // Run cleanup hooks
       const teardownResult = await Promised.settle(
-        [...this.#lifeCycle.get("teardown")].map(e => e())
+        [...this.#lifeCycle.get("teardown")].map(e => Promise.resolve(e()))
       )
 
       this.#processResult("Tearing down the pipeline.", teardownResult)

package/src/lib/ActionHooks.js

@@ -41,6 +41,14 @@ export default class ActionHooks extends BrowserActionHooks {
     return this.#hooksFile
   }
 
+  /**
+   * @typedef {object} ActionHooksConfig
+   * @property {string} [hooksFile] Path to the hooks file
+   * @property {string} [hooksKind] Name of the hooks class to instantiate
+   * @property {object} [hooks] Pre-instantiated hooks object
+   * @property {number} [timeout] Timeout for hook execution
+   */
+
   /**
    * Static factory method to create and initialize a hook manager.
    * Loads hooks from the specified file and returns an initialized instance.

package/src/types/browser/lib/ActionBuilder.d.ts

@@ -58,9 +58,10 @@ export default class ActionBuilder {
      * Register an activity that the runner can execute.
      *
      * Overloads:
-     * - do(name, op)
-     * - do(name, kind, pred, opOrWrapper)
-     * - do(name, kind, splitter, rejoiner, opOrWrapper)
+     * - do(name, op) - Simple once-off activity
+     * - do(name, kind, pred) - BREAK/CONTINUE control flow (no op, just predicate)
+     * - do(name, kind, pred, opOrWrapper) - WHILE/UNTIL/IF with predicate and operation
+     * - do(name, kind, splitter, rejoiner, opOrWrapper) - SPLIT with parallel execution
      *
      * @overload
      * @param {string|symbol} name Activity name
@@ -71,22 +72,30 @@ export default class ActionBuilder {
     /**
      * @overload
      * @param {string|symbol} name Activity name
-     * @param {number} kind Kind bitfield from {@link ActivityFlags}.
+     * @param {number} kind ACTIVITY.BREAK or ACTIVITY.CONTINUE flag.
+     * @param {(context: unknown) => boolean|Promise<boolean>} pred Predicate to evaluate for control flow.
+     * @returns {ActionBuilder}
+     */
+    do(name: string | symbol, kind: number, pred: (context: unknown) => boolean | Promise<boolean>): ActionBuilder;
+    /**
+     * @overload
+     * @param {string|symbol} name Activity name
+     * @param {number} kind Activity kind (WHILE, UNTIL, or IF) from {@link ActivityFlags}.
      * @param {(context: unknown) => boolean|Promise<boolean>} pred Predicate executed before/after the op.
-     * @param {ActionFunction|import("./ActionWrapper.js").default} op Operation or nested wrapper to execute.
+     * @param {ActionFunction|ActionBuilder} op Operation or nested builder to execute.
      * @returns {ActionBuilder}
      */
-    do(name: string | symbol, kind: number, pred: (context: unknown) => boolean | Promise<boolean>, op: ActionFunction | import("./ActionWrapper.js").default): ActionBuilder;
+    do(name: string | symbol, kind: number, pred: (context: unknown) => boolean | Promise<boolean>, op: ActionFunction | ActionBuilder): ActionBuilder;
     /**
      * @overload
      * @param {string|symbol} name Activity name
      * @param {number} kind ACTIVITY.SPLIT flag.
      * @param {(context: unknown) => unknown} splitter Splitter function for SPLIT mode.
      * @param {(originalContext: unknown, splitResults: unknown) => unknown} rejoiner Rejoiner function for SPLIT mode.
-     * @param {ActionFunction|import("./ActionWrapper.js").default} op Operation or nested wrapper to execute.
+     * @param {ActionFunction|ActionBuilder} op Operation or nested builder to execute.
      * @returns {ActionBuilder}
      */
-    do(name: string | symbol, kind: number, splitter: (context: unknown) => unknown, rejoiner: (originalContext: unknown, splitResults: unknown) => unknown, op: ActionFunction | import("./ActionWrapper.js").default): ActionBuilder;
+    do(name: string | symbol, kind: number, splitter: (context: unknown) => unknown, rejoiner: (originalContext: unknown, splitResults: unknown) => unknown, op: ActionFunction | ActionBuilder): ActionBuilder;
     /**
      * Configure hooks to be loaded from a file when the action is built.
      *
@@ -112,6 +121,13 @@ export default class ActionBuilder {
      * @returns {ActionBuilder} The builder instance for chaining.
      */
     withAction(action: ActionBuilderAction): ActionBuilder;
+    /**
+     * Register a callback to be executed after all activities complete.
+     *
+     * @param {ActionFunction} callback Function to execute at the end of the pipeline.
+     * @returns {ActionBuilder} The builder instance for chaining.
+     */
+    done(callback: ActionFunction): ActionBuilder;
     /**
      * Finalises the builder and returns a payload that can be consumed by the
      * runner.

package/src/types/browser/lib/ActionBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionBuilder.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionBuilder.js"],"names":[],"mappings":"AAMA,kEAAkE;AAClE,uEAAuE;AAEvE;;GAEG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAaE;;;;;OAKG;IACH,qBAHW,mBAAmB,mBACnB,mBAAmB,EAe7B;IAED,yBAEC;;;;;;;;;;;;;;IAUE,SACQ,MAAM,GAAC,MAAM,MACb,cAAc,GACZ,aAAa,CACzB;;;;;;;;;IAGE,SACQ,MAAM,GAAC,MAAM,QACb,MAAM,QACN,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,MAC9C,cAAc,GAAC,OAAO,oBAAoB,EAAE,OAAO,GACjD,aAAa,CACzB;;;;;;;;;;IAGE,SACQ,MAAM,GAAC,MAAM,QACb,MAAM,YACN,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,YAC7B,CAAC,eAAe,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,KAAK,OAAO,MAC5D,cAAc,GAAC,OAAO,oBAAoB,EAAE,OAAO,GACjD,aAAa,CACzB;IA0DD;;;;;;;OAOG;IACH,yBALW,MAAM,aACN,MAAM,GACJ,aAAa,CAYzB;IAED;;;;;;OAMG;IACH,iBAJW,OAAO,kBAAkB,EAAE,OAAO,GAChC,aAAa,CAgBzB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,aAAa,CAczB;IAeD;;;;;OAKG;IACH,SAFa,OAAO,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAmBzD;;CAqBF;2BA3Sa,OAAO,mBAAmB,EAAE,OAAO;4BACnC,cAAc,eAAe,EAAE,QAAQ;sBAGxC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;WAKjE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;YAYhC,mBAAmB,GAAC,IAAI;;;;WACxB,OAAO,GAAC,IAAI;;;;UACZ,MAAM,GAAC,MAAM;;;;QACb,cAAc,GAAC,OAAO,oBAAoB,EAAE,OAAO;;;;;;;;sBAEzC,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC;;6BAI/C,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC"}
+{"version":3,"file":"ActionBuilder.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionBuilder.js"],"names":[],"mappings":"AAMA,kEAAkE;AAClE,uEAAuE;AAEvE;;GAEG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBE;;;;;OAKG;IACH,qBAHW,mBAAmB,mBACnB,mBAAmB,EAe7B;IAED,yBAEC;;;;;;;;;;;;;;;IAWE,SACQ,MAAM,GAAC,MAAM,MACb,cAAc,GACZ,aAAa,CACzB;;;;;;;;IAGE,SACQ,MAAM,GAAC,MAAM,QACb,MAAM,QACN,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,GAC5C,aAAa,CACzB;;;;;;;;;IAGE,SACQ,MAAM,GAAC,MAAM,QACb,MAAM,QACN,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,MAC9C,cAAc,GAAC,aAAa,GAC1B,aAAa,CACzB;;;;;;;;;;IAGE,SACQ,MAAM,GAAC,MAAM,QACb,MAAM,YACN,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,YAC7B,CAAC,eAAe,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,KAAK,OAAO,MAC5D,cAAc,GAAC,aAAa,GAC1B,aAAa,CACzB;IAkED;;;;;;;OAOG;IACH,yBALW,MAAM,aACN,MAAM,GACJ,aAAa,CAYzB;IAED;;;;;;OAMG;IACH,iBAJW,OAAO,kBAAkB,EAAE,OAAO,GAChC,aAAa,CAgBzB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,aAAa,CAczB;IAED;;;;;OAKG;IACH,eAHW,cAAc,GACZ,aAAa,CAOzB;IAeD;;;;;OAKG;IACH,SAFa,OAAO,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAqBzD;;CAqBF;2BAhVa,OAAO,mBAAmB,EAAE,OAAO;4BACnC,cAAc,eAAe,EAAE,QAAQ;sBAGxC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;WAKjE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;YAYhC,mBAAmB,GAAC,IAAI;;;;WACxB,OAAO,GAAC,IAAI;;;;UACZ,MAAM,GAAC,MAAM;;;;QACb,cAAc,GAAC,OAAO,oBAAoB,EAAE,OAAO;;;;;;;;sBAEzC,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC;;6BAI/C,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC"}

package/src/types/browser/lib/ActionRunner.d.ts

@@ -1,6 +1,9 @@
 /**
  * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
  */
+/**
+ * @typedef {import("./ActionBuilder.js").default} ActionBuilder
+ */
 /**
  * @typedef {object} ActionRunnerOptions
  * @property {DebugFn} [debug] Logger function.
@@ -23,16 +26,18 @@ export default class ActionRunner extends Piper {
     /**
      * Executes the configured action pipeline.
      * Builds the ActionWrapper on first run and caches it for subsequent calls.
-     * Supports WHILE, UNTIL, and SPLIT activity kinds.
+     * Supports WHILE, UNTIL, IF, SPLIT, BREAK, and CONTINUE activity kinds.
      *
      * @param {unknown} context - Seed value passed to the first activity.
+     * @param {import("./ActionWrapper.js").default|null} [parentWrapper] - Parent wrapper for BREAK/CONTINUE signaling.
      * @returns {Promise<unknown>} Final value produced by the pipeline.
      * @throws {Sass} When no activities are registered, conflicting activity kinds are used, or execution fails.
      */
-    run(context: unknown): Promise<unknown>;
+    run(context: unknown, parentWrapper?: import("./ActionWrapper.js").default | null): Promise<unknown>;
     #private;
 }
 export type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void;
+export type ActionBuilder = import("./ActionBuilder.js").default;
 export type ActionRunnerOptions = {
     /**
      * Logger function.

package/src/types/browser/lib/ActionRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionRunner.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionRunner.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;GAGG;AACH;;;;;;GAMG;AACH;IAaE;;;;;OAKG;IACH,2BAHW,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,cACzC,mBAAmB,EAkB7B;IAED;;;;;;;;OAQG;IACH,aAJW,OAAO,GACL,OAAO,CAAC,OAAO,CAAC,CAuG5B;;CA0FF;sBA1PY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;;;kBAH7D,YAAY"}
+{"version":3,"file":"ActionRunner.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionRunner.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;GAEG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AACH;IAoBE;;;;;OAKG;IACH,2BAHW,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,cACzC,mBAAmB,EAkB7B;IAED;;;;;;;;;OASG;IACH,aALW,OAAO,kBACP,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,GACvC,OAAO,CAAC,OAAO,CAAC,CA4I5B;;CAyFF;sBA3SY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;4BAIlE,OAAO,oBAAoB,EAAE,OAAO;;;;;;;kBAP/B,YAAY"}