@gesslar/actioneer 3.0.1 → 3.1.0

package/README.md

@@ -1,6 +1,6 @@
 # Actioneer
 
-Actioneer is a small, focused action orchestration library for Node.js and browser environments. It provides a fluent builder for composing activities and a concurrent runner with lifecycle hooks and control flow semantics (while/until/if/break/continue). The project is written as ES modules and targets Node 20+ and modern browsers.
+Actioneer is a small, focused action orchestration library for Node.js and browser environments. It provides a fluent builder for composing activities and a concurrent runner with lifecycle hooks and control flow semantics (while/until/if/break/continue). The project is written as ES modules and targets Node 24+ and modern browsers.
 
 This repository extracts the action orchestration pieces from a larger codebase and exposes a compact API for building pipelines of work that can run concurrently with hook support and nested pipelines.
 
@@ -131,623 +131,17 @@ import { ActionBuilder, ActionRunner } from "@gesslar/actioneer"
 
 If you'd like more complete typings or additional JSDoc, open an issue or send a PR — contributions welcome.
 
-## Activity Modes
+## Documentation
 
-Actioneer supports six distinct execution modes for activities, allowing you to control how operations are executed:
+Full guides and API reference live at **[actioneer.gesslar.io](https://actioneer.gesslar.io)**. Highlights:
 
-### Execute Once (Default)
-
-The simplest mode executes an activity exactly once per context:
-
-```js
-class MyAction {
-  setup(builder) {
-    builder.do("processItem", ctx => {
-      ctx.result = ctx.input * 2
-    })
-  }
-}
-```
-
-### WHILE Mode
-
-Loops while a predicate returns `true`. The predicate is evaluated **before** each iteration:
-
-```js
-import { ActionBuilder, ACTIVITY } from "@gesslar/actioneer"
-
-class CounterAction {
-  #shouldContinue = (ctx) => ctx.count < 10
-
-  #increment = (ctx) => {
-    ctx.count += 1
-  }
-
-  setup(builder) {
-    builder
-      .do("initialize", ctx => { ctx.count = 0 })
-      .do("countUp", ACTIVITY.WHILE, this.#shouldContinue, this.#increment)
-      .do("finish", ctx => { return ctx.count })
-  }
-}
-```
-
-The activity will continue executing as long as the predicate returns `true`. Once it returns `false`, execution moves to the next activity.
-
-### UNTIL Mode
-
-Loops until a predicate returns `true`. The predicate is evaluated **after** each iteration:
-
-```js
-import { ActionBuilder, ACTIVITY } from "@gesslar/actioneer"
-
-class ProcessorAction {
-  #queueIsEmpty = (ctx) => ctx.queue.length === 0
-
-  #processItem = (ctx) => {
-    const item = ctx.queue.shift()
-    ctx.processed.push(item)
-  }
-
-  setup(builder) {
-    builder
-      .do("initialize", ctx => {
-        ctx.queue = [1, 2, 3, 4, 5]
-        ctx.processed = []
-      })
-      .do("process", ACTIVITY.UNTIL, this.#queueIsEmpty, this.#processItem)
-      .do("finish", ctx => { return ctx.processed })
-  }
-}
-```
-
-The activity executes at least once, then continues while the predicate returns `false`. Once it returns `true`, execution moves to the next activity.
-
-### IF Mode
-
-Conditionally executes an activity based on a predicate. Unlike WHILE/UNTIL, IF executes at most once:
-
-```js
-import { ActionBuilder, ACTIVITY } from "@gesslar/actioneer"
-
-class ConditionalAction {
-  #shouldProcess = (ctx) => ctx.value > 10
-
-  #processLargeValue = (ctx) => {
-    ctx.processed = ctx.value * 2
-  }
-
-  setup(builder) {
-    builder
-      .do("initialize", ctx => { ctx.value = 15 })
-      .do("maybeProcess", ACTIVITY.IF, this.#shouldProcess, this.#processLargeValue)
-      .do("finish", ctx => { return ctx })
-  }
-}
-```
-
-If the predicate returns `true`, the activity executes once. If `false`, the activity is skipped entirely and execution moves to the next activity.
-
-### BREAK Mode
-
-Breaks out of a WHILE or UNTIL loop when a predicate returns `true`. BREAK must be used inside a nested ActionBuilder within a loop:
-
-```js
-import { ActionBuilder, ACTIVITY } from "@gesslar/actioneer"
-
-class BreakExample {
-  setup(builder) {
-    builder
-      .do("initialize", ctx => {
-        ctx.count = 0
-        ctx.items = []
-      })
-      .do("loop", ACTIVITY.WHILE, ctx => ctx.count < 100,
-        new ActionBuilder()
-          .do("increment", ctx => {
-            ctx.count++
-            ctx.items.push(ctx.count)
-            return ctx
-          })
-          .do("earlyExit", ACTIVITY.BREAK, ctx => ctx.count >= 5)
-      )
-      .do("finish", ctx => { return ctx.items }) // Returns [1, 2, 3, 4, 5]
-  }
-}
-```
-
-When the BREAK predicate returns `true`, the loop terminates immediately and execution continues with the next activity after the loop.
-
-**Important:** BREAK only works inside a nested ActionBuilder that is the operation of a WHILE or UNTIL activity. Using BREAK outside of a loop context will throw an error.
-
-### CONTINUE Mode
-
-Skips the remaining activities in the current loop iteration and continues to the next iteration. Like BREAK, CONTINUE must be used inside a nested ActionBuilder within a loop:
-
-```js
-import { ActionBuilder, ACTIVITY } from "@gesslar/actioneer"
-
-class ContinueExample {
-  setup(builder) {
-    builder
-      .do("initialize", ctx => {
-        ctx.count = 0
-        ctx.processed = []
-      })
-      .do("loop", ACTIVITY.WHILE, ctx => ctx.count < 5,
-        new ActionBuilder()
-          .do("increment", ctx => {
-            ctx.count++
-            return ctx
-          })
-          .do("skipEvens", ACTIVITY.CONTINUE, ctx => ctx.count % 2 === 0)
-          .do("process", ctx => {
-            ctx.processed.push(ctx.count)
-            return ctx
-          })
-      )
-      .do("finish", ctx => { return ctx.processed }) // Returns [1, 3, 5]
-  }
-}
-```
-
-When the CONTINUE predicate returns `true`, the remaining activities in that iteration are skipped, and the loop continues with its next iteration (re-evaluating the loop predicate for WHILE, or executing the operation then evaluating for UNTIL).
-
-**Important:** Like BREAK, CONTINUE only works inside a nested ActionBuilder within a WHILE or UNTIL loop.
-
-### Combining Control Flow
-
-You can combine IF, BREAK, and CONTINUE within the same loop for complex control flow:
-
-```js
-class CombinedExample {
-  setup(builder) {
-    builder
-      .do("initialize", ctx => {
-        ctx.count = 0
-        ctx.results = []
-      })
-      .do("loop", ACTIVITY.WHILE, ctx => ctx.count < 100,
-        new ActionBuilder()
-          .do("increment", ctx => { ctx.count++; return ctx })
-          .do("exitAt10", ACTIVITY.BREAK, ctx => ctx.count > 10)
-          .do("skipEvens", ACTIVITY.CONTINUE, ctx => ctx.count % 2 === 0)
-          .do("processLarge", ACTIVITY.IF, ctx => ctx.count > 5, ctx => {
-            ctx.results.push(ctx.count * 10)
-            return ctx
-          })
-          .do("processAll", ctx => {
-            ctx.results.push(ctx.count)
-            return ctx
-          })
-      )
-  }
-}
-// Results: [1, 3, 5, 70, 7, 90, 9]
-// - 1, 3, 5: odd numbers <= 5, just pushed
-// - 7, 9: odd numbers > 5, pushed with *10 first, then pushed
-// - evens skipped by CONTINUE
-// - loop exits when count > 10
-```
-
-### SPLIT Mode
-
-Executes with a split/rejoin pattern for parallel execution. This mode requires a splitter function to divide the context and a rejoiner function to recombine results:
-
-```js
-import { ActionBuilder, ACTIVITY } from "@gesslar/actioneer"
-
-class ParallelProcessor {
-  #split = (ctx) => {
-    // Split context into multiple items for parallel processing
-    return ctx.items.map(item => ({ item, processedBy: "worker" }))
-  }
-
-  #rejoin = (originalCtx, splitResults) => {
-    // Recombine parallel results back into original context
-    originalCtx.results = splitResults.map(r => r.item)
-    return originalCtx
-  }
-
-  #processItem = (ctx) => {
-    ctx.item = ctx.item.toUpperCase()
-  }
-
-  setup(builder) {
-    builder
-      .do("initialize", ctx => {
-        ctx.items = ["apple", "banana", "cherry"]
-      })
-      .do("parallel", ACTIVITY.SPLIT, this.#split, this.#rejoin, this.#processItem)
-      .do("finish", ctx => { return ctx.results })
-  }
-}
-```
-
-**How SPLIT Mode Works:**
-
-1. The **splitter** function receives the context and returns an array of contexts (one per parallel task)
-2. Each split context is processed in parallel through the **operation** function
-3. The **rejoiner** function receives the original context and the array of settled results from `Promise.allSettled()`
-4. The rejoiner combines the results and returns the updated context
-
-**Important: SPLIT uses `Promise.allSettled()`**
-
-The SPLIT mode uses `Promise.allSettled()` internally to execute parallel operations. This means your **rejoiner** function will receive an array of settlement objects, not the raw context values. Each element in the array will be either:
-
-- `{ status: "fulfilled", value: <result> }` for successful operations
-- `{ status: "rejected", reason: <error> }` for failed operations
-
-Your rejoiner must handle settled results accordingly. You can process them however you need - check each `status` manually, or use helper utilities like those in `@gesslar/toolkit`:
-
-```js
-import { Util } from "@gesslar/toolkit"
-
-#rejoin = (originalCtx, settledResults) => {
-  // settledResults is an array of settlement objects
-  // Each has either { status: "fulfilled", value: ... }
-  // or { status: "rejected", reason: ... }
-
-  // Example: extract only successful results
-  originalCtx.results = Util.fulfilledValues(settledResults)
-
-  // Example: check for any failures
-  if (Util.anyRejected(settledResults)) {
-    originalCtx.errors = Util.rejectedReasons(
-      Util.settledAndRejected(settledResults)
-    )
-  }
-
-  return originalCtx
-}
-```
-
-**Nested Pipelines with SPLIT:**
-
-You can use nested ActionBuilders with SPLIT mode for complex parallel workflows:
-
-```js
-class NestedParallel {
-  #split = (ctx) => ctx.batches.map(batch => ({ batch }))
-
-  #rejoin = (original, results) => {
-    original.processed = results.flatMap(r => r.batch)
-    return original
-  }
-
-  setup(builder) {
-    builder
-      .do("parallel", ACTIVITY.SPLIT, this.#split, this.#rejoin,
-        new ActionBuilder(this)
-          .do("step1", ctx => { /* ... */ })
-          .do("step2", ctx => { /* ... */ })
-      )
-  }
-}
-```
-
-### Mode Constraints
-
-- **Only one mode per activity**: Each activity can have only one mode. Attempting to combine modes will throw an error
-- **SPLIT requires both functions**: The splitter and rejoiner are both mandatory for SPLIT mode
-- **Predicates must return boolean**: All predicates (WHILE, UNTIL, IF, BREAK, CONTINUE) should return `true` or `false`
-- **BREAK/CONTINUE require loop context**: These modes only work inside a nested ActionBuilder within a WHILE or UNTIL loop
-
-### Mode Summary Table
-
-| Mode         | Signature                                                  | Predicate Timing | Use Case                                    |
-| ------------ | ---------------------------------------------------------- | ---------------- | ------------------------------------------- |
-| **Default**  | `.do(name, operation)`                                     | N/A              | Execute once per context                    |
-| **WHILE**    | `.do(name, ACTIVITY.WHILE, predicate, operation)`          | Before iteration | Loop while condition is true                |
-| **UNTIL**    | `.do(name, ACTIVITY.UNTIL, predicate, operation)`          | After iteration  | Loop until condition is true                |
-| **IF**       | `.do(name, ACTIVITY.IF, predicate, operation)`             | Before execution | Conditional execution (once or skip)        |
-| **BREAK**    | `.do(name, ACTIVITY.BREAK, predicate)`                     | When reached     | Exit enclosing WHILE/UNTIL loop             |
-| **CONTINUE** | `.do(name, ACTIVITY.CONTINUE, predicate)`                  | When reached     | Skip to next iteration of enclosing loop    |
-| **SPLIT**    | `.do(name, ACTIVITY.SPLIT, splitter, rejoiner, operation)` | N/A              | Parallel execution with split/rejoin        |
-
-## Running Actions: `run()` vs `pipe()`
-
-ActionRunner provides two methods for executing your action pipelines:
-
-### `run(context)` - Single Context Execution
-
-Executes the pipeline once with a single context. Returns the final context value directly, or throws if an error occurs.
-
-```js
-const builder = new ActionBuilder(new MyAction())
-const runner = new ActionRunner(builder)
-
-try {
-  const result = await runner.run({input: "data"})
-  console.log(result) // Final context value
-} catch (error) {
-  console.error("Pipeline failed:", error)
-}
-```
-
-**Use `run()` when:**
-
-- Processing a single context
-- You want errors to throw immediately
-- You prefer traditional try/catch error handling
-
-### `pipe(contexts, maxConcurrent)` - Concurrent Batch Execution
-
-Executes the pipeline concurrently across multiple contexts with a configurable concurrency limit. Returns an array of **settled results** - never throws on individual pipeline failures.
-
-```js
-const builder = new ActionBuilder(new MyAction())
-const runner = new ActionRunner(builder)
-
-const contexts = [{id: 1}, {id: 2}, {id: 3}]
-const results = await runner.pipe(contexts, 4) // Max 4 concurrent
-
-results.forEach((result, i) => {
-  if (result.status === "fulfilled") {
-    console.log(`Context ${i} succeeded:`, result.value)
-  } else {
-    console.error(`Context ${i} failed:`, result.reason)
-  }
-})
-```
-
-**Use `pipe()` when:**
-
-- Processing multiple contexts in parallel
-- You want to control concurrency (default: 10)
-- You need all results (both successes and failures)
-- Error handling should be at the call site
-
-**Important: `pipe()` returns settled results**
-
-The `pipe()` method uses `Promise.allSettled()` internally and returns an array of settlement objects:
-
-- `{status: "fulfilled", value: <result>}` for successful executions
-- `{status: "rejected", reason: <error>}` for failed executions
-
-This design ensures error handling responsibility stays at the call site - you decide how to handle failures rather than the framework deciding for you.
-
-## Pipeline Completion: `done()`
-
-The `done()` method registers a callback that executes after all activities in the pipeline complete, regardless of whether an error occurred. This is useful for cleanup, finalization, or returning a transformed result.
-
-```js
-import { ActionBuilder, ActionRunner } from "@gesslar/actioneer"
-
-class MyAction {
-  setup(builder) {
-    builder
-      .do("step1", ctx => { ctx.a = 1 })
-      .do("step2", ctx => { ctx.b = 2 })
-      .done(ctx => {
-        // This runs after all activities complete
-        return { total: ctx.a + ctx.b }
-      })
-  }
-}
-
-const builder = new ActionBuilder(new MyAction())
-const runner = new ActionRunner(builder)
-const result = await runner.run({})
-console.log(result) // { total: 3 }
-```
-
-### Key Behaviors
-
-- **Always executes**: The `done()` callback runs even if an earlier activity throws an error (similar to `finally` in try/catch)
-- **Top-level only**: The callback only runs for the outermost pipeline, not for nested builders inside loops (WHILE/UNTIL). However, for SPLIT activities, `done()` runs for each split context since each is an independent execution
-- **Transform the result**: Whatever you return from `done()` becomes the final pipeline result
-- **Access to action context**: The callback is bound to the action instance, so `this` refers to your action class
-- **Async support**: The callback can be async and return a Promise
-
-### Use Cases
-
-**Cleanup resources:**
-
-```js
-builder
-  .do("openConnection", ctx => { ctx.conn = openDb() })
-  .do("query", ctx => { ctx.data = ctx.conn.query("SELECT *") })
-  .done(ctx => {
-    ctx.conn.close() // Always close, even on error
-    return ctx.data
-  })
-```
-
-**Transform the final result:**
-
-```js
-builder
-  .do("gather", ctx => { ctx.items = [1, 2, 3] })
-  .do("process", ctx => { ctx.items = ctx.items.map(x => x * 2) })
-  .done(ctx => ctx.items) // Return just the items array, not the whole context
-```
-
-**Logging and metrics:**
-
-```js
-builder
-  .do("start", ctx => { ctx.startTime = Date.now() })
-  .do("work", ctx => { /* ... */ })
-  .done(ctx => {
-    console.log(`Pipeline completed in ${Date.now() - ctx.startTime}ms`)
-    return ctx
-  })
-```
-
-## ActionHooks
-
-Actioneer supports lifecycle hooks that can execute before and after each activity in your pipeline. Hooks can be configured by file path (Node.js only) or by providing a pre-instantiated hooks object (Node.js and browser).
-
-### Hook System Overview
-
-The hook system allows you to:
-
-- Execute code before and after each activity in your pipeline
-- Implement setup and cleanup logic
-- Add observability and logging to your pipelines
-- Modify or inspect the context flowing through activities
-
-### Configuring Hooks
-
-#### Browser: Pre-instantiated Hooks
-
-In browser environments, you must provide pre-instantiated hooks objects:
-
-```js
-import {ActionBuilder, ActionRunner} from "@gesslar/actioneer"
-
-class MyActionHooks {
-  constructor({debug}) {
-    this.debug = debug
-  }
-
-  async before$prepare(context) {
-    this.debug("About to prepare", context)
-  }
-
-  async after$prepare(context) {
-    this.debug("Finished preparing", context)
-  }
-}
-
-const hooks = new MyActionHooks({debug: console.log})
-
-class MyAction {
-  setup(builder) {
-    builder
-      .withHooks(hooks)
-      .do("prepare", ctx => { ctx.count = 0 })
-      .do("work", ctx => { ctx.count += 1 })
-  }
-}
-
-const builder = new ActionBuilder(new MyAction())
-const runner = new ActionRunner(builder)
-const result = await runner.pipe([{}], 4)
-```
-
-#### Node.js: File-based or Pre-instantiated
-
-**Option 1: Load hooks from a file** (Node.js only)
-
-```js
-import {ActionBuilder, ActionRunner} from "@gesslar/actioneer"
-
-class MyAction {
-  setup(builder) {
-    builder
-      .withHooksFile("./hooks/MyActionHooks.js", "MyActionHooks")
-      .do("prepare", ctx => { ctx.count = 0 })
-      .do("work", ctx => { ctx.count += 1 })
-  }
-}
-
-const builder = new ActionBuilder(new MyAction())
-const runner = new ActionRunner(builder)
-const result = await runner.pipe([{}], 4)
-```
-
-**Option 2: Provide a pre-instantiated hooks object** (Node.js and browser)
-
-```js
-import {ActionBuilder, ActionRunner} from "@gesslar/actioneer"
-import {MyActionHooks} from "./hooks/MyActionHooks.js"
-
-const hooks = new MyActionHooks({debug: console.log})
-
-class MyAction {
-  setup(builder) {
-    builder
-      .withHooks(hooks)
-      .do("prepare", ctx => { ctx.count = 0 })
-      .do("work", ctx => { ctx.count += 1 })
-  }
-}
-
-const builder = new ActionBuilder(new MyAction())
-const runner = new ActionRunner(builder)
-const result = await runner.pipe([{}], 4)
-```
-
-### Writing Hooks
-
-Hooks are classes exported from a module. The hook methods follow a naming convention: `event$activityName`.
-
-```js
-// hooks/MyActionHooks.js
-export class MyActionHooks {
-  constructor({ debug }) {
-    this.debug = debug
-  }
-
-  // Hook that runs before the "prepare" activity
-  async before$prepare(context) {
-    this.debug("About to prepare", context)
-  }
-
-  // Hook that runs after the "prepare" activity
-  async after$prepare(context) {
-    this.debug("Finished preparing", context)
-  }
-
-  // Hook that runs before the "work" activity
-  async before$work(context) {
-    this.debug("Starting work", context)
-  }
-
-  // Hook that runs after the "work" activity
-  async after$work(context) {
-    this.debug("Work complete", context)
-  }
-
-  // Optional: setup hook runs once at initialization
-  async setup(args) {
-    this.debug("Hooks initialized")
-  }
-
-  // Optional: cleanup hook for teardown
-  async cleanup(args) {
-    this.debug("Hooks cleaned up")
-  }
-}
-```
-
-### Hook Naming Convention
-
-Activity names are transformed to hook method names:
-
-- Spaces are removed and words are camelCased: `"do work"` → `before$doWork` / `after$doWork`
-- Non-word characters are stripped: `"step-1"` → `before$step1` / `after$step1`
-- First word stays lowercase: `"Prepare Data"` → `before$prepareData` / `after$prepareData`
-
-### Hook Timeout
-
-By default, hooks have a 1-second (1000ms) timeout. If a hook exceeds this timeout, the pipeline will throw a `Sass` error. You can configure the timeout when creating the hooks:
-
-```js
-new ActionHooks({
-  actionKind: "MyActionHooks",
-  hooksFile: "./hooks.js",
-  hookTimeout: 5000, // 5 seconds
-  debug: console.log
-})
-```
-
-### Nested Pipelines and Hooks
-
-When you nest ActionBuilders (for branching or parallel execution), the parent's hooks are automatically passed to all children, ensuring consistent hook behavior throughout the entire pipeline hierarchy.
-
-### Optional TypeScript (local, opt-in)
-
-This project intentionally avoids committing TypeScript tool configuration. If you'd like to use TypeScript's checker locally (for editor integration or optional JSDoc checking), you can drop a `tsconfig.json` in your working copy — `tsconfig.json` is already in the repository `.gitignore`, so feel free to typecheck yourselves into oblivion.
-
-Two common local options:
-
-- Editor/resolve-only (no checking): set `moduleResolution`/`module` and `noEmit` so the editor resolves imports consistently without typechecking.
-- Local JSDoc checks: set `allowJs: true` and `checkJs: true` with `noEmit: true` and `strict: false` to let the TypeScript checker validate JSDoc without enforcing strict typing.
-
-Examples of minimal configs and one-liners to run them are in the project discussion; use them locally if you want an optional safety net. The repository will not require or enforce these files.
+- [Activity Modes](https://actioneer.gesslar.io/guides/activity-modes/) — the six execution modes (`WHILE`, `UNTIL`, `IF`, `BREAK`, `CONTINUE`, `SPLIT`)
+- [Control Flow](https://actioneer.gesslar.io/guides/control-flow/) — `BREAK` and `CONTINUE` inside loops
+- [Parallelism with SPLIT](https://actioneer.gesslar.io/guides/split/) — split/rejoin and settled results
+- [run() vs pipe()](https://actioneer.gesslar.io/guides/run-vs-pipe/) — single vs concurrent execution
+- [Finalizing with done()](https://actioneer.gesslar.io/guides/done/) — cleanup and result shaping
+- [Lifecycle Hooks](https://actioneer.gesslar.io/guides/hooks/) — `before$` / `after$` hooks
+- [API Reference](https://actioneer.gesslar.io/reference/action-builder/) — `ActionBuilder`, `ActionRunner`, `Activity`, `ActionHooks`, `Piper`
 
 ## Testing
 
@@ -770,7 +164,7 @@ Tests are organized in `tests/unit/` with one file per class. All tests use Node
 
 ## Publishing
 
-This repository is prepared for npm publishing. The package uses ESM and targets Node 20+. The `files` field includes the `src/` folder and types. If you publish, ensure the `version` in `package.json` is updated and you have an npm token configured on the CI runner.
+This repository is prepared for npm publishing. The package uses ESM and targets Node 24+. The `files` field includes the `src/` folder and types. If you publish, ensure the `version` in `package.json` is updated and you have an npm token configured on the CI runner.
 
 A simple publish checklist:
 
@@ -784,17 +178,6 @@ A simple publish checklist:
 
 Contributions and issues are welcome. Please open issues for feature requests or bugs. If you're submitting a PR, include tests for new behavior where possible.
 
-## License
-
-`@gesslar/actioneer` is released into the public domain under the [Unlicense](LICENSE.txt).
-
-This package includes or depends on third-party components under their own
-licenses:
-
-| Dependency | License |
-| --- | --- |
-| [@gesslar/toolkit](https://github.com/gesslar/toolkit) | 0BSD |
-
 ## Most Portum
 
 As this is my repo, I have some opinions I would like to express and be made clear.
@@ -804,3 +187,14 @@ As this is my repo, I have some opinions I would like to express and be made cle
 - Thank you, I love you. BYEBYE!
 
 🤗
+
+## License
+
+`@gesslar/actioneer` is released under the [0BSD](LICENSE.txt).
+
+This package includes or depends on third-party components under their own
+licenses:
+
+| Dependency | License |
+| --- | --- |
+| [@gesslar/toolkit](https://github.com/gesslar/toolkit) | 0BSD |

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "3.0.1",
+  "version": "3.1.0",
   "license": "0BSD",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {
@@ -41,11 +41,11 @@
   },
   "files": [
     "src/",
-    "UNLICENSE.txt"
+    "LICENSE.txt"
   ],
   "sideEffects": false,
   "engines": {
-    "node": ">=24.11.0"
+    "node": ">=24"
   },
   "scripts": {
     "lint": "eslint src/",
@@ -62,11 +62,11 @@
     "major": "npm version major"
   },
   "dependencies": {
-    "@gesslar/toolkit": "^5.0.0"
+    "@gesslar/toolkit": "^5.5.2"
   },
   "devDependencies": {
-    "@gesslar/uglier": "^2.4.0",
-    "eslint": "^10.2.0",
-    "typescript": "^6.0.2"
+    "@gesslar/uglier": "^2.4.1",
+    "eslint": "^10.4.1",
+    "typescript": "^6.0.3"
   }
 }

package/src/browser/lib/ActionBuilder.js

@@ -51,6 +51,16 @@ import {ACTIVITY} from "./Activity.js"
  * @class ActionBuilder
  */
 export default class ActionBuilder {
+  /**
+   * The ActionHooks class used to resolve hooks. Defaults to the
+   * browser-compatible implementation (pre-instantiated hooks only). The Node
+   * entry point overrides this with the file-loading subclass so that
+   * {@link ActionBuilder#withHooksFile} works.
+   *
+   * @type {typeof ActionHooks}
+   */
+  static HooksClass = ActionHooks
+
   /** @type {ActionBuilderAction?} */
   #action = null
   /** @type {Map<string|symbol, ActivityDefinition>} */
@@ -334,23 +344,29 @@ export default class ActionBuilder {
   }
 
   async #getHooks() {
-    const newHooks = ActionHooks.new
+    const HooksClass = ActionBuilder.HooksClass
 
     const hooks = this.#hooks
     if(hooks) {
-      // If hooks is already an ActionHooks instance, use it directly
+      // If hooks is already an ActionHooks instance, use it directly.
+      // The base class catches subclass instances too.
       if(hooks instanceof ActionHooks)
         return hooks
 
       // Otherwise, wrap it in a new ActionHooks instance
-      return await newHooks({hooks}, this.#debug)
+      return await HooksClass.new({hooks}, this.#debug)
     }
 
     const hooksFile = this.#hooksFile
     const hooksKind = this.#hooksKind
 
+    // File loading is only available on the Node HooksClass; the loader keys the
+    // class to instantiate off `actionKind`.
     if(hooksFile && hooksKind)
-      return await newHooks({hooksFile,hooksKind}, this.#debug)
+      return await HooksClass.new(
+        {hooksFile, actionKind: hooksKind},
+        this.#debug,
+      )
   }
 
   /**

package/src/browser/lib/ActionRunner.js

@@ -63,7 +63,25 @@ export default class ActionRunner extends Piper {
   }
 
   /**
-   * Invokes the `setup` lifecycle hook on the raw hooks object, if defined.
+   * Builds the ActionWrapper on first use and caches it for subsequent calls.
+   *
+   * Hooks are configured by the action's `setup()`, which only runs during
+   * `build()`. The setup/cleanup lifecycle hooks fire from {@link Piper#pipe}
+   * before any item is processed, so the wrapper must be built here too —
+   * otherwise the resolved hooks would not yet exist when setup runs.
+   *
+   * @returns {Promise<import("./ActionWrapper.js").default>} The built wrapper.
+   * @private
+   */
+  async #ensureBuilt() {
+    if(!this.#actionWrapper)
+      this.#actionWrapper = await this.#actionBuilder.build(this)
+
+    return this.#actionWrapper
+  }
+
+  /**
+   * Invokes the `setup` lifecycle hook on the resolved hooks object, if defined.
    * Registered as a Piper setup step so it fires before any items are processed.
    *
    * @param {unknown} ctx - Value passed by {@link Piper#pipe} (the items array).
@@ -71,29 +89,30 @@ export default class ActionRunner extends Piper {
    * @private
    */
   async #setupHooks(ctx) {
-    const ab = this.#actionBuilder
-    const ah = ab?.hooks
+    const wrapper = await this.#ensureBuilt()
+    const ah = wrapper.hooks
     const setup = ah?.setup
 
     if(setup)
-      await setup.call(ah, ctx)
+      await setup.call(ah.hooks, ctx)
   }
 
   /**
-   * Invokes the `cleanup` lifecycle hook on the raw hooks object, if defined.
-   * Registered as a Piper teardown step so it fires after all items are processed.
+   * Invokes the `cleanup` lifecycle hook on the resolved hooks object, if
+   * defined. Registered as a Piper teardown step so it fires after all items
+   * are processed.
    *
    * @param {unknown} ctx - Value passed by {@link Piper#pipe} (the items array).
    * @returns {Promise<void>}
    * @private
    */
   async #cleanupHooks(ctx) {
-    const ab = this.#actionBuilder
-    const ah = ab?.hooks
+    const wrapper = await this.#ensureBuilt()
+    const ah = wrapper.hooks
     const cleanup = ah?.cleanup
 
     if(cleanup)
-      await cleanup.call(ah, ctx)
+      await cleanup.call(ah.hooks, ctx)
   }
 
   /**
@@ -108,10 +127,7 @@ export default class ActionRunner extends Piper {
    * @throws {Tantrum} When both an activity and the done callback fail.
    */
   async run(context, parentWrapper=null) {
-    if(!this.#actionWrapper)
-      this.#actionWrapper = await this.#actionBuilder.build(this)
-
-    const actionWrapper = this.#actionWrapper
+    const actionWrapper = await this.#ensureBuilt()
     const activities = Array.from(actionWrapper.activities)
 
     let caughtError = null

package/src/browser/lib/ActionWrapper.js

@@ -113,4 +113,13 @@ export default class ActionWrapper {
   get action() {
     return this.#action
   }
+
+  /**
+   * Get the resolved hooks manager.
+   *
+   * @returns {import("./ActionHooks.js").default?} Hooks manager or null.
+   */
+  get hooks() {
+    return this.#hooks
+  }
 }

package/src/browser/lib/Piper.js

@@ -170,9 +170,9 @@ export default class Piper extends NotifyClass {
    * @param {Array<unknown>} settled - Results from settleAll
    * @throws {Tantrum} - If any settled result was rejected
    */
-  #processResult(_message, settled) {
+  #processResult(message, settled) {
     if(Promised.hasRejected(settled))
-      Promised.throw(settled)
+      Promised.throw(message, settled)
   }
 
   /**

package/src/index.js

@@ -1,9 +1,14 @@
 // Browser-compatible base classes
-export {default as ActionBuilder} from "./browser/lib/ActionBuilder.js"
+import ActionBuilder from "./browser/lib/ActionBuilder.js"
+import ActionHooks from "./lib/ActionHooks.js"
+
+// Node-enhanced ActionHooks (extends browser, adds FileObject support). Wiring
+// it into the builder makes withHooksFile() load hooks from disk under the Node
+// entry point, while the browser entry keeps the pre-instantiated-only default.
+ActionBuilder.HooksClass = ActionHooks
+
+export {ActionBuilder, ActionHooks}
 export {default as ActionRunner} from "./browser/lib/ActionRunner.js"
 export {default as ActionWrapper} from "./browser/lib/ActionWrapper.js"
 export {default as Activity, ACTIVITY} from "./browser/lib/Activity.js"
 export {default as Piper} from "./browser/lib/Piper.js"
-
-// Node-enhanced version (extends browser, adds FileObject support)
-export {default as ActionHooks} from "./lib/ActionHooks.js"

package/src/lib/ActionHooks.js

@@ -75,11 +75,11 @@ export default class ActionHooks extends BrowserActionHooks {
 
     const hooksFile = new FileObject(config.hooksFile)
 
-    debug("Loading hooks from %o", 2, hooksFile.uri)
-    debug("Checking hooks file exists: %o", 2, hooksFile.uri)
+    debug("Loading hooks from %o", 2, hooksFile.path)
+    debug("Checking hooks file exists: %o", 2, hooksFile.path)
 
     if(!await hooksFile.exists)
-      throw Sass.new(`No such hooks file, ${hooksFile.uri}`)
+      throw Sass.new(`No such hooks file, ${hooksFile.path}`)
 
     try {
       const hooksImport = await hooksFile.import()
@@ -100,7 +100,7 @@ export default class ActionHooks extends BrowserActionHooks {
       // Create instance with loaded hooks
       return new ActionHooks({...config, hooks, debug})
     } catch(error) {
-      debug("Failed to load hooks %o: %o", 1, hooksFile.uri, error.message)
+      debug("Failed to load hooks %o: %o", 1, hooksFile.path, error.message)
 
       return null
     }

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

@@ -44,6 +44,15 @@
  * @class ActionBuilder
  */
 export default class ActionBuilder {
+    /**
+     * The ActionHooks class used to resolve hooks. Defaults to the
+     * browser-compatible implementation (pre-instantiated hooks only). The Node
+     * entry point overrides this with the file-loading subclass so that
+     * {@link ActionBuilder#withHooksFile} works.
+     *
+     * @type {typeof ActionHooks}
+     */
+    static HooksClass: typeof ActionHooks;
     /**
      * Creates a new ActionBuilder instance with the provided action callback.
      *

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;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBE;;;;;OAKG;IACH,qBAHW,mBAAmB,mBACnB,mBAAmB,EAkB7B;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,WAAW,GACT,aAAa,CAgBzB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,aAAa,CAczB;IAED;;;;;OAKG;IACH,eAHW,cAAc,GACZ,aAAa,CAOzB;IAeD;;;;;;OAMG;IACH,cAHW,YAAY,GACV,OAAO,CAAC,aAAa,CAAC,CAoClC;IAsBD;;;;;OAKG;IACH,aAFa,MAAM,cAAU,IAAI,CAIhC;;CACF;;;;sBAjWY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;;;;WAGjE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;YAQhC,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;;;;;6BAE/C,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC;wBA1BnC,kBAAkB;6CAMA,mBAAmB;0BAPnC,oBAAoB"}
+{"version":3,"file":"ActionBuilder.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionBuilder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACE;;;;;;;OAOG;IACH,mBAFU,OAAO,WAAW,CAEG;IAmB/B;;;;;OAKG;IACH,qBAHW,mBAAmB,mBACnB,mBAAmB,EAkB7B;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,WAAW,GACT,aAAa,CAgBzB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,aAAa,CAczB;IAED;;;;;OAKG;IACH,eAHW,cAAc,GACZ,aAAa,CAOzB;IAeD;;;;;;OAMG;IACH,cAHW,YAAY,GACV,OAAO,CAAC,aAAa,CAAC,CAoClC;IA4BD;;;;;OAKG;IACH,aAFa,MAAM,cAAU,IAAI,CAIhC;;CACF;;;;sBAjXY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;;;;WAGjE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;YAQhC,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;;;;;6BAE/C,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC;wBA1BnC,kBAAkB;6CAMA,mBAAmB;0BAPnC,oBAAoB"}

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;;;;;GAKG;AACH;;;;;GAKG;AAEH;;;;;;GAMG;AACH;IAaE;;;;;OAKG;IACH,2BAHW,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,cACzC,mBAAmB,EAoB7B;IAoCD;;;;;;;;;;OAUG;IACH,aANW,OAAO,kBACP,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,GACvC,OAAO,CAAC,OAAO,CAAC,CAoJ5B;;CAiGF;sBAlVY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;;;kBAT7D,YAAY"}
+{"version":3,"file":"ActionRunner.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionRunner.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;;;;;GAKG;AAEH;;;;;;GAMG;AACH;IAaE;;;;;OAKG;IACH,2BAHW,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,cACzC,mBAAmB,EAoB7B;IAuDD;;;;;;;;;;OAUG;IACH,aANW,OAAO,kBACP,OAAO,oBAAoB,EAAE,OAAO,GAAC,IAAI,GACvC,OAAO,CAAC,OAAO,CAAC,CAiJ5B;;CAiGF;sBAlWY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;;;;;;;kBAT7D,YAAY"}

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

@@ -58,6 +58,12 @@ export default class ActionWrapper {
      * @returns {unknown|null} Action instance or null.
      */
     get action(): unknown | null;
+    /**
+     * Get the resolved hooks manager.
+     *
+     * @returns {import("./ActionHooks.js").default?} Hooks manager or null.
+     */
+    get hooks(): import("./ActionHooks.js").default | null;
     #private;
 }
 export type WrappedActivityConfig = {

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

@@ -1 +1 @@
-{"version":3,"file":"ActionWrapper.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionWrapper.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AACH;IAwBE;;;;;;;;;OASG;IACH,sEANG;QAAwD,UAAU,EAA1D,GAAG,CAAC,MAAM,GAAC,MAAM,EAAE,qBAAqB,CAAC;QACgC,KAAK,EAA9E,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;QACxB,KAAK,EAA/C,OAAO,kBAAkB,EAAE,OAAO,OAAC;QAC0B,IAAI,cAAtD,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC;QAChC,MAAM,GAArB,OAAO;KACjB,EAuBA;IAED;;;;;OAKG;IACH,UAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,kBAFa,QAAQ,CAAC,QAAQ,CAAC,CAI9B;IAED;;;;OAIG;IACH,YAFa,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAC,IAAI,CAIjE;IAED;;;;OAIG;IACH,cAFa,OAAO,GAAC,IAAI,CAIxB;;CACF;;;;;UAzGa,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;;qBAf3D,eAAe"}
+{"version":3,"file":"ActionWrapper.d.ts","sourceRoot":"","sources":["../../../browser/lib/ActionWrapper.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AACH;IAwBE;;;;;;;;;OASG;IACH,sEANG;QAAwD,UAAU,EAA1D,GAAG,CAAC,MAAM,GAAC,MAAM,EAAE,qBAAqB,CAAC;QACgC,KAAK,EAA9E,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI;QACxB,KAAK,EAA/C,OAAO,kBAAkB,EAAE,OAAO,OAAC;QAC0B,IAAI,cAAtD,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC;QAChC,MAAM,GAArB,OAAO;KACjB,EAuBA;IAED;;;;;OAKG;IACH,UAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,kBAFa,QAAQ,CAAC,QAAQ,CAAC,CAI9B;IAED;;;;OAIG;IACH,YAFa,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAC,IAAI,CAIjE;IAED;;;;OAIG;IACH,cAFa,OAAO,GAAC,IAAI,CAIxB;IAED;;;;OAIG;IACH,aAFa,OAAO,kBAAkB,EAAE,OAAO,OAAC,CAI/C;;CACF;;;;;UAlHa,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;;qBAf3D,eAAe"}

package/src/types/index.d.ts

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

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

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