@gesslar/actioneer 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/actioneer",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Ready? Set?? ACTION!! pew!pew!pew!pew!",
   "main": "./src/index.js",
   "type": "module",
@@ -22,6 +22,7 @@
   "scripts": {
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
+    "types:build": "tsc -p tsconfig.types.json && eslint --fix \"src/types/**/*.d.ts\"",
     "submit": "npm publish --access public",
     "update": "npx npm-check-updates -u && npm install",
     "test": "node --test tests/unit/*.test.js",

package/src/lib/ActionBuilder.js

@@ -3,6 +3,37 @@ import {Data, Sass, Valid} from "@gesslar/toolkit"
 import ActionWrapper from "./ActionWrapper.js"
 
 /** @typedef {import("./ActionRunner.js").default} ActionRunner */
+/** @typedef {typeof import("./Activity.js").ACTIVITY} ActivityFlags */
+
+/**
+ * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
+ */
+
+/**
+ * @typedef {object} ActionBuilderAction
+ * @property {(builder: ActionBuilder) => void} setup Function invoked during {@link ActionBuilder#build} to register activities.
+ * @property {symbol} [tag] Optional tag to reuse when reconstructing builders.
+ */
+
+/**
+ * @typedef {object} ActionBuilderConfig
+ * @property {symbol} [tag] Optional tag for the builder instance.
+ * @property {DebugFn} [debug] Logger used by the pipeline internals.
+ */
+
+/**
+ * @typedef {object} ActivityDefinition
+ * @property {ActionBuilderAction|null} action Parent action instance when available.
+ * @property {DebugFn|null} debug Logger function.
+ * @property {string|symbol} name Activity identifier.
+ * @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.
+ */
+
+/**
+ * @typedef {(context: unknown) => unknown|Promise<unknown>} ActionFunction
+ */
 
 /**
  * Fluent builder for describing how an action should process the context that
@@ -25,16 +56,20 @@ import ActionWrapper from "./ActionWrapper.js"
  * @class ActionBuilder
  */
 export default class ActionBuilder {
+  /** @type {ActionBuilderAction|null} */
   #action = null
+  /** @type {Map<string|symbol, ActivityDefinition>} */
   #activities = new Map([])
+  /** @type {DebugFn|null} */
   #debug = null
+  /** @type {symbol|null} */
   #tag = null
 
   /**
    * Creates a new ActionBuilder instance with the provided action callback.
    *
-   * @param {(ctx: unknown) => unknown} action Base action invoked by the runner when a block satisfies the configured structure.
-   * @param {{tag?: symbol, debug?: (message: string, level?: number, ...args: Array<unknown>) => void}} [config] Options
+   * @param {ActionBuilderAction} [action] Base action invoked by the runner when a block satisfies the configured structure.
+   * @param {ActionBuilderConfig} [config] Options
    */
   constructor(
     action,
@@ -52,12 +87,30 @@ export default class ActionBuilder {
   }
 
   /**
-   * Register an activity.
+   * Register an activity that the runner can execute.
    *
    * Overloads:
    * - do(name, op)
    * - do(name, kind, pred, opOrWrapper)
    *
+   * @overload
+   * @param {string|symbol} name Activity name
+   * @param {ActionFunction} op Operation to execute once.
+   * @returns {ActionBuilder}
+   */
+
+  /**
+   * @overload
+   * @param {string|symbol} name Activity name
+   * @param {number} kind Kind bitfield 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.
+   * @returns {ActionBuilder}
+   */
+
+  /**
+   * Handles runtime dispatch across the documented overloads.
+   *
    * @param {string|symbol} name Activity name
    * @param {...unknown} args See overloads
    * @returns {ActionBuilder} The builder instance for chaining
@@ -114,7 +167,7 @@ export default class ActionBuilder {
    * Finalises the builder and returns a payload that can be consumed by the
    * runner.
    *
-   * @returns {{action: (context: unknown) => unknown, build: ActionBuilder}} Payload consumed by the {@link ActionRunner} constructor.
+   * @returns {import("./ActionWrapper.js").default} Payload consumed by the {@link ActionRunner} constructor.
    */
   build() {
     const action = this.#action

package/src/lib/ActionHooks.js

@@ -1,27 +1,44 @@
 import {setTimeout as timeout} from "timers/promises"
 import {FileObject, Sass, Util, Valid} from "@gesslar/toolkit"
 
+/**
+ * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
+ */
+
+/**
+ * @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 {number} [hookTimeout] Timeout applied to hook execution in milliseconds.
+ * @property {DebugFn} debug Logger to emit diagnostics.
+ */
+
+/**
+ * @typedef {Record<string, (context: unknown) => Promise<unknown>|unknown>} HookModule
+ */
+
 /**
  * Generic base class for managing hooks with configurable event types.
  * Provides common functionality for hook registration, execution, and lifecycle management.
  * Designed to be extended by specific implementations.
  */
 export default class ActionHooks {
+  /** @type {FileObject|null} */
   #hooksFile = null
+  /** @type {HookModule|null} */
   #hooks = null
+  /** @type {string|null} */
   #actionKind = null
+  /** @type {number} */
   #timeout = 1000 // Default 1 second timeout
+  /** @type {DebugFn|null} */
   #debug = null
 
   /**
    * Creates a new ActionHook instance.
    *
-   * @param {object} config - Configuration object
-   * @param {string} config.actionKind - Action identifier
-   * @param {FileObject} config.hooksFile - File object containing hooks with uri property
-   * @param {number} [config.hookTimeout] - Hook execution timeout in milliseconds
-   * @param {unknown} [config.hooks] - The hooks object
-   * @param {(message: string, level?: number, ...args: Array<unknown>) => void} config.debug - Debug function from Glog.
+   * @param {ActionHooksConfig} config Configuration values describing how to load the hooks.
    */
   constructor({actionKind, hooksFile, hooks, hookTimeout = 1000, debug}) {
     this.#actionKind = actionKind
@@ -90,11 +107,8 @@ export default class ActionHooks {
    * Loads hooks from the specified file and returns an initialized instance.
    * Override loadHooks() in subclasses to customize hook loading logic.
    *
-   * @param {object} config - Same configuration object as constructor
-   * @param {string|object} config.actionKind - Action identifier or instance
-   * @param {FileObject} config.hooksFile - File object containing hooks with uri property
-   * @param {number} [config.timeOut] - Hook execution timeout in milliseconds
-   * @param {(message: string, level?: number, ...args: Array<unknown>) => void} debug - The debug function.
+   * @param {ActionHooksConfig} config Same configuration object as constructor
+   * @param {DebugFn} debug The debug function.
    * @returns {Promise<ActionHooks|null>} Initialized hook manager or null if no hooks found
    */
   static async new(config, debug) {
@@ -138,6 +152,14 @@ export default class ActionHooks {
     }
   }
 
+  /**
+   * Invoke a dynamically-named hook such as `before$foo`.
+   *
+   * @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>}
+   */
   async callHook(kind, activityName, context) {
     try {
       const debug = this.#debug

package/src/lib/ActionRunner.js

@@ -3,6 +3,18 @@ import {FileObject, Sass, Valid} from "@gesslar/toolkit"
 import ActionBuilder from "./ActionBuilder.js"
 import {ACTIVITY} from "./Activity.js"
 import Piper from "./Piper.js"
+
+/** @typedef {import("./ActionHooks.js").default} ActionHooks */
+
+/**
+ * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
+ */
+
+/**
+ * @typedef {object} ActionRunnerOptions
+ * @property {ActionHooks} [hooks] Pre-configured hooks.
+ * @property {DebugFn} [debug] Logger function.
+ */
 /**
  * Orchestrates execution of {@link ActionBuilder}-produced pipelines.
  *
@@ -11,13 +23,49 @@ import Piper from "./Piper.js"
  * context object under `result.value` that can be replaced or enriched.
  */
 export default class ActionRunner extends Piper {
+  /**
+   * Pipeline produced by the builder.
+   *
+   * @type {import("./ActionWrapper.js").default|null}
+   */
   #actionWrapper = null
-  #debug = null
+  /**
+   * Logger invoked for diagnostics.
+   *
+   * @type {DebugFn}
+   */
+  #debug = () => {}
+  /**
+   * Filesystem path to a hooks module.
+   *
+   * @type {string|null}
+   */
   #hooksPath = null
+  /**
+   * Constructor name exported by the hooks module.
+   *
+   * @type {string|null}
+   */
   #hooksClassName = null
+  /**
+   * Lazily instantiated hooks implementation.
+   *
+   * @type {ActionHooks|null}
+   */
   #hooks = null
+  /**
+   * Unique tag for log correlation.
+   *
+   * @type {symbol|null}
+   */
   #tag = null
 
+  /**
+   * Instantiate a runner over an optional action wrapper.
+   *
+   * @param {import("./ActionWrapper.js").default|null} wrappedAction Output of {@link ActionBuilder#build}.
+   * @param {ActionRunnerOptions} [options] Optional hooks/debug overrides.
+   */
   constructor(wrappedAction, {hooks,debug=(() => {})} = {}) {
     super({debug})
 
@@ -45,20 +93,14 @@ export default class ActionRunner extends Piper {
    * Executes the configured action pipeline.
    *
    * @param {unknown} context - Seed value passed to the first activity.
-   * @param {boolean} asIs - When true, do not wrap context in {value} (internal nested runners)
    * @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.
    */
-  async run(context, asIs=false) {
+  async run(context) {
     this.#debug(this.#tag.description)
     const actionWrapper = this.#actionWrapper
     const activities = actionWrapper.activities
 
-    if(!asIs)
-      context = {value: context}
-
-    context
-
     for(const activity of activities) {
       activity.setActionHooks(this.#hooks)
 
@@ -89,7 +131,6 @@ export default class ActionRunner extends Piper {
                 break
 
             context = await this.#executeActivity(activity,context)
-            context
 
             if(kindUntil)
               if(!await this.#predicateCheck(activity,pred,context))
@@ -97,7 +138,6 @@ export default class ActionRunner extends Piper {
           }
         } else {
           context = await this.#executeActivity(activity, context)
-          context
         }
       }
 
@@ -106,6 +146,14 @@ export default class ActionRunner extends Piper {
     return context
   }
 
+  /**
+   * Execute a single activity, recursing into nested action wrappers when needed.
+   *
+   * @param {import("./Activity.js").default} activity Pipeline activity descriptor.
+   * @param {unknown} context Current pipeline context.
+   * @returns {Promise<unknown>} Resolved activity result.
+   * @private
+   */
   async #executeActivity(activity, context) {
     // What kind of op are we looking at? Is it a function?
     // Or a class instance of type ActionWrapper?
@@ -119,12 +167,21 @@ export default class ActionRunner extends Piper {
 
       return await runner.run(context, true)
     } else if(opKind === "Function") {
-      return (await activity.run(context)).activityResult
+      return await activity.run(context)
     }
 
     throw Sass.new("We buy Functions and ActionWrappers. Only. Not whatever that was.")
   }
 
+  /**
+   * Evaluate the predicate for WHILE/UNTIL 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.
+   * @private
+   */
   async #predicateCheck(activity,predicate,context) {
     Valid.type(predicate, "Function")
 
@@ -135,6 +192,13 @@ export default class ActionRunner extends Piper {
     return `[object ${this.constructor.name}]`
   }
 
+  /**
+   * Configure hooks to be lazily loaded when the pipeline runs.
+   *
+   * @param {string} hooksPath Absolute path to the module exporting the hooks class.
+   * @param {string} className Constructor to instantiate from the hooks module.
+   * @returns {this} Runner instance for chaining.
+   */
   setHooks(hooksPath, className) {
     this.#hooksPath = hooksPath
     this.#hooksClassName = className
@@ -144,6 +208,12 @@ export default class ActionRunner extends Piper {
     return this
   }
 
+  /**
+   * Import and instantiate the configured hooks module.
+   *
+   * @returns {Promise<null|void>} Null when hooks are disabled, otherwise void.
+   * @private
+   */
   async #loadHooks() {
     if(!this.#hooksPath)
       return null

package/src/lib/ActionWrapper.js

@@ -1,9 +1,41 @@
 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 {number} [kind] Optional loop semantic flags.
+ * @property {(context: unknown) => boolean|Promise<boolean>} [pred] Predicate tied to WHILE/UNTIL semantics.
+ * @property {unknown} [action] Parent action instance supplied when invoking the op.
+ * @property {(message: string, level?: number, ...args: Array<unknown>) => void} [debug] Optional logger reference.
+ */
+
+/**
+ * @typedef {Generator<Activity, void, unknown>} ActivityIterator
+ */
+
+/**
+ * Thin wrapper that materialises {@link Activity} instances on demand.
+ */
 export default class ActionWrapper {
+  /**
+   * Registry of activities supplied by the builder.
+   *
+   * @type {Map<string|symbol, WrappedActivityConfig>}
+   */
   #activities = new Map()
-  #debug = null
+  /**
+   * Logger invoked for wrapper lifecycle events.
+   *
+   * @type {(message: string, level?: number, ...args: Array<unknown>) => void}
+   */
+  #debug = () => {}
 
+  /**
+   * 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,debug}) {
     this.#debug = debug
     this.#activities = activities
@@ -15,13 +47,15 @@ export default class ActionWrapper {
   }
 
   *#_activities() {
-    for(const [_,activity] of this.#activities) {
-      const result = new Activity(activity)
-
-      yield result
-    }
+    for(const [,activity] of this.#activities)
+      yield new Activity(activity)
   }
 
+  /**
+   * Iterator over the registered activities.
+   *
+   * @returns {ActivityIterator} Lazy iterator yielding Activity instances.
+   */
   get activities() {
     return this.#_activities()
   }

package/src/lib/Activity.js

@@ -108,7 +108,7 @@ export default class Activity {
     if(Data.typeOf(after) === "Function")
       await after.call(hooks,context)
 
-    return {activityResult: result}
+    return result
   }
 
   /**

package/src/lib/Piper.js

@@ -106,9 +106,8 @@ export default class Piper {
     }
 
     const setupResult = await Util.settleAll(
-      [...this.#lifeCycle.get("setup")
-
-      ].map(e => e()))
+      [...this.#lifeCycle.get("setup")].map(e => e())
+    )
     this.#processResult("Setting up the pipeline.", setupResult)
 
     // Start workers up to maxConcurrent limit
@@ -124,9 +123,8 @@ export default class Piper {
 
     // Run cleanup hooks
     const teardownResult = await Util.settleAll(
-      [...this.#lifeCycle.get("teardown")
-
-      ].map(e => e()))
+      [...this.#lifeCycle.get("teardown")].map(e => e())
+    )
     this.#processResult("Tearing down the pipeline.", teardownResult)
 
     return allResults

package/src/types/index.d.ts

@@ -1,6 +1,7 @@
-export {default as ActionBuilder} from './ActionBuilder'
-export {default as ActionHooks} from './ActionHooks'
-export {default as ActionRunner} from './ActionRunner'
-export {default as ActionWrapper} from './ActionWrapper'
-export {default as Activity, ACTIVITY} from './Activity'
-export {default as Piper} from './Piper'
+export { default as ActionBuilder } from './lib/ActionBuilder.js'
+export { default as ActionHooks } from './lib/ActionHooks.js'
+export { default as ActionRunner } from './lib/ActionRunner.js'
+export { default as ActionWrapper } from './lib/ActionWrapper.js'
+export { default as Piper } from './lib/Piper.js'
+export { default as Activity, ACTIVITY } from './lib/Activity.js'
+//# sourceMappingURL=index.d.ts.map

package/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,137 @@
+/** @typedef {import("./ActionRunner.js").default} ActionRunner */
+/** @typedef {typeof import("./Activity.js").ACTIVITY} ActivityFlags */
+/**
+ * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
+ */
+/**
+ * @typedef {object} ActionBuilderAction
+ * @property {(builder: ActionBuilder) => void} setup Function invoked during {@link ActionBuilder#build} to register activities.
+ * @property {symbol} [tag] Optional tag to reuse when reconstructing builders.
+ */
+/**
+ * @typedef {object} ActionBuilderConfig
+ * @property {symbol} [tag] Optional tag for the builder instance.
+ * @property {DebugFn} [debug] Logger used by the pipeline internals.
+ */
+/**
+ * @typedef {object} ActivityDefinition
+ * @property {ActionBuilderAction|null} action Parent action instance when available.
+ * @property {DebugFn|null} debug Logger function.
+ * @property {string|symbol} name Activity identifier.
+ * @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.
+ */
+/**
+ * @typedef {(context: unknown) => unknown|Promise<unknown>} ActionFunction
+ */
+/**
+ * Fluent builder for describing how an action should process the context that
+ * flows through the {@link ActionRunner}. Consumers register named activities,
+ * optional hook pairs, and nested parallel pipelines before handing the
+ * builder back to the runner for execution.
+ *
+ * Typical usage:
+ *
+ * ```js
+ * const pipeline = new ActionBuilder(myAction)
+ *   .act("prepare", ACTIVITY.ONCE, ctx => ctx.initialise())
+ *   .parallel(parallel => parallel
+ *     .act("step", ACTIVITY.MANY, ctx => ctx.consume())
+ *   )
+ *   .act("finalise", ACTIVITY.ONCE, ctx => ctx.complete())
+ *   .build()
+ * ```
+ *
+ * @class ActionBuilder
+ */
+export default class ActionBuilder {
+  /**
+   * 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
+   */
+  constructor(action?: ActionBuilderAction, { tag, debug }?: ActionBuilderConfig)
+  /**
+   * Register an activity that the runner can execute.
+   *
+   * Overloads:
+   * - do(name, op)
+   * - do(name, kind, pred, opOrWrapper)
+   *
+   * @overload
+   * @param {string|symbol} name Activity name
+   * @param {ActionFunction} op Operation to execute once.
+   * @returns {ActionBuilder}
+   */
+  do(name: string | symbol, op: ActionFunction): ActionBuilder
+  /**
+   * @overload
+   * @param {string|symbol} name Activity name
+   * @param {number} kind Kind bitfield 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.
+   * @returns {ActionBuilder}
+   */
+  do(name: string | symbol, kind: number, pred: (context: unknown) => boolean | Promise<boolean>, op: ActionFunction | import('./ActionWrapper.js').default): ActionBuilder
+  /**
+   * Finalises the builder and returns a payload that can be consumed by the
+   * runner.
+   *
+   * @returns {import("./ActionWrapper.js").default} Payload consumed by the {@link ActionRunner} constructor.
+   */
+  build(): import('./ActionWrapper.js').default
+  #private
+}
+export type ActionRunner = import('./ActionRunner.js').default
+export type ActivityFlags = typeof import('./Activity.js').ACTIVITY
+export type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
+export type ActionBuilderAction = {
+  /**
+   * Function invoked during {@link ActionBuilder#build} to register activities.
+   */
+  setup: (builder: ActionBuilder) => void;
+  /**
+   * Optional tag to reuse when reconstructing builders.
+   */
+  tag?: symbol | undefined;
+}
+export type ActionBuilderConfig = {
+  /**
+   * Optional tag for the builder instance.
+   */
+  tag?: symbol | undefined;
+  /**
+   * Logger used by the pipeline internals.
+   */
+  debug?: DebugFn | undefined;
+}
+export type ActivityDefinition = {
+  /**
+   * Parent action instance when available.
+   */
+  action: ActionBuilderAction | null;
+  /**
+   * Logger function.
+   */
+  debug: DebugFn | null;
+  /**
+   * Activity identifier.
+   */
+  name: string | symbol;
+  /**
+   * Operation to execute.
+   */
+  op: ActionFunction | import('./ActionWrapper.js').default;
+  /**
+   * Optional kind flags from {@link ActivityFlags}.
+   */
+  kind?: number | undefined;
+  /**
+   * Loop predicate.
+   */
+  pred?: ((context: unknown) => boolean | Promise<boolean>) | undefined;
+}
+export type ActionFunction = (context: unknown) => unknown | Promise<unknown>
+//# sourceMappingURL=ActionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ActionBuilder.d.ts","sourceRoot":"","sources":["../../lib/ActionBuilder.js"],"names":[],"mappings":"AAIA,kEAAkE;AAClE,uEAAuE;AAEvE;;GAEG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAUE;;;;;OAKG;IACH,qBAHW,mBAAmB,mBACnB,mBAAmB,EAe7B;;;;;;;;;;;;;IASE,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;IAyDD;;;;;OAKG;IACH,SAFa,OAAO,oBAAoB,EAAE,OAAO,CAehD;;CACF;2BArLa,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/lib/ActionHooks.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
+ */
+/**
+ * @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 {number} [hookTimeout] Timeout applied to hook execution in milliseconds.
+ * @property {DebugFn} debug Logger to emit diagnostics.
+ */
+/**
+ * @typedef {Record<string, (context: unknown) => Promise<unknown>|unknown>} HookModule
+ */
+/**
+ * Generic base class for managing hooks with configurable event types.
+ * Provides common functionality for hook registration, execution, and lifecycle management.
+ * Designed to be extended by specific implementations.
+ */
+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.
+   *
+   * @param {ActionHooksConfig} config Same configuration object as constructor
+   * @param {DebugFn} debug The debug function.
+   * @returns {Promise<ActionHooks|null>} Initialized hook manager or null if no hooks found
+   */
+  static 'new'(config: ActionHooksConfig, debug: DebugFn): Promise<ActionHooks | null>
+  /**
+   * Creates a new ActionHook instance.
+   *
+   * @param {ActionHooksConfig} config Configuration values describing how to load the hooks.
+   */
+  constructor({ actionKind, hooksFile, hooks, hookTimeout, debug }: ActionHooksConfig)
+  /**
+   * Gets the action identifier.
+   *
+   * @returns {string} Action identifier or instance
+   */
+  get actionKind(): string
+  /**
+   * Gets the hooks file object.
+   *
+   * @returns {FileObject} File object containing hooks
+   */
+  get hooksFile(): FileObject
+  /**
+   * Gets the loaded hooks object.
+   *
+   * @returns {object|null} Hooks object or null if not loaded
+   */
+  get hooks(): object | null
+  /**
+   * Gets the hook execution timeout in milliseconds.
+   *
+   * @returns {number} Timeout in milliseconds
+   */
+  get timeout(): number
+  /**
+   * Gets the setup hook function if available.
+   *
+   * @returns {(args: object) => unknown|null} Setup hook function or null
+   */
+  get setup(): (args: object) => unknown | null
+  /**
+   * Gets the cleanup hook function if available.
+   *
+   * @returns {(args: object) => unknown|null} Cleanup hook function or null
+   */
+  get cleanup(): (args: object) => unknown | null
+  /**
+   * Invoke a dynamically-named hook such as `before$foo`.
+   *
+   * @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>}
+   */
+  callHook(kind: 'before' | 'after' | 'setup' | 'cleanup' | string, activityName: string | symbol, context: unknown): Promise<void>
+  #private
+}
+export type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
+export type ActionHooksConfig = {
+  /**
+   * Action identifier shared between runner and hooks.
+   */
+  actionKind: string;
+  /**
+   * File handle used to import the hooks module.
+   */
+  hooksFile: FileObject;
+  /**
+   * Already-instantiated hooks implementation (skips loading).
+   */
+  hooks?: unknown;
+  /**
+   * Timeout applied to hook execution in milliseconds.
+   */
+  hookTimeout?: number | undefined;
+  /**
+   * Logger to emit diagnostics.
+   */
+  debug: DebugFn;
+}
+export type HookModule = Record<string, (context: unknown) => Promise<unknown> | unknown>
+import { FileObject } from '@gesslar/toolkit'
+//# sourceMappingURL=ActionHooks.d.ts.map

package/src/types/lib/ActionHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionHooks.d.ts","sourceRoot":"","sources":["../../lib/ActionHooks.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AAEH;;;;GAIG;AACH;IA+EE;;;;;;;;OAQG;IACH,qBAJW,iBAAiB,SACjB,OAAO,GACL,OAAO,CAAC,WAAW,GAAC,IAAI,CAAC,CAyCrC;IAnHD;;;;OAIG;IACH,kEAFW,iBAAiB,EAQ3B;IAED;;;;OAIG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,UAAU,CAItB;IAED;;;;OAIG;IACH,aAFa,MAAM,GAAC,IAAI,CAIvB;IAED;;;;OAIG;IACH,eAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,aAFa,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAC,IAAI,CAI1C;IAED;;;;OAIG;IACH,eAFa,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAC,IAAI,CAI1C;IAoDD;;;;;;;OAOG;IACH,eALW,QAAQ,GAAC,OAAO,GAAC,OAAO,GAAC,SAAS,GAAC,MAAM,gBACzC,MAAM,GAAC,MAAM,WACb,OAAO,GACL,OAAO,CAAC,IAAI,CAAC,CAoDzB;;CACF;sBAjNY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;gBAKjE,MAAM;;;;eACN,UAAU;;;;YACV,OAAO;;;;;;;;WAEP,OAAO;;yBAIR,MAAM,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAC,OAAO,CAAC;2BAhB/B,kBAAkB"}

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

@@ -0,0 +1,56 @@
+/** @typedef {import("./ActionHooks.js").default} ActionHooks */
+/**
+ * @typedef {(message: string, level?: number, ...args: Array<unknown>) => void} DebugFn
+ */
+/**
+ * @typedef {object} ActionRunnerOptions
+ * @property {ActionHooks} [hooks] Pre-configured hooks.
+ * @property {DebugFn} [debug] Logger function.
+ */
+/**
+ * Orchestrates execution of {@link ActionBuilder}-produced pipelines.
+ *
+ * Activities run in insertion order, with support for once-off work, repeated
+ * loops, and nested parallel pipelines. Each activity receives a mutable
+ * context object under `result.value` that can be replaced or enriched.
+ */
+export default class ActionRunner extends Piper {
+  /**
+   * Instantiate a runner over an optional action wrapper.
+   *
+   * @param {import("./ActionWrapper.js").default|null} wrappedAction Output of {@link ActionBuilder#build}.
+   * @param {ActionRunnerOptions} [options] Optional hooks/debug overrides.
+   */
+  constructor(wrappedAction: import('./ActionWrapper.js').default | null, { hooks, debug }?: ActionRunnerOptions)
+  /**
+   * Executes the configured action pipeline.
+   *
+   * @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.
+   */
+  run(context: unknown): Promise<unknown>
+  /**
+   * Configure hooks to be lazily loaded when the pipeline runs.
+   *
+   * @param {string} hooksPath Absolute path to the module exporting the hooks class.
+   * @param {string} className Constructor to instantiate from the hooks module.
+   * @returns {this} Runner instance for chaining.
+   */
+  setHooks(hooksPath: string, className: string): this
+  #private
+}
+export type ActionHooks = import('./ActionHooks.js').default
+export type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
+export type ActionRunnerOptions = {
+  /**
+   * Pre-configured hooks.
+   */
+  hooks?: import('./ActionHooks.js').default | undefined;
+  /**
+   * Logger function.
+   */
+  debug?: DebugFn | undefined;
+}
+import Piper from './Piper.js'
+//# sourceMappingURL=ActionRunner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ActionRunner.d.ts","sourceRoot":"","sources":["../../lib/ActionRunner.js"],"names":[],"mappings":"AAMA,gEAAgE;AAEhE;;GAEG;AAEH;;;;GAIG;AACH;;;;;;GAMG;AACH;IAsCE;;;;;OAKG;IACH,2BAHW,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,qBACzC,mBAAmB,EAuB7B;IAED;;;;;;OAMG;IACH,aAJW,OAAO,GACL,OAAO,CAAC,OAAO,CAAC,CAmD5B;IAgDD;;;;;;OAMG;IACH,oBAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAShB;;CA2BF;0BArOa,OAAO,kBAAkB,EAAE,OAAO;sBAGnC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;;;;;;;kBAL7D,YAAY"}

package/src/types/lib/ActionWrapper.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @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 {number} [kind] Optional loop semantic flags.
+ * @property {(context: unknown) => boolean|Promise<boolean>} [pred] Predicate tied to WHILE/UNTIL semantics.
+ * @property {unknown} [action] Parent action instance supplied when invoking the op.
+ * @property {(message: string, level?: number, ...args: Array<unknown>) => void} [debug] Optional logger reference.
+ */
+/**
+ * @typedef {Generator<Activity, void, unknown>} ActivityIterator
+ */
+/**
+ * Thin wrapper that materialises {@link Activity} instances on demand.
+ */
+export default class ActionWrapper {
+  /**
+   * 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, debug }: {
+    activities: Map<string | symbol, WrappedActivityConfig>;
+    debug: (message: string, level?: number, ...args: Array<unknown>) => void;
+  })
+  /**
+   * Iterator over the registered activities.
+   *
+   * @returns {ActivityIterator} Lazy iterator yielding Activity instances.
+   */
+  get activities(): ActivityIterator
+  #private
+}
+export type WrappedActivityConfig = {
+  /**
+   * Activity identifier used by hooks/logs.
+   */
+  name: string | symbol;
+  /**
+   * Operation or nested wrapper to execute.
+   */
+  op: (context: unknown) => unknown | Promise<unknown> | ActionWrapper;
+  /**
+   * Optional loop semantic flags.
+   */
+  kind?: number | undefined;
+  /**
+   * Predicate tied to WHILE/UNTIL semantics.
+   */
+  pred?: ((context: unknown) => boolean | Promise<boolean>) | undefined;
+  /**
+   * Parent action instance supplied when invoking the op.
+   */
+  action?: unknown;
+  /**
+   * Optional logger reference.
+   */
+  debug?: ((message: string, level?: number, ...args: Array<unknown>) => void) | undefined;
+}
+export type ActivityIterator = Generator<Activity, void, unknown>
+import Activity from './Activity.js'
+//# sourceMappingURL=ActionWrapper.d.ts.map

package/src/types/lib/ActionWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActionWrapper.d.ts","sourceRoot":"","sources":["../../lib/ActionWrapper.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;GAEG;AACH;IAcE;;;;OAIG;IACH,mCAFW;QAAC,UAAU,EAAE,GAAG,CAAC,MAAM,GAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;QAAC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;KAAC,EAU5I;IAOD;;;;OAIG;IACH,kBAFa,gBAAgB,CAI5B;;CACF;;;;;UAzDa,MAAM,GAAC,MAAM;;;;QACb,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,GAAC,aAAa;;;;;;;;sBAElD,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC;;;;aAC9C,OAAO;;;;uBACG,MAAM,UAAU,MAAM,WAAW,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;+BAInE,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC;qBAb1B,eAAe"}

package/src/types/lib/Activity.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Activity bit flags recognised by the builder. The flag decides
+ * loop semantics for an activity.
+ */
+export type ACTIVITY = number
+/**
+ * Activity bit flags recognised by the builder. The flag decides
+ * loop semantics for an activity.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const ACTIVITY: Readonly<{
+  WHILE: number;
+  UNTIL: number;
+}>
+export default class Activity {
+  /**
+   * Construct an Activity definition wrapper.
+   *
+   * @param {{action: unknown, name: string, op: (context: unknown) => unknown|Promise<unknown>|unknown, kind?: number, pred?: (context: unknown) => boolean|Promise<boolean>}} init - Initial properties describing the activity operation, loop semantics, and predicate
+   */
+  constructor({ action, name, op, kind, pred }: {
+    action: unknown;
+    name: string;
+    op: (context: unknown) => unknown | Promise<unknown> | unknown;
+    kind?: number;
+    pred?: (context: unknown) => boolean | Promise<boolean>;
+  })
+  /**
+   * The activity name.
+   *
+   * @returns {string} - Activity identifier
+   */
+  get name(): string
+  /**
+   * Bitflag kind for loop semantics.
+   *
+   * @returns {number|null} - Combined flags (e.g., WHILE or UNTIL)
+   */
+  get kind(): number | null
+  /**
+   * The predicate function for WHILE/UNTIL flows.
+   *
+   * @returns {(context: unknown) => boolean|Promise<boolean>|undefined} - Predicate used to continue/stop loops
+   */
+  get pred(): (context: unknown) => boolean | Promise<boolean> | undefined
+  /**
+   * The operator kind name (Function or ActionWrapper).
+   *
+   * @returns {string} - Kind name extracted via Data.typeOf
+   */
+  get opKind(): string
+  /**
+   * The operator to execute (function or nested wrapper).
+   *
+   * @returns {unknown} - Activity operation
+   */
+  get op(): unknown
+  /**
+   * The action instance this activity belongs to.
+   *
+   * @returns {unknown} - Bound action instance
+   */
+  get action(): unknown
+  /**
+   * Execute the activity with before/after hooks.
+   *
+   * @param {unknown} context - Mutable context flowing through the pipeline
+   * @returns {Promise<{activityResult: unknown}>} - Activity result wrapper with new context
+   */
+  run(context: unknown): Promise<{
+    activityResult: unknown;
+  }>
+  /**
+   * Attach hooks to this activity instance.
+   *
+   * @param {unknown} hooks - Hooks instance with optional before$/after$ methods
+   * @returns {this} - This activity for chaining
+   */
+  setActionHooks(hooks: unknown): this
+  #private
+}
+//# sourceMappingURL=Activity.d.ts.map

package/src/types/lib/Activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Activity.d.ts","sourceRoot":"","sources":["../../lib/Activity.js"],"names":[],"mappings":";;;;uBAOU,MAAM;AALhB;;;;;;GAMG;AACH;;;GAGE;AAEF;IAQE;;;;OAIG;IACH,8CAFW;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,GAAC,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,CAAA;KAAC,EAQ3K;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,GAAC,IAAI,CAIvB;IAED;;;;OAIG;IACH,YAFa,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,GAAC,SAAS,CAIpE;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,UAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,aAHW,OAAO,GACL,OAAO,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAC,CAAC,CAkB9C;IAED;;;;;OAKG;IACH,sBAHW,OAAO,GACL,IAAI,CAOhB;;CACF"}

package/src/types/lib/Piper.d.ts

@@ -0,0 +1,48 @@
+export default class Piper {
+  /**
+   * Create a Piper instance.
+   *
+   * @param {{debug?: (message: string, level?: number, ...args: Array<unknown>) => void}} [config] Optional configuration with debug function
+   */
+  constructor({ debug }?: {
+    debug?: (message: string, level?: number, ...args: Array<unknown>) => void;
+  })
+  /**
+   * Add a processing step to the pipeline
+   *
+   * @param {(context: unknown) => Promise<unknown>|unknown} fn Function that processes an item
+   * @param {{name?: string, required?: boolean}} [options] Step options
+   * @param {unknown} [newThis] Optional this binding
+   * @returns {Piper} The pipeline instance (for chaining)
+   */
+  addStep(fn: (context: unknown) => Promise<unknown> | unknown, options?: {
+    name?: string;
+    required?: boolean;
+  }, newThis?: unknown): Piper
+  /**
+   * Add setup hook that runs before processing starts.
+   *
+   * @param {() => Promise<void>|void} fn - Setup function executed before processing
+   * @param {unknown} [thisArg] - Optional this binding for the setup function
+   * @returns {Piper} - The pipeline instance
+   */
+  addSetup(fn: () => Promise<void> | void, thisArg?: unknown): Piper
+  /**
+   * Add cleanup hook that runs after processing completes
+   *
+   * @param {() => Promise<void>|void} fn - Cleanup function executed after processing
+   * @param {unknown} [thisArg] - Optional this binding for the cleanup function
+   * @returns {Piper} - The pipeline instance
+   */
+  addCleanup(fn: () => Promise<void> | void, thisArg?: unknown): Piper
+  /**
+   * Process items through the pipeline with concurrency control
+   *
+   * @param {Array<unknown>|unknown} items - Items to process
+   * @param {number} maxConcurrent - Maximum concurrent items to process
+   * @returns {Promise<Array<unknown>>} - Collected results from steps
+   */
+  pipe(items: Array<unknown> | unknown, maxConcurrent?: number): Promise<Array<unknown>>
+  #private
+}
+//# sourceMappingURL=Piper.d.ts.map

package/src/types/lib/Piper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Piper.d.ts","sourceRoot":"","sources":["../../lib/Piper.js"],"names":[],"mappings":"AAaA;IASE;;;;OAIG;IACH,wBAFW;QAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;KAAC,EAItF;IAED;;;;;;;OAOG;IACH,YALW,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAC,OAAO,YAC9C;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,YACnC,OAAO,GACL,KAAK,CAWjB;IAED;;;;;;OAMG;IACH,aAJW,MAAM,OAAO,CAAC,IAAI,CAAC,GAAC,IAAI,YACxB,OAAO,GACL,KAAK,CAMjB;IAED;;;;;;OAMG;IACH,eAJW,MAAM,OAAO,CAAC,IAAI,CAAC,GAAC,IAAI,YACxB,OAAO,GACL,KAAK,CAMjB;IAED;;;;;;OAMG;IACH,YAJW,KAAK,CAAC,OAAO,CAAC,GAAC,OAAO,kBACtB,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAiDnC;;CAyCF"}

package/src/types/ActionBuilder.d.ts

@@ -1,32 +0,0 @@
-import type ActionWrapper from './ActionWrapper'
-
-declare type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
-import type { ActionFunction } from './ActionWrapper'
-
-declare class ActionBuilder {
-  /**
-   * @param action An object with a `setup(builder)` method or undefined for an empty builder
-   */
-  constructor(
-    action?: { setup?: (builder: ActionBuilder) => void } | unknown,
-    config?: { tag?: symbol, debug?: DebugFn }
-  )
-
-  // Overload: once-off activity
-  do(name: string | symbol, op: ActionFunction): this
-
-  // Overload: controlled activity with kind, predicate and op (function or nested ActionWrapper)
-  do(
-    name: string | symbol,
-    kind: number,
-    pred: (context: unknown) => Promise<boolean>,
-    op: ActionFunction | ActionWrapper
-  ): this
-
-  // Generic fallback
-  do(name: string | symbol, ...args: Array<unknown>): this
-
-  build(): ActionWrapper
-}
-
-export default ActionBuilder

package/src/types/ActionHooks.d.ts

@@ -1,24 +0,0 @@
-declare type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
-
-declare class ActionHooks {
-  constructor(config: {
-    actionKind: unknown,
-    hooksFile: unknown,
-    hooks?: unknown,
-    hookTimeout?: number,
-    debug?: DebugFn
-  })
-  static new(
-    config: { actionKind: unknown, hooksFile: unknown, timeOut?: number },
-    debug?: DebugFn
-  ): Promise<ActionHooks | null>
-  callHook(kind: string, activityName: string, context: unknown): Promise<void>
-  get actionKind(): unknown
-  get hooksFile(): unknown
-  get hooks(): unknown | null
-  get timeout(): number
-  get setup(): ((args: object) => unknown) | null
-  get cleanup(): ((args: object) => unknown) | null
-}
-
-export default ActionHooks

package/src/types/ActionRunner.d.ts

@@ -1,18 +0,0 @@
-import Piper from './Piper'
-
-declare type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
-
-declare class ActionRunner extends Piper {
-  constructor(wrappedAction?: unknown, config?: { hooks?: unknown, debug?: DebugFn })
-
-  /**
-   * Execute the pipeline. When asIs is true, the context is not wrapped in {value}.
-   */
-  run(context: unknown, asIs?: boolean): Promise<unknown>
-
-  setHooks(hooksPath: string, className: string): this
-
-  toString(): string
-}
-
-export default ActionRunner

package/src/types/ActionWrapper.d.ts

@@ -1,27 +0,0 @@
-import type Activity from './Activity'
-
-/** Operation function signature used by activities */
-export type ActionFunction = (context: unknown) => unknown | Promise<unknown>
-
-import type { ActionFunction as _AF } from './ActionBuilder'
-
-declare type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
-
-declare class ActionWrapper {
-  constructor(config: {
-    activities: Map<unknown, {
-      name: string,
-      /** operation: either a function(context) or a nested ActionWrapper */
-      op: ActionFunction | ActionWrapper,
-      kind?: number,
-      /** predicate used for WHILE/UNTIL, returns Promise<boolean> */
-      pred?: (context: unknown) => Promise<boolean>,
-      action?: unknown,
-      debug?: DebugFn
-    }>,
-    debug?: DebugFn
-  })
-  get activities(): IterableIterator<Activity>
-}
-
-export default ActionWrapper

package/src/types/Activity.d.ts

@@ -1,21 +0,0 @@
-export const ACTIVITY: { WHILE: number; UNTIL: number }
-
-declare class Activity {
-  constructor(init: {
-    action: unknown,
-    name: string,
-    op: (context: unknown) => unknown | Promise<unknown> | unknown,
-    kind?: number,
-    pred?: (context: unknown) => Promise<boolean>
-  })
-  get name(): string
-  get kind(): number | null
-  get pred(): ((context: unknown) => boolean | Promise<boolean>) | undefined
-  get opKind(): string
-  get op(): unknown
-  get action(): unknown
-  run(context: unknown): Promise<{ activityResult: unknown }>
-  setActionHooks(hooks: unknown): this
-}
-
-export default Activity

package/src/types/Piper.d.ts

@@ -1,15 +0,0 @@
-declare type DebugFn = (message: string, level?: number, ...args: Array<unknown>) => void
-
-declare class Piper {
-  constructor(config?: { debug?: DebugFn })
-  addStep(
-    fn: (context: unknown) => Promise<unknown> | unknown,
-    options?: { name?: string, required?: boolean },
-    newThis?: unknown
-  ): this
-  addSetup(fn: () => Promise<void> | void, thisArg?: unknown): this
-  addCleanup(fn: () => Promise<void> | void, thisArg?: unknown): this
-  pipe(items: Array<unknown> | unknown, maxConcurrent?: number): Promise<Array<unknown>>
-}
-
-export default Piper