@gesslar/actioneer 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/actioneer",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Ready? Set?? ACTION!! pew! pew! pew!",
   "main": "./src/index.js",
   "type": "module",

package/src/lib/ActionBuilder.js

@@ -30,6 +30,8 @@ import ActionHooks from "./ActionHooks.js"
  * @property {ActionFunction|import("./ActionWrapper.js").default} op Operation to execute.
  * @property {number} [kind] Optional kind flags from {@link ActivityFlags}.
  * @property {(context: unknown) => boolean|Promise<boolean>} [pred] Loop predicate.
+ * @property {(context: unknown) => unknown} [splitter] Function to split context for parallel execution (SPLIT activities).
+ * @property {(originalContext: unknown, splitResults: unknown) => unknown} [rejoiner] Function to rejoin split results (SPLIT activities).
  */
 
 /**
@@ -65,15 +67,29 @@ export default class ActionBuilder {
   #debug = null
   /** @type {symbol|null} */
   #tag = null
+  /** @type {string|null} */
   #hooksFile = null
+  /** @type {string|null} */
   #hooksKind = null
+  /** @type {unknown|null} */
   #hooks = null
+  /** @type {import("./ActionHooks.js").default|null} */
+  #actionHooks = null
+
+  /**
+   * Get the builder's tag symbol.
+   *
+   * @returns {symbol|null} The tag symbol for this builder instance
+   */
+  get tag() {
+    return this.#tag
+  }
 
   /**
    * Creates a new ActionBuilder instance with the provided action callback.
    *
-   * @param {ActionBuilderAction} [action] Base action invoked by the runner when a block satisfies the configured structure.
-   * @param {ActionBuilderConfig} [config] Options
+   * @param {ActionBuilderAction} [action] - Base action invoked by the runner when a block satisfies the configured structure.
+   * @param {ActionBuilderConfig} [config] - Options
    */
   constructor(
     action,
@@ -112,6 +128,16 @@ export default class ActionBuilder {
    * @returns {ActionBuilder}
    */
 
+  /**
+   * @overload
+   * @param {string|symbol} name Activity name
+   * @param {number} kind Kind bitfield (ACTIVITY.SPLIT).
+   * @param {(context: unknown) => unknown} splitter Function to split context for parallel execution.
+   * @param {(originalContext: unknown, splitResults: unknown) => unknown} rejoiner Function to rejoin split results with original context.
+   * @param {ActionFunction|ActionBuilder} op Operation or nested ActionBuilder to execute on split context.
+   * @returns {ActionBuilder}
+   */
+
   /**
    * Handles runtime dispatch across the documented overloads.
    *
@@ -129,22 +155,32 @@ export default class ActionBuilder {
 
     const action = this.#action
     const debug = this.#debug
-    const activityDefinition = {name, action, debug}
+    const activityDefinition = {name,action,debug}
 
     if(args.length === 1) {
-      const [op, kind] = args
+      const [op,kind] = args
       Valid.type(kind, "Number|undefined")
       Valid.type(op, "Function")
 
-      Object.assign(activityDefinition, {op, kind})
+      Object.assign(activityDefinition, {op,kind})
     } else if(args.length === 3) {
-      const [kind, pred, op] = args
+      const [kind,pred,op] = args
 
       Valid.type(kind, "Number")
       Valid.type(pred, "Function")
       Valid.type(op, "Function|ActionBuilder")
 
-      Object.assign(activityDefinition, {kind, pred, op})
+      Object.assign(activityDefinition, {kind,pred,op})
+    } else if(args.length === 4) {
+      const [kind,splitter,rejoiner,op] = args
+
+      Valid.type(kind, "Number")
+      Valid.type(splitter, "Function")
+      Valid.type(rejoiner, "Function")
+      Valid.type(op, "Function|ActionBuilder")
+
+      Object.assign(activityDefinition, {kind,splitter,rejoiner,op})
+
     } else {
       throw Sass.new("Invalid number of arguments passed to 'do'")
     }
@@ -163,9 +199,7 @@ export default class ActionBuilder {
    * @throws {Sass} If hooks have already been configured.
    */
   withHooksFile(hooksFile, hooksKind) {
-    Valid.assert(this.#hooksFile === null, "Hooks have already been configured.")
-    Valid.assert(this.#hooksKind === null, "Hooks have already been configured.")
-    Valid.assert(this.#hooks === null, "Hooks have already been configured.")
+    Valid.assert(this.#exclusiveHooksCheck(), "Hooks have already been configured.")
 
     this.#hooksFile = hooksFile
     this.#hooksKind = hooksKind
@@ -181,15 +215,40 @@ export default class ActionBuilder {
    * @throws {Sass} If hooks have already been configured.
    */
   withHooks(hooks) {
-    Valid.assert(this.#hooksFile === null, "Hooks have already been configured.")
-    Valid.assert(this.#hooksKind === null, "Hooks have already been configured.")
-    Valid.assert(this.#hooks === null, "Hooks have already been configured.")
+    Valid.assert(this.#exclusiveHooksCheck(), "Hooks have already been configured.")
 
     this.#hooks = hooks
 
     return this
   }
 
+  /**
+   * Configure hooks using an ActionHooks instance directly (typically used internally).
+   *
+   * @param {import("./ActionHooks.js").default} actionHooks Pre-configured ActionHooks instance.
+   * @returns {ActionBuilder} The builder instance for chaining.
+   * @throws {Sass} If hooks have already been configured.
+   */
+  withActionHooks(actionHooks) {
+    Valid.assert(this.#exclusiveHooksCheck(), "Hooks have already been configured.")
+
+    this.#actionHooks = actionHooks
+
+    return this
+  }
+
+  /**
+   * Ensures only one hooks configuration method is used at a time.
+   *
+   * @returns {boolean} True if no hooks have been configured yet, false otherwise.
+   * @private
+   */
+  #exclusiveHooksCheck() {
+    return !!(this.#hooksFile && this.#hooksKind) +
+           !!(this.#hooks) +
+           !!(this.#actionHooks) === 0
+  }
+
   /**
    * Validates that an activity name has not been reused.
    *
@@ -211,6 +270,8 @@ export default class ActionBuilder {
    */
   async build() {
     const action = this.#action
+    const activities = this.#activities
+    const debug = this.#debug
 
     if(!action.tag) {
       action.tag = this.#tag
@@ -221,24 +282,47 @@ export default class ActionBuilder {
     // All children in a branch also get the same hooks.
     const hooks = await this.#getHooks()
 
-    return new ActionWrapper({
-      activities: this.#activities,
-      debug: this.#debug,
-      hooks,
-    })
+    return new ActionWrapper({activities,hooks,debug})
+  }
+
+  /**
+   * Check if this builder has ActionHooks configured.
+   *
+   * @returns {boolean} True if ActionHooks have been configured.
+   */
+  get hasActionHooks() {
+    return this.#actionHooks !== null
   }
 
+  /**
+   * Internal method to retrieve or create ActionHooks instance.
+   * Caches the hooks instance to avoid redundant instantiation.
+   *
+   * @returns {Promise<import("./ActionHooks.js").default|undefined>} The ActionHooks instance if configured.
+   * @private
+   */
   async #getHooks() {
+    if(this.#actionHooks) {
+      return this.#actionHooks
+    }
+
     const newHooks = ActionHooks.new
 
     const hooks = this.#hooks
-    if(hooks)
-      return await newHooks({hooks}, this.#debug)
+
+    if(hooks) {
+      this.#actionHooks = await newHooks({hooks}, this.#debug)
+
+      return this.#actionHooks
+    }
 
     const hooksFile = this.#hooksFile
     const hooksKind = this.#hooksKind
 
-    if(hooksFile && hooksKind)
-      return await newHooks({hooksFile,hooksKind}, this.#debug)
+    if(hooksFile && hooksKind) {
+      this.#actionHooks = await newHooks({hooksFile,hooksKind}, this.#debug)
+
+      return this.#actionHooks
+    }
   }
 }

package/src/lib/ActionHooks.js

@@ -7,11 +7,10 @@ import {Data, FileObject, Sass, Util, Valid} from "@gesslar/toolkit"
 
 /**
  * @typedef {object} ActionHooksConfig
- * @property {string} actionKind Action identifier shared between runner and hooks.
- * @property {FileObject} hooksFile File handle used to import the hooks module.
- * @property {unknown} [hooks] Already-instantiated hooks implementation (skips loading).
+ * @property {string} [actionKind] Action identifier shared between runner and hooks.
+ * @property {FileObject|string} [hooksFile] File handle or path used to import the hooks module.
+ * @property {unknown} [hooksObject] Already-instantiated hooks implementation (skips loading).
  * @property {number} [hookTimeout] Timeout applied to hook execution in milliseconds.
- * @property {DebugFn} debug Logger to emit diagnostics.
  */
 
 /**
@@ -27,7 +26,7 @@ export default class ActionHooks {
   /** @type {FileObject|null} */
   #hooksFile = null
   /** @type {HookModule|null} */
-  #hooks = null
+  #hooksObject = null
   /** @type {string|null} */
   #actionKind = null
   /** @type {number} */
@@ -39,11 +38,15 @@ export default class ActionHooks {
    * Creates a new ActionHook instance.
    *
    * @param {ActionHooksConfig} config Configuration values describing how to load the hooks.
+   * @param {(message: string, level?: number, ...args: Array<unknown>) => void} debug Debug function
    */
-  constructor({actionKind, hooksFile, hooks, hookTimeout = 1_000, debug}) {
+  constructor(
+    {actionKind, hooksFile, hooksObject, hookTimeout = 1_000},
+    debug,
+  ) {
     this.#actionKind = actionKind
     this.#hooksFile = hooksFile
-    this.#hooks = hooks
+    this.#hooksObject = hooksObject
     this.#timeout = hookTimeout
     this.#debug = debug
   }
@@ -51,7 +54,7 @@ export default class ActionHooks {
   /**
    * Gets the action identifier.
    *
-   * @returns {string} Action identifier or instance
+   * @returns {string|null} Action identifier or instance
    */
   get actionKind() {
     return this.#actionKind
@@ -60,7 +63,7 @@ export default class ActionHooks {
   /**
    * Gets the hooks file object.
    *
-   * @returns {FileObject} File object containing hooks
+   * @returns {FileObject|null} File object containing hooks
    */
   get hooksFile() {
     return this.#hooksFile
@@ -69,10 +72,10 @@ export default class ActionHooks {
   /**
    * Gets the loaded hooks object.
    *
-   * @returns {object|null} Hooks object or null if not loaded
+   * @returns {HookModule|null} Hooks object or null if not loaded
    */
   get hooks() {
-    return this.#hooks
+    return this.#hooksObject
   }
 
   /**
@@ -105,17 +108,17 @@ export default class ActionHooks {
   /**
    * Static factory method to create and initialize a hook manager.
    * Loads hooks from the specified file and returns an initialized instance.
-   * Override loadHooks() in subclasses to customize hook loading logic.
+   * If a hooksObject is provided in config, it's used directly; otherwise, hooks are loaded from file.
    *
-   * @param {ActionHooksConfig} config Same configuration object as constructor
+   * @param {ActionHooksConfig} config Configuration object with hooks settings
    * @param {DebugFn} debug The debug function.
-   * @returns {Promise<ActionHooks|null>} Initialized hook manager or null if no hooks found
+   * @returns {Promise<ActionHooks>} Initialized hook manager
    */
   static async new(config, debug) {
     debug("Creating new HookManager instance with args: %o", 2, config)
 
     const instance = new ActionHooks(config, debug)
-    if(!instance.#hooks) {
+    if(!instance.#hooksObject) {
       const hooksFile = new FileObject(instance.#hooksFile)
 
       debug("Loading hooks from %o", 2, hooksFile.uri)
@@ -140,7 +143,7 @@ export default class ActionHooks {
 
         debug(hooks.constructor.name, 4)
 
-        instance.#hooks = hooks
+        instance.#hooksObject = hooks
         debug("Hooks %o loaded successfully for %o", 2, hooksFile.uri, instance.actionKind)
 
         return instance
@@ -151,31 +154,34 @@ export default class ActionHooks {
       }
     }
 
-    return this
+    return instance
   }
 
   /**
-   * Invoke a dynamically-named hook such as `before$foo`.
+   * Invoke a dynamically-named hook such as `before$foo` or `after$foo`.
+   * The hook name is constructed by combining the kind with the activity name.
+   * Symbols are converted to their description. Non-alphanumeric characters are filtered out.
    *
    * @param {'before'|'after'|'setup'|'cleanup'|string} kind Hook namespace.
    * @param {string|symbol} activityName Activity identifier.
    * @param {unknown} context Pipeline context supplied to the hook.
    * @returns {Promise<void>}
+   * @throws {Sass} If the hook execution fails or exceeds timeout.
    */
   async callHook(kind, activityName, context) {
-    try {
-      const debug = this.#debug
-      const hooks = this.#hooks
+    const debug = this.#debug
+    const hooks = this.#hooksObject
 
-      if(!hooks)
-        return
+    if(!hooks)
+      return
 
-      const stringActivityName = Data.isType("Symbol")
-        ? activityName.description()
-        : activityName
+    const stringActivityName = Data.isType(activityName, "Symbol")
+      ? activityName.description()
+      : activityName
 
-      const hookName = this.#getActivityHookName(kind, stringActivityName)
+    const hookName = this.#getActivityHookName(kind, stringActivityName)
 
+    try {
       debug("Looking for hook: %o", 4, hookName)
 
       const hook = hooks[hookName]
@@ -189,7 +195,7 @@ export default class ActionHooks {
         debug("Hook function starting execution: %o", 4, hookName)
 
         const duration = (
-          await Util.time(() => hook.call(this.#hooks, context))
+          await Util.time(() => hook.call(this.#hooksObject, context))
         ).cost
 
         debug("Hook function completed successfully: %o, after %oms", 4, hookName, duration)
@@ -208,16 +214,26 @@ export default class ActionHooks {
           expireAsync
         ])
       } catch(error) {
-        throw Sass.new(`Processing hook ${kind}$${activityName}`, error)
+        throw Sass.new(`Processing hook ${hookName}`, error)
       }
 
       debug("We made it throoough the wildernessss", 4)
 
     } catch(error) {
-      throw Sass.new(`Processing hook ${kind}$${activityName}`, error)
+      throw Sass.new(`Processing hook ${hookName}`, error)
     }
   }
 
+  /**
+   * Transforms an activity name into a hook-compatible name.
+   * Converts "my activity name" to "myActivityName" and combines with event kind.
+   * Example: ("before", "my activity") => "before$myActivity"
+   *
+   * @param {string} event Hook event type (before, after, etc.)
+   * @param {string} activityName The raw activity name
+   * @returns {string} The formatted hook name
+   * @private
+   */
   #getActivityHookName(event, activityName) {
     const name = activityName
       .split(" ")

package/src/lib/ActionRunner.js

@@ -1,4 +1,4 @@
-import {Sass, Valid} from "@gesslar/toolkit"
+import {Data, Sass, Valid} from "@gesslar/toolkit"
 
 import ActionBuilder from "./ActionBuilder.js"
 import {ACTIVITY} from "./Activity.js"
@@ -20,7 +20,10 @@ import Piper from "./Piper.js"
  * context object under `result.value` that can be replaced or enriched.
  */
 export default class ActionRunner extends Piper {
+  /** @type {import("./ActionBuilder.js").default|null} */
   #actionBuilder = null
+  /** @type {import("./ActionWrapper.js").default|null} */
+  #actionWrapper = null
 
   /**
    * Logger invoked for diagnostics.
@@ -48,82 +51,160 @@ export default class ActionRunner extends Piper {
 
     this.#actionBuilder = actionBuilder
 
-    this.addStep(this.run)
+    this.addStep(this.run, {
+      name: `ActionRunner for ${actionBuilder.tag.description}`
+    })
   }
 
   /**
    * Executes the configured action pipeline.
+   * Builds the ActionWrapper on first run and caches it for subsequent calls.
+   * Supports WHILE, UNTIL, and SPLIT activity kinds.
    *
    * @param {unknown} context - Seed value passed to the first activity.
-   * @returns {Promise<unknown>} Final value produced by the pipeline, or null when a parallel stage reports failures.
-   * @throws {Sass} When no activities are registered or required parallel builders are missing.
+   * @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) {
-    const actionWrapper = await this.#actionBuilder.build()
+    if(!this.#actionWrapper)
+      this.#actionWrapper = await this.#actionBuilder.build()
+
+    const actionWrapper = this.#actionWrapper
     const activities = actionWrapper.activities
 
     for(const activity of activities) {
-      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.#executeActivity(activity, context)
-      } else {
-        const {WHILE,UNTIL} = ACTIVITY
-        const pred = activity.pred
-        const kindWhile = kind & WHILE
-        const kindUntil = kind & UNTIL
-
-        if(kindWhile && kindUntil)
-          throw Sass.new(
-            "For Kathy Griffin's sake! You can't do something while AND " +
-            "until. Pick one!"
-          )
-
-        if(kindWhile || kindUntil) {
-          for(;;) {
-
-            if(kindWhile)
-              if(!await this.#predicateCheck(activity,pred,context))
-                break
+      try {
+        // await timeout(500)
 
-            context = await this.#executeActivity(activity,context)
+        const kind = activity.kind
 
-            if(kindUntil)
-              if(!await this.#predicateCheck(activity,pred,context))
-                break
-          }
+        // 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 {
-          context = await this.#executeActivity(activity, context)
+          // 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))
+                  break
+
+              context = await this.#execute(activity,context)
+
+              if(kindUntil)
+                if(!await this.#hasPredicate(activity,predicate,context))
+                  break
+            }
+          } else if(kindSplit && activity.opKind === "ActionBuilder") {
+            // SPLIT activity: parallel execution with splitter/rejoiner pattern
+            const splitter = activity.splitter
+            const rejoiner = activity.rejoiner
+
+            if(!splitter || !rejoiner)
+              throw Sass.new(
+                `SPLIT activity "${String(activity.name)}" requires both splitter and rejoiner functions.`
+              )
+
+            const original = context
+            const splitContext = splitter.call(activity.action,context)
+            const newContext = await this.#execute(activity,splitContext,true)
+            const rejoined = rejoiner.call(activity.action, original,newContext)
+
+            context = rejoined
+          } else {
+            context = await this.#execute(activity, context)
+          }
         }
+      } catch(error) {
+        throw Sass.new("ActionRunner running activity", error)
       }
-
     }
 
     return context
   }
 
   /**
-   * Execute a single activity, recursing into nested action wrappers when needed.
+   * Execute a single activity, recursing into nested ActionBuilders when needed.
+   * Handles both function-based activities and ActionBuilder-based nested pipelines.
+   * Automatically propagates hooks to nested builders and handles dynamic ActionBuilder returns.
+   *
+   * When parallel=true, uses Piper.pipe() for concurrent execution with worker pool pattern.
+   * This is triggered by SPLIT activities where context is divided for parallel processing.
+   * Results from parallel execution are filtered to only include successful outcomes ({ok: true}).
    *
    * @param {import("./Activity.js").default} activity Pipeline activity descriptor.
    * @param {unknown} context Current pipeline context.
+   * @param {boolean} [parallel] Whether to use parallel execution (via pipe() instead of run()). Default: false.
    * @returns {Promise<unknown>} Resolved activity result.
+   * @throws {Sass} If the operation kind is invalid, or if SPLIT activity lacks splitter/rejoiner.
    * @private
    */
-  async #executeActivity(activity, context) {
+  async #execute(activity, context, parallel=false) {
     // What kind of op are we looking at? Is it a function?
     // Or a class instance of type ActionBuilder?
     const opKind = activity.opKind
+
     if(opKind === "ActionBuilder") {
-      const runner = new this.constructor(activity.op, {debug: this.#debug})
+      if(activity.hooks && !activity.op.hasActionHooks)
+        activity.op.withActionHooks(activity.hooks)
+
+      const runner = new this.constructor(activity.op, {
+        debug: this.#debug, name: activity.name
+      })
 
-      return await runner.run(context, true)
+      if(parallel) {
+        const piped = await runner.pipe(context)
+
+        return piped.filter(p => p.ok).map(p => p.value)
+      } else {
+        return await runner.run(context)
+      }
     } else if(opKind === "Function") {
-      return await activity.run(context)
+      try {
+        const result = await activity.run(context)
+
+        if(Data.isType(result, "ActionBuilder")) {
+          if(activity.hooks)
+            result.withActionHooks(activity.hooks)
+
+          const runner = new this.constructor(result, {
+            debug: this.#debug, name: result.name
+          })
+
+          if(parallel) {
+            const piped = await runner.pipe(context)
+
+            return piped.filter(p => p.ok).map(p => p.value)
+          } else {
+            return await runner.run(context)
+          }
+        } else {
+          return result
+        }
+      } catch(error) {
+        throw Sass.new("Executing activity", error)
+      }
     }
 
+    console.log(activity.opKind + " " + JSON.stringify(activity))
+
     throw Sass.new("We buy Functions and ActionBuilders. Only. Not whatever that was.")
   }
 
@@ -136,7 +217,7 @@ export default class ActionRunner extends Piper {
    * @returns {Promise<boolean>} True when the predicate allows another iteration.
    * @private
    */
-  async #predicateCheck(activity,predicate,context) {
+  async #hasPredicate(activity,predicate,context) {
     Valid.type(predicate, "Function")
 
     return !!(await predicate.call(activity.action, context))

package/src/lib/ActionWrapper.js

@@ -3,9 +3,11 @@ import Activity from "./Activity.js"
 /**
  * @typedef {object} WrappedActivityConfig
  * @property {string|symbol} name Activity identifier used by hooks/logs.
- * @property {(context: unknown) => unknown|Promise<unknown>|ActionWrapper} op Operation or nested wrapper to execute.
+ * @property {(context: unknown) => unknown|Promise<unknown>|import("./ActionBuilder.js").default} op Operation or nested ActionBuilder to execute.
  * @property {number} [kind] Optional loop semantic flags.
  * @property {(context: unknown) => boolean|Promise<boolean>} [pred] Predicate tied to WHILE/UNTIL semantics.
+ * @property {(context: unknown) => unknown} [splitter] Splitter function for SPLIT activities.
+ * @property {(originalContext: unknown, splitResults: unknown) => unknown} [rejoiner] Rejoiner function for SPLIT activities.
  * @property {unknown} [action] Parent action instance supplied when invoking the op.
  * @property {(message: string, level?: number, ...args: Array<unknown>) => void} [debug] Optional logger reference.
  */
@@ -31,21 +33,29 @@ export default class ActionWrapper {
    */
   #debug = () => {}
 
+  /**
+   * ActionHooks instance shared across all activities.
+   *
+   * @type {import("./ActionHooks.js").default|null}
+   */
   #hooks = null
 
   /**
    * 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.
+   * @param {object} config Builder payload containing activities + logger
+   * @param {Map<string|symbol, WrappedActivityConfig>} config.activities Activities map
+   * @param {(message: string, level?: number, ...args: Array<unknown>) => void} config.debug Debug function
+   * @param {object} config.hooks Hooks object
    */
-  constructor({activities,hooks,debug}) {
-    this.#debug = debug
-    this.#hooks = hooks
-    this.#activities = activities
+  constructor(config) {
+    this.#debug = config.debug
+    this.#hooks = config.hooks
+    this.#activities = config.activities
     this.#debug(
       "Instantiating ActionWrapper with %o activities.",
       2,
-      activities.size,
+      this.#activities.size,
     )
   }