@wpkernel/pipeline 0.12.3-beta.2 → 0.12.6-beta.0

package/README.md

@@ -1,20 +1,34 @@
 # @wpkernel/pipeline
 
-> Framework-agnostic orchestration primitives for building dependency-aware execution pipelines with atomic rollback.
+> A type-safe, dependency-aware workflow engine for orchestrating complex generation tasks.
 
 ## Overview
 
-`@wpkernel/pipeline` powers every generation flow inside WPKernel. It was extracted from
-`@wpkernel/core` so CLI builders, PHP bridges, and external projects can compose helpers,
-validate dependencies, and execute deterministic plans. The runtime enforces a three-phase
-model (fragments → builders → extensions) and provides rich diagnostics when helpers clash or
-dependencies are missing.
+`@wpkernel/pipeline` is a generic orchestration engine that turns sets of decoupled "helpers" into deterministic, topologically sorted execution plans.
 
-## Quick links
+While it powers WPKernel's code generation (assembling fragments into artifacts), the core is completely agnostic. You can use it to build:
 
-- [Package guide](../../docs/packages/pipeline.md)
-- [API reference](../../docs/api/@wpkernel/pipeline/README.md)
-- [PHP codemod roadmap](../../docs/internal/php-json-ast-codemod-plan.md)
+- **ETL Pipelines**: Extract, Transform, and Load stages with shared state.
+- **Build Systems**: Compile, Bundle, and Minify steps with precise ordering.
+- **Code Generators**: The standard "Fragment → Builder" pattern.
+
+It guarantees:
+
+- **Deterministic Ordering**: Topologically sorts helpers based on `dependsOn`.
+- **Cycle Detection**: Fails fast (halts execution) if dependencies form a loop.
+- **Robust Rollbacks**: Extensions and helpers provide best-effort rollback hooks run LIFO, attempting all cleanup steps and reporting any rollback failures.
+- **Type Safety**: Full TypeScript support for custom contexts, options, and artifacts.
+
+### Architecture Note
+
+The package exports a single entry point `@wpkernel/pipeline` which provides the "Standard Pipeline" (Fragments & Builders). This is the recommended API for most consumers.
+
+Under the hood, the package is split into:
+
+1.  **Standard Pipeline (`src/standard-pipeline`)**: The opinionated implementation used by WPKernel.
+2.  **Core Runner (`src/core/runner`)**: A purely agnostic DAG execution engine.
+
+Subpath imports (e.g., `@wpkernel/pipeline/core`) are available if you need to build a completely custom pipeline architecture using the runner primitives directly.
 
 ## Installation
 
@@ -24,101 +38,131 @@ pnpm add @wpkernel/pipeline
 
 The package ships pure TypeScript and has no runtime dependencies.
 
-## Quick start
+### Usage
+
+#### Standard Pipeline (Recommended)
+
+Use `createPipeline` for the standard Fragment → Builder workflow used by WPKernel.
 
 ```ts
-import { createPipeline, createHelper } from '@wpkernel/pipeline';
+import { createPipeline } from '@wpkernel/pipeline';
 
 const pipeline = createPipeline({
-	fragmentKind: 'fragment',
-	builderKind: 'builder',
-	createBuildOptions: (options) => options,
-	createContext: (options) => ({ reporter: options.reporter }),
-	createFragmentState: () => ({ items: [] }),
-	createFragmentArgs: ({ context, draft }) => ({
-		context,
-		input: undefined,
-		output: draft,
-		reporter: context.reporter,
-	}),
-	finalizeFragmentState: ({ draft }) => draft,
-	createBuilderArgs: ({ context, artifact }) => ({
-		context,
-		input: artifact,
-		output: { result: '' },
-		reporter: context.reporter,
-	}),
+	// Configuration
+	createContext: (ops) => ({ db: ops.db }),
+	createBuildOptions: () => ({}),
+	createFragmentState: () => ({}),
+
+	// Argument resolvers
+	createFragmentArgs: ({ context }) => ({ db: context.db }),
+	createBuilderArgs: ({ artifact }) => ({ artifact }),
+});
+```
+
+#### Custom Pipeline (Advanced)
+
+For completely custom architectures (ETL, migrations, etc.), use `makePipeline` to define your own stages.
+
+```ts
+import { makePipeline } from '@wpkernel/pipeline';
+
+const pipeline = makePipeline({
+	// Define the "Stages" of your pipeline
+	helperKinds: ['extract', 'transform', 'load'] as const,
+	createStages: (deps) => [
+		deps.makeLifecycleStage('extract'),
+		deps.makeLifecycleStage('transform'),
+		deps.makeLifecycleStage('load'),
+		deps.commitStage,
+		deps.finalizeResult,
+	],
+	createContext: (ops) => ({ db: ops.db }),
+	// ... logic for resolving args for your helpers ...
+});
+```
+
+### 2. Register Helpers
+
+Helpers are the atomic units of work. They can be anything - functions, objects, or complex services.
+
+```ts
+// "Extract" helper
+pipeline.use({
+	kind: 'extract',
+	key: 'users',
+	apply: async ({ context }) => {
+		return context.db.query('SELECT * FROM users');
+	},
 });
 
-pipeline.ir.use(
-	createHelper({
-		key: 'collect-items',
-		kind: 'fragment',
-		apply: ({ output }) => {
-			output.items.push('item1', 'item2');
-		},
-	})
-);
-
-pipeline.builders.use(
-	createHelper({
-		key: 'format-result',
-		kind: 'builder',
-		dependsOn: ['collect-items'],
-		apply: ({ input, output }) => {
-			output.result = input.items.join(', ');
-		},
-	})
-);
-
-const result = await pipeline.run({ reporter: console });
-console.log(result.artifact.result); // "item1, item2"
+// "Transform" helper (depends on generic extract logic)
+pipeline.use({
+	kind: 'transform',
+	key: 'clean-users',
+	dependsOn: ['users'],
+	apply: ({ input }) => {
+		return input.map((u) => ({ ...u, name: u.name.trim() }));
+	},
+});
+```
+
+### 3. Run It
+
+The pipeline resolves the graph, executes the content, and manages the lifecycle.
+
+```ts
+const result = await pipeline.run({ db: myDatabase });
 ```
 
-## Core concepts
+## Concepts
+
+### Agnostic Helper Kinds
+
+You are not limited to fixed roles. Define any `kind` of helper (e.g., `'validator'`, `'compiler'`, `'notifier'`) and map them to execution stages.
 
-- **Three-phase execution** – fragment helpers assemble intermediate representations, builder
-  helpers produce artefacts, and extension hooks commit or roll back side-effects.
-- **Deterministic ordering** – helpers declare `dependsOn` relationships; the runtime performs
-  topological sorting, cycle detection, and unused-helper diagnostics.
-- **Extension system** – register hooks via `createPipelineExtension()` to manage commits,
-  rollbacks, and shared setup/teardown logic.
-- **Typed contracts** – helper descriptors, execution metadata, and diagnostics surfaces are
-  fully typed for TypeScript consumers.
+### Dependency Graph
 
-## Official extension incubator
+Pipeline creates a dependency graph for _each_ kind of helper. If `Helper B` depends on `Helper A`, the runner ensures `A` executes before `B` (and passes `A`'s output to `B` if configured).
 
-The package owns an `src/extensions/` workspace where internal extensions are designed before
-being promoted to standalone packages. The directory ships a README that documents authoring
-guidelines and an [`official.ts`](./src/extensions/official.ts) catalogue describing the
-blueprints for:
+### Extensions & Lifecycles
+
+Extensions wrap execution with hooks at specific lifecycle stages.
+
+**Standard Pipeline Lifecycles**:
+`prepare` → `before-fragments` → `after-fragments` → `before-builders` → `after-builders` → `finalize`
+
+> **Note**: Custom pipelines (using `makePipeline`) can define arbitrary lifecycle stages. Extensions can hook into any stage, standard or custom, as long as it exists in the pipeline's execution plan.
+
+**Validation**: The pipeline validates extension registrations. If an extension attempts to hook into an unscheduled lifecycle, the pipeline will log a warning instead of silently ignoring it.
+
+**Extension Registration (Sync & Async)**: `extensions.use()` returns `MaybePromise<unknown>`. It returns a Promise only if the extension's `register` method is asynchronous.
+
+```ts
+// Sync registration (e.g. simple helper bundles)
+extensions.use(mySyncExtension);
+
+// Async registration (e.g. database connections)
+await extensions.use(myAsyncExtension);
+```
 
-- a live runner extension that streams reporter events to interactive renderers;
-- a deterministic concurrency scheduler;
-- additional integration blueprints for telemetry and runtime adapters.
+> **Recommendation**: We recommend `await`ing registration when possible for consistency, but you may omit it if you are certain the extension initializes synchronously. `pipeline.run()` will automatically wait for any pending async registrations.
 
-Consumers can import the catalogue through `@wpkernel/pipeline/extensions` to understand the
-contracts and helper annotations each extension expects while we finalise their
-implementations.
+### Rollbacks
 
-## Consumers
+The pipeline supports robust rollback for both helper application and extension lifecycle commit phases:
 
-- `@wpkernel/cli` (code generation pipeline, codemod entry points)
-- `@wpkernel/core` (resource/action orchestration)
-- `@wpkernel/php-json-ast` (codemod and builder stacks)
-- External tooling that requires deterministic job orchestration
+- **Extensions**: Can provide transactional overhead via the `commit` phase. If extensive failure occurs, `rollback` hooks are triggered.
+- **Helpers**: Can return a `rollback` function in their result. These are executed LIFO if a later failure occurs.
+- **Robustness**: The rollback stack continues execution even if individual rollback actions fail (errors are collected and reported).
 
-## Diagnostics & error handling
+### Re-run Semantics
 
-Use the built-in factories (`createDefaultError`, `PipelineDiagnostic`) to capture conflicts,
-missing dependencies, and rollback metadata. Execution snapshots describe which helpers ran,
-which were skipped, and what extensions committed.
+Diagnostics are per-run. Calling `pipeline.run()` automatically clears any previous runtime diagnostics to ensure a fresh state. Static diagnostics (e.g., registration conflicts) are preserved and re-emitted for each run.
 
-## Contributing
+## Documentation
 
-Keep helpers exported through `src/index.ts` and accompany new primitives with examples in the
-API reference. When expanding the extension system or diagnostics, update the codemod roadmap to
-reflect new capabilities that PHP bridges or the CLI can adopt.
+- [Architecture Guide](../../docs/packages/pipeline/architecture.md): Deep dive into the runner's internals and DAG resolution.
+- [API Reference](../../docs/api/@wpkernel/pipeline/README.md): Generated TSDoc for all interfaces.
 
 ## License
 

package/dist/{async-utils.d.ts → core/async-utils.d.ts}

@@ -62,4 +62,13 @@ export type Program<S> = (state: S) => MaybePromise<S>;
  * @internal
  */
 export declare const composeK: <S>(...fns: Program<S>[]) => Program<S>;
+/**
+ * Sync-friendly Probise.all equivalent.
+ *
+ * @param values
+ * @returns
+ *
+ * @internal
+ */
+export declare function maybeAll<T>(values: readonly MaybePromise<T>[]): MaybePromise<T[]>;
 //# sourceMappingURL=async-utils.d.ts.map

package/dist/core/async-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-utils.d.ts","sourceRoot":"","sources":["../../src/core/async-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CAAC,CAS3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EACnC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,EACtB,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,GAC9C,YAAY,CAAC,OAAO,CAAC,CAUvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACzB,GAAG,EAAE,MAAM,YAAY,CAAC,CAAC,CAAC,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,YAAY,CAAC,CAAC,CAAC,GAC1C,YAAY,CAAC,CAAC,CAAC,CAYjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACpC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,YAAY,CAAC,IAAI,CAAC,EACvD,SAAS,GAAE,SAAS,GAAG,SAAqB,GAC1C,YAAY,CAAC,IAAI,CAAC,CAgCpB;AAED;;;;GAIG;AAEH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,CAAC;AACvD;;;;;;GAMG;AAEH,eAAO,MAAM,QAAQ,GACnB,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,KAAG,OAAO,CAAC,CAAC,CAKjC,CAAC;AAEL;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAKjF"}

package/dist/core/async-utils.js

@@ -0,0 +1,46 @@
+function f(t) {
+  return (typeof t != "object" || t === null) && typeof t != "function" ? !1 : typeof t.then == "function";
+}
+function m(t, e) {
+  if (typeof e != "function")
+    throw new TypeError("maybeThen: onFulfilled is not a function");
+  return f(t) ? Promise.resolve(t).then(e) : e(t);
+}
+function l(t, e) {
+  try {
+    const r = t();
+    return f(r) ? Promise.resolve(r).catch((n) => e(n)) : r;
+  } catch (r) {
+    return e(r);
+  }
+}
+function p(t, e, r = "forward") {
+  const n = t.length;
+  if (n === 0)
+    return;
+  const h = (o) => r === "forward" ? o < n : o >= 0, s = (o) => r === "forward" ? o + 1 : o - 1, i = (o) => {
+    for (let c = o; h(c); c = s(c)) {
+      const a = t[c], u = e(a, c);
+      if (f(u))
+        return Promise.resolve(u).then(
+          () => i(s(c))
+        );
+    }
+  }, y = r === "forward" ? 0 : n - 1;
+  return i(y);
+}
+const w = (...t) => (e) => t.reduceRight(
+  (r, n) => m(r, n),
+  e
+);
+function b(t) {
+  return t.some(f) ? Promise.all(t) : t;
+}
+export {
+  w as composeK,
+  f as isPromiseLike,
+  b as maybeAll,
+  m as maybeThen,
+  l as maybeTry,
+  p as processSequentially
+};

package/dist/core/createExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createExtension.d.ts","sourceRoot":"","sources":["../../src/core/createExtension.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,YAAY,EACZ,iBAAiB,EACjB,qBAAqB,EACrB,iCAAiC,EACjC,0BAA0B,EAC1B,MAAM,YAAY,CAAC;AAEpB,UAAU,kCAAkC;IAC3C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mCAAmC,CACnD,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,CACR,SAAQ,kCAAkC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,CAClB,QAAQ,EAAE,SAAS,KACf,YAAY,CACd,IAAI,GACJ,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,GACpD,iCAAiC,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAClE,CAAC;CACF;AAED,UAAU,gCAAgC,CACzC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,CACR,SAAQ,kCAAkC;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;IAC7D,QAAQ,CAAC,IAAI,CAAC,EACX,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,GACpD,iCAAiC,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,0BAA0B,CAAC;CAChD;AAED,MAAM,MAAM,8BAA8B,CACzC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,IAEP,mCAAmC,CACnC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,CACR,GACD,gCAAgC,CAChC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,CACR,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoJG;AACH,wBAAgB,uBAAuB,CACtC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,EAET,OAAO,EAAE,8BAA8B,CACtC,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,SAAS,CACT,GACC,iBAAiB,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAoD7D"}

package/dist/core/dependency-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-graph.d.ts","sourceRoot":"","sources":["../../src/core/dependency-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO;IACxC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAaD;;;;GAIG;AACH,MAAM,WAAW,sBAAsB,CAAC,OAAO;IAC9C,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,4BAA4B,CAAC,OAAO;IACpD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAC9B,KAAK,EAAE,sBAAsB,CAAC,OAAO,CAAC,KAClC,IAAI,CAAC;IACV,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE;QACxC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;KACjD,KAAK,IAAI,CAAC;IACX;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACzC,KAAK,EAAE,MAAM,GACX,MAAM,CAER;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAS,gBAAgB,EAC9D,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAC5B,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,GAC1B,MAAM,CAUR;AAoPD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,SAAS,gBAAgB,EACrE,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,EACpC,OAAO,EAAE,4BAA4B,CAAC,OAAO,CAAC,GAAG,SAAS,EAC1D,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,KAAK,GACnD;IACF,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;IACnC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACpC,CAgBA"}

package/dist/core/error-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-factory.d.ts","sourceRoot":"","sources":["../../src/core/error-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,KAAK,CAAC;AAEpE;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAIvE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,KAAK,GAC9C,YAAY,CAEd"}

package/dist/{executor.d.ts → core/execution-utils.d.ts}

@@ -21,4 +21,4 @@ import { RegisteredHelper } from './dependency-graph';
  * @internal
  */
 export declare function executeHelpers<TContext, TInput, TOutput, TReporter extends PipelineReporter, TKind extends HelperKind, THelper extends Helper<TContext, TInput, TOutput, TReporter, TKind>, TArgs extends HelperApplyOptions<TContext, TInput, TOutput, TReporter>>(ordered: RegisteredHelper<THelper>[], makeArgs: (entry: RegisteredHelper<THelper>) => TArgs, invoke: (helper: THelper, args: TArgs, next: () => MaybePromise<void>) => MaybePromise<void>, recordStep: (entry: RegisteredHelper<THelper>) => void): MaybePromise<Set<string>>;
-//# sourceMappingURL=executor.d.ts.map
+//# sourceMappingURL=execution-utils.d.ts.map

package/dist/core/execution-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-utils.d.ts","sourceRoot":"","sources":["../../src/core/execution-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EACN,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,SAAS,gBAAgB,EAClC,KAAK,SAAS,UAAU,EACxB,OAAO,SAAS,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,EACnE,KAAK,SAAS,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,EAEtE,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,EACpC,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,KAAK,EACrD,MAAM,EAAE,CACP,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,MAAM,YAAY,CAAC,IAAI,CAAC,KAC1B,YAAY,CAAC,IAAI,CAAC,EACvB,UAAU,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,IAAI,GACpD,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA0E3B"}

package/dist/core/executor.d.ts

@@ -0,0 +1,2 @@
+export * from './execution-utils';
+//# sourceMappingURL=executor.d.ts.map

package/dist/core/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/core/executor.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/{extensions → core/extensions}/index.d.ts

@@ -1,3 +1,4 @@
+export * from './runner';
 export { OFFICIAL_EXTENSION_BLUEPRINTS } from './official';
 export type { OfficialExtensionBlueprint, ExtensionBlueprint, ExtensionBehaviour, ExtensionFactorySignature, } from './official';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAC3D,YAAY,EACX,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,GACzB,MAAM,YAAY,CAAC"}

package/dist/core/extensions/official.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"official.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/official.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,yBAAyB,CAAC,QAAQ,GAAG,OAAO;IAC5D;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,gBAAgB,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,yBAAyB,CAAC;IAC7C,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACnD,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG,CACzC,OAAO,CAAC,EAAE,OAAO,KACb,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,kBAAkB,EA+GtE,CAAC;AAEF,YAAY,EAAE,kBAAkB,IAAI,0BAA0B,EAAE,CAAC"}

package/dist/{extensions.d.ts → core/extensions/runner.d.ts}

@@ -1,4 +1,4 @@
-import { MaybePromise, PipelineExtensionHook, PipelineExtensionHookOptions, PipelineExtensionHookResult, PipelineExtensionRollbackErrorMetadata, PipelineExtensionLifecycle } from './types';
+import { MaybePromise, PipelineExtensionHook, PipelineExtensionHookOptions, PipelineExtensionHookResult, PipelineExtensionLifecycle } from '../types';
 /**
  * An extension hook entry with its unique key.
  *
@@ -39,7 +39,6 @@ export interface RollbackErrorArgs {
  *
  * @internal
  */
-export declare function createRollbackErrorMetadata(error: unknown): PipelineExtensionRollbackErrorMetadata;
 /**
  * Runs extension hooks sequentially and accumulates their results.
  *
@@ -82,6 +81,4 @@ export declare function commitExtensionResults<TContext, TOptions, TArtifact>(re
  * @internal
  */
 export declare function rollbackExtensionResults<TContext, TOptions, TArtifact>(results: readonly ExtensionHookExecution<TContext, TOptions, TArtifact>[], hooks: readonly ExtensionHookEntry<TContext, TOptions, TArtifact>[], onRollbackError: (args: RollbackErrorArgs) => void): MaybePromise<void>;
-export { OFFICIAL_EXTENSION_BLUEPRINTS } from './extensions/official.js';
-export type { OfficialExtensionBlueprint, ExtensionBlueprint, ExtensionBehaviour, ExtensionFactorySignature, } from './extensions/official.js';
-//# sourceMappingURL=extensions.d.ts.map
+//# sourceMappingURL=runner.d.ts.map

package/dist/core/extensions/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,YAAY,EACZ,qBAAqB,EACrB,4BAA4B,EAC5B,2BAA2B,EAC3B,0BAA0B,EAC1B,MAAM,UAAU,CAAC;AASlB;;;;GAIG;AACH,MAAM,WAAW,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS;IAChE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,0BAA0B,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;CACpE;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS;IACpE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACjE,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC,SAAS,CAAC,CAAC;CACxD;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;;;;;;;;;;GAUG;AAGH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAC9D,KAAK,EAAE,SAAS,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EACnE,SAAS,EAAE,0BAA0B,EACrC,OAAO,EAAE,4BAA4B,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EACpE,eAAe,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,GAChD,YAAY,CAAC;IACf,QAAQ,EAAE,SAAS,CAAC;IACpB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAC;CACjE,CAAC,CA8DD;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EACnE,OAAO,EAAE,SAAS,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GACvE,YAAY,CAAC,IAAI,CAAC,CAcpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EACrE,OAAO,EAAE,SAAS,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EACzE,KAAK,EAAE,SAAS,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EACnE,eAAe,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,GAChD,YAAY,CAAC,IAAI,CAAC,CA0BpB"}

package/dist/core/extensions/runner.js

@@ -0,0 +1,73 @@
+import { maybeTry as p, maybeThen as a, processSequentially as f, isPromiseLike as k } from "../async-utils.js";
+import { runRollbackStack as b } from "../rollback.js";
+function E(u, s, t, r) {
+  let n = t.artifact;
+  const i = [], o = u.filter(
+    (e) => e.lifecycle === s
+  ), m = {
+    context: t.context,
+    options: t.options,
+    lifecycle: s
+  }, h = p(
+    () => f(o, (e) => {
+      const c = e.hook({
+        ...m,
+        artifact: n
+      });
+      if (k(c))
+        return Promise.resolve(c).then((l) => {
+          l && (l.artifact !== void 0 && (n = l.artifact), i.push({
+            hook: e,
+            result: l
+          }));
+        });
+      if (c)
+        return c.artifact !== void 0 && (n = c.artifact), void i.push({
+          hook: e,
+          result: c
+        });
+    }),
+    (e) => a(
+      d(i, o, r),
+      () => {
+        throw e;
+      }
+    )
+  );
+  return a(h, () => ({ artifact: n, results: i }));
+}
+function R(u) {
+  return f(u, (s) => {
+    const t = s.result.commit;
+    if (!t)
+      return;
+    const r = t();
+    if (k(r))
+      return r.then(() => {
+      });
+  });
+}
+function d(u, s, t) {
+  const r = s.map((o) => o.key), n = r, i = u.map((o) => ({
+    result: o.result,
+    hook: o.hook
+  })).filter((o) => o.result.rollback).map((o) => ({
+    key: o.hook.key,
+    run: o.result.rollback
+  }));
+  return b(i, {
+    source: "extension",
+    onError: ({ error: o }) => {
+      t({
+        error: o,
+        extensionKeys: r,
+        hookSequence: n
+      });
+    }
+  });
+}
+export {
+  R as commitExtensionResults,
+  d as rollbackExtensionResults,
+  E as runExtensionHooks
+};

package/dist/core/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/core/helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,mBAAmB,EACnB,MAAM,EACN,UAAU,EAEV,gBAAgB,EAChB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6IG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,EACrD,KAAK,SAAS,UAAU,GAAG,UAAU,EAErC,OAAO,EAAE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,GACvE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,CA8BrD"}

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+export * from './async-utils.js';
+export * from './createExtension.js';
+export * from './dependency-graph.js';
+export * from './error-factory.js';
+export * from './executor.js';
+export * from './extensions/index.js';
+export * from './helper.js';
+export * from './registration.js';
+export * from './rollback.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,36 @@
+import { composeK as o, isPromiseLike as t, maybeAll as a, maybeThen as l, maybeTry as p, processSequentially as s } from "./async-utils.js";
+import { createPipelineExtension as c } from "./createExtension.js";
+import { compareHelpers as m, createDependencyGraph as x, createHelperId as E } from "./dependency-graph.js";
+import { createDefaultError as k, createErrorFactory as u } from "./error-factory.js";
+import { createHelper as b } from "./helper.js";
+import { handleExtensionRegisterResult as H, registerExtensionHook as I, registerHelper as d } from "./registration.js";
+import { createPipelineRollback as S, createRollbackErrorMetadata as T, runRollbackStack as g } from "./rollback.js";
+import { executeHelpers as F } from "./execution-utils.js";
+import { OFFICIAL_EXTENSION_BLUEPRINTS as N } from "./extensions/official.js";
+import { commitExtensionResults as D, rollbackExtensionResults as O, runExtensionHooks as _ } from "./extensions/runner.js";
+export {
+  N as OFFICIAL_EXTENSION_BLUEPRINTS,
+  D as commitExtensionResults,
+  m as compareHelpers,
+  o as composeK,
+  k as createDefaultError,
+  x as createDependencyGraph,
+  u as createErrorFactory,
+  b as createHelper,
+  E as createHelperId,
+  c as createPipelineExtension,
+  S as createPipelineRollback,
+  T as createRollbackErrorMetadata,
+  F as executeHelpers,
+  H as handleExtensionRegisterResult,
+  t as isPromiseLike,
+  a as maybeAll,
+  l as maybeThen,
+  p as maybeTry,
+  s as processSequentially,
+  I as registerExtensionHook,
+  d as registerHelper,
+  O as rollbackExtensionResults,
+  _ as runExtensionHooks,
+  g as runRollbackStack
+};

package/dist/{internal → core/internal}/extension-coordinator.d.ts

@@ -16,6 +16,6 @@ import { ExtensionCoordinator, ExtensionRollbackEvent } from './extension-coordi
  * @category Pipeline
  * @internal
  */
-export declare function initExtensionCoordinator<TContext, TOptions, TArtifact>(onRollbackError: (event: ExtensionRollbackEvent<TContext, TOptions, TArtifact>) => void): ExtensionCoordinator<TContext, TOptions, TArtifact>;
+export declare function initExtensionCoordinator<TContext, TOptions, TUserState>(onRollbackError: (event: ExtensionRollbackEvent<TContext, TOptions, TUserState>) => void): ExtensionCoordinator<TContext, TOptions, TUserState>;
 export type { ExtensionLifecycleState, ExtensionHookEntry, } from './extension-coordinator.types';
 //# sourceMappingURL=extension-coordinator.d.ts.map

package/dist/core/internal/extension-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-coordinator.d.ts","sourceRoot":"","sources":["../../../src/core/internal/extension-coordinator.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,oBAAoB,EAEpB,sBAAsB,EACtB,MAAM,+BAA+B,CAAC;AAGvC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EACtE,eAAe,EAAE,CAChB,KAAK,EAAE,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,KACzD,IAAI,GACP,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CA+EtD;AAED,YAAY,EACX,uBAAuB,EACvB,kBAAkB,GAClB,MAAM,+BAA+B,CAAC"}

package/dist/{internal → core/internal}/extension-coordinator.js

@@ -1,18 +1,19 @@
-import { commitExtensionResults as m, rollbackExtensionResults as d, runExtensionHooks as f, createRollbackErrorMetadata as s } from "../extensions.js";
+import { createRollbackErrorMetadata as s } from "../rollback.js";
 import { maybeThen as i } from "../async-utils.js";
+import { commitExtensionResults as u, rollbackExtensionResults as f, runExtensionHooks as d } from "../extensions/runner.js";
 function R(n) {
   return {
     runLifecycle: (t, { hooks: o, hookOptions: r }) => {
       const c = o.filter(
         (e) => e.lifecycle === t
-      ), a = f(
+      ), a = d(
         o,
         t,
         r,
-        ({ error: e, extensionKeys: l, hookSequence: u }) => n({
+        ({ error: e, extensionKeys: l, hookSequence: m }) => n({
           error: e,
           extensionKeys: l,
-          hookSequence: u,
+          hookSequence: m,
           errorMetadata: s(e),
           hookOptions: r
         })
@@ -27,7 +28,7 @@ function R(n) {
       );
     },
     createRollbackHandler: (t) => (o) => i(
-      d(
+      f(
         t.results,
         t.hooks,
         ({ error: r, extensionKeys: c, hookSequence: a }) => n({
@@ -42,7 +43,7 @@ function R(n) {
         throw o;
       }
     ),
-    commit: (t) => m(t.results),
+    commit: (t) => u(t.results),
     handleRollbackError: n
   };
 }

package/dist/{internal → core/internal}/extension-coordinator.types.d.ts

@@ -6,10 +6,10 @@ import { ExtensionHookEntry, ExtensionHookExecution, RollbackErrorArgs } from '.
  * @category Pipeline
  * @internal
  */
-export interface ExtensionLifecycleState<TContext, TOptions, TArtifact> {
-    readonly artifact: TArtifact;
-    readonly results: ExtensionHookExecution<TContext, TOptions, TArtifact>[];
-    readonly hooks: readonly ExtensionHookEntry<TContext, TOptions, TArtifact>[];
+export interface ExtensionLifecycleState<TContext, TOptions, TUserState> {
+    readonly artifact: TUserState;
+    readonly results: ExtensionHookExecution<TContext, TOptions, TUserState>[];
+    readonly hooks: readonly ExtensionHookEntry<TContext, TOptions, TUserState>[];
 }
 /**
  * Handles extension execution, rollback, and commit using the primitives exposed by the
@@ -25,18 +25,18 @@ export interface ExtensionLifecycleState<TContext, TOptions, TArtifact> {
  * @category Pipeline
  * @internal
  */
-export interface ExtensionRollbackEvent<TContext, TOptions, TArtifact> extends RollbackErrorArgs {
+export interface ExtensionRollbackEvent<TContext, TOptions, TUserState> extends RollbackErrorArgs {
     readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
-    readonly hookOptions?: PipelineExtensionHookOptions<TContext, TOptions, TArtifact>;
+    readonly hookOptions?: PipelineExtensionHookOptions<TContext, TOptions, TUserState>;
 }
-export interface ExtensionCoordinator<TContext, TOptions, TArtifact> {
-    readonly runLifecycle: (lifecycle: ExtensionHookEntry<TContext, TOptions, TArtifact>['lifecycle'], options: {
-        readonly hooks: readonly ExtensionHookEntry<TContext, TOptions, TArtifact>[];
-        readonly hookOptions: PipelineExtensionHookOptions<TContext, TOptions, TArtifact>;
-    }) => MaybePromise<ExtensionLifecycleState<TContext, TOptions, TArtifact>>;
-    readonly createRollbackHandler: <TResult>(state: ExtensionLifecycleState<TContext, TOptions, TArtifact>) => (error: unknown) => MaybePromise<TResult>;
-    readonly commit: (state: ExtensionLifecycleState<TContext, TOptions, TArtifact>) => MaybePromise<void>;
-    readonly handleRollbackError: (args: ExtensionRollbackEvent<TContext, TOptions, TArtifact>) => void;
+export interface ExtensionCoordinator<TContext, TOptions, TUserState> {
+    readonly runLifecycle: (lifecycle: ExtensionHookEntry<TContext, TOptions, TUserState>['lifecycle'], options: {
+        readonly hooks: readonly ExtensionHookEntry<TContext, TOptions, TUserState>[];
+        readonly hookOptions: PipelineExtensionHookOptions<TContext, TOptions, TUserState>;
+    }) => MaybePromise<ExtensionLifecycleState<TContext, TOptions, TUserState>>;
+    readonly createRollbackHandler: <TResult>(state: ExtensionLifecycleState<TContext, TOptions, TUserState>) => (error: unknown) => MaybePromise<TResult>;
+    readonly commit: (state: ExtensionLifecycleState<TContext, TOptions, TUserState>) => MaybePromise<void>;
+    readonly handleRollbackError: (args: ExtensionRollbackEvent<TContext, TOptions, TUserState>) => void;
 }
 export type { ExtensionHookEntry, ExtensionHookExecution, RollbackErrorArgs };
 //# sourceMappingURL=extension-coordinator.types.d.ts.map

package/dist/core/internal/extension-coordinator.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-coordinator.types.d.ts","sourceRoot":"","sources":["../../../src/core/internal/extension-coordinator.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,YAAY,EACZ,4BAA4B,EAC5B,sCAAsC,EACtC,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EACX,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,MAAM,eAAe,CAAC;AAEvB;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU;IACtE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE,CAAC;IAC3E,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,CAC1C,QAAQ,EACR,QAAQ,EACR,UAAU,CACV,EAAE,CAAC;CACJ;AAED;;;;;;;GAOG;AACH;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CACrE,SAAQ,iBAAiB;IACzB,QAAQ,CAAC,aAAa,EAAE,sCAAsC,CAAC;IAC/D,QAAQ,CAAC,WAAW,CAAC,EAAE,4BAA4B,CAClD,QAAQ,EACR,QAAQ,EACR,UAAU,CACV,CAAC;CACF;AAED,MAAM,WAAW,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU;IACnE,QAAQ,CAAC,YAAY,EAAE,CACtB,SAAS,EAAE,kBAAkB,CAC5B,QAAQ,EACR,QAAQ,EACR,UAAU,CACV,CAAC,WAAW,CAAC,EACd,OAAO,EAAE;QACR,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,CAC1C,QAAQ,EACR,QAAQ,EACR,UAAU,CACV,EAAE,CAAC;QACJ,QAAQ,CAAC,WAAW,EAAE,4BAA4B,CACjD,QAAQ,EACR,QAAQ,EACR,UAAU,CACV,CAAC;KACF,KACG,YAAY,CAAC,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;IAC3E,QAAQ,CAAC,qBAAqB,EAAE,CAAC,OAAO,EACvC,KAAK,EAAE,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,KAC1D,CAAC,KAAK,EAAE,OAAO,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC;IAC/C,QAAQ,CAAC,MAAM,EAAE,CAChB,KAAK,EAAE,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,KAC1D,YAAY,CAAC,IAAI,CAAC,CAAC;IACxB,QAAQ,CAAC,mBAAmB,EAAE,CAC7B,IAAI,EAAE,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,KACxD,IAAI,CAAC;CACV;AAED,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,CAAC"}