@wpkernel/pipeline 0.12.5-beta.0 → 0.12.6-beta.1

package/README.md

@@ -15,10 +15,21 @@ While it powers WPKernel's code generation (assembling fragments into artifacts)
 It guarantees:
 
 - **Deterministic Ordering**: Topologically sorts helpers based on `dependsOn`.
-- **Cycle Detection**: Fails fast if dependencies form a loop.
-- **Atomic Rollbacks**: Extensions provide transactional `commit` and `rollback` hooks.
+- **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
 
 ```bash
@@ -27,25 +38,44 @@ pnpm add @wpkernel/pipeline
 
 The package ships pure TypeScript and has no runtime dependencies.
 
-## Usage
+### Usage
+
+#### Standard Pipeline (Recommended)
+
+Use `createPipeline` for the standard Fragment → Builder workflow used by WPKernel.
+
+```ts
+import { createPipeline } from '@wpkernel/pipeline';
+
+const pipeline = createPipeline({
+	// Configuration
+	createContext: (ops) => ({ db: ops.db }),
+	createBuildOptions: () => ({}),
+	createFragmentState: () => ({}),
+
+	// Argument resolvers
+	createFragmentArgs: ({ context }) => ({ db: context.db }),
+	createBuilderArgs: ({ artifact }) => ({ artifact }),
+});
+```
 
-### 1. Define Your World
+#### Custom Pipeline (Advanced)
 
-The pipeline is generic. You define the "Stages" and "State" relevant to your domain.
+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
-	stages: (deps) => [
+	helperKinds: ['extract', 'transform', 'load'] as const,
+	createStages: (deps) => [
 		deps.makeLifecycleStage('extract'),
 		deps.makeLifecycleStage('transform'),
 		deps.makeLifecycleStage('load'),
 		deps.commitStage,
 		deps.finalizeResult,
 	],
-	// Define how to create your context and state
 	createContext: (ops) => ({ db: ops.db }),
 	// ... logic for resolving args for your helpers ...
 });
@@ -96,7 +126,38 @@ Pipeline creates a dependency graph for _each_ kind of helper. If `Helper B` dep
 
 ### Extensions & Lifecycles
 
-Extensions wrap the execution with hooks like `prepare`, `onSuccess`, and `rollback`. They are crucial for ensuring atomic operations - if any stage fails, the pipeline automatically triggers the rollback chain for all executed extensions.
+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);
+```
+
+> **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.
+
+### Rollbacks
+
+The pipeline supports robust rollback for both helper application and extension lifecycle commit phases:
+
+- **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).
+
+### Re-run Semantics
+
+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.
 
 ## Documentation
 

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 Promise.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,CAKlC,CAAC;AAEJ;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACzB,MAAM,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,GAChC,YAAY,CAAC,CAAC,EAAE,CAAC,CAKnB"}

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/core/extensions/index.d.ts

@@ -0,0 +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 { 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 { ExtensionLifecycleState, ExtensionHookEntry, } from "./extension-coordinator.types";
-//# sourceMappingURL=extension-coordinator.d.ts.map
+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"}

package/dist/core/makePipeline.d.ts

@@ -0,0 +1,5 @@
+import { PipelineDiagnostic, PipelineReporter, PipelineRunState, AgnosticPipeline, AgnosticPipelineOptions } from './types';
+export declare function makePipeline<TRunOptions, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter = PipelineReporter, TUserState = unknown, TDiagnostic extends PipelineDiagnostic = PipelineDiagnostic, TRunResult = PipelineRunState<TUserState, TDiagnostic>>(options: AgnosticPipelineOptions<TRunOptions, TContext, TReporter, TUserState, TDiagnostic, TRunResult>): AgnosticPipeline<TRunOptions, TRunResult, TContext, TReporter>;
+//# sourceMappingURL=makePipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makePipeline.d.ts","sourceRoot":"","sources":["../../src/core/makePipeline.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAKX,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAEhB,gBAAgB,EAChB,uBAAuB,EACvB,MAAM,SAAS,CAAC;AAWjB,wBAAgB,YAAY,CAC3B,WAAW,EACX,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,EACrD,UAAU,GAAG,OAAO,EACpB,WAAW,SAAS,kBAAkB,GAAG,kBAAkB,EAC3D,UAAU,GAAG,gBAAgB,CAAC,UAAU,EAAE,WAAW,CAAC,EAEtD,OAAO,EAAE,uBAAuB,CAC/B,WAAW,EACX,QAAQ,EACR,SAAS,EACT,UAAU,EACV,WAAW,EACX,UAAU,CACV,GACC,gBAAgB,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,CAwVhE"}