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

package/dist/async-utils.d.ts

@@ -48,4 +48,18 @@ export declare function maybeTry<T>(run: () => MaybePromise<T>, onError: (error:
  * @internal
  */
 export declare function processSequentially<T>(items: readonly T[], handler: (item: T, index: number) => MaybePromise<void>, direction?: 'forward' | 'reverse'): MaybePromise<void>;
+/**
+ * A small abstraction representing a state transformer that may be async.
+ *
+ * @internal
+ */
+export type Program<S> = (state: S) => MaybePromise<S>;
+/**
+ * Right-to-left composition for {@link Program} functions that short-circuits
+ * on promises while preserving synchronous execution when possible.
+ *
+ * @param {...any} fns
+ * @internal
+ */
+export declare const composeK: <S>(...fns: Program<S>[]) => Program<S>;
 //# sourceMappingURL=async-utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"async-utils.d.ts","sourceRoot":"","sources":["../src/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,CAMvB;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"}
+{"version":3,"file":"async-utils.d.ts","sourceRoot":"","sources":["../src/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,CAMvB;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"}

package/dist/async-utils.js

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

package/dist/createExtension.d.ts

@@ -2,7 +2,13 @@ import { MaybePromise, PipelineExtension, PipelineExtensionHook, PipelineExtensi
 interface CreatePipelineExtensionBaseOptions {
     readonly key?: string;
 }
-interface CreatePipelineExtensionWithRegister<TPipeline, TContext, TOptions, TArtifact> extends CreatePipelineExtensionBaseOptions {
+/**
+ * Options for creating a pipeline extension using the dynamic register pattern.
+ *
+ * @category Pipeline
+ * @public
+ */
+export interface CreatePipelineExtensionWithRegister<TPipeline, TContext, TOptions, TArtifact> extends CreatePipelineExtensionBaseOptions {
     readonly register: (pipeline: TPipeline) => MaybePromise<void | PipelineExtensionHook<TContext, TOptions, TArtifact> | PipelineExtensionHookRegistration<TContext, TOptions, TArtifact>>;
 }
 interface CreatePipelineExtensionWithSetup<TPipeline, TContext, TOptions, TArtifact> extends CreatePipelineExtensionBaseOptions {

package/dist/createExtension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createExtension.d.ts","sourceRoot":"","sources":["../src/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,UAAU,mCAAmC,CAC5C,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"}
+{"version":3,"file":"createExtension.d.ts","sourceRoot":"","sources":["../src/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/dependency-graph.d.ts

@@ -28,6 +28,12 @@ export interface CreateDependencyGraphOptions<THelper> {
     readonly onUnresolvedHelpers?: (options: {
         readonly unresolved: RegisteredHelper<THelper>[];
     }) => void;
+    /**
+     * Optional set of helper keys that are considered “already satisfied”.
+     * Useful when a pipeline run intentionally omits certain helpers (e.g. IR
+     * fragments) but builders still declare them as dependencies.
+     */
+    readonly providedKeys?: readonly string[];
 }
 /**
  * Creates a unique identifier for a registered helper.

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

@@ -1 +1 @@
-{"version":3,"file":"dependency-graph.d.ts","sourceRoot":"","sources":["../src/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;CACX;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;AA2KD;;;;;;;;;;;;;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,CA4CA"}
+{"version":3,"file":"dependency-graph.d.ts","sourceRoot":"","sources":["../src/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/dependency-graph.js

@@ -1,101 +1,109 @@
-function k(n, e) {
+function M(n, e) {
   return `${n.kind}:${n.key}#${e}`;
 }
-function f(n, e) {
+function u(n, e) {
   return n.helper.priority !== e.helper.priority ? e.helper.priority - n.helper.priority : n.helper.key !== e.helper.key ? n.helper.key.localeCompare(e.helper.key) : n.index - e.index;
 }
 function y(n) {
-  const e = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
-  for (const t of n)
-    e.set(t.id, /* @__PURE__ */ new Set()), o.set(t.id, 0), r.set(t.id, t);
-  return { adjacency: e, indegree: o, entryById: r };
+  const e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+  for (const o of n)
+    e.set(o.id, /* @__PURE__ */ new Set()), t.set(o.id, 0), r.set(o.id, o);
+  return { adjacency: e, indegree: t, entryById: r };
 }
 function a(n, e) {
-  const o = [];
+  const t = [];
   for (const r of n)
-    for (const t of r.helper.dependsOn)
+    for (const o of r.helper.dependsOn)
       h(
         n,
         e,
-        t,
+        o,
         r.id
-      ) || o.push({
+      ) || t.push({
         dependant: r,
-        dependencyKey: t
+        dependencyKey: o
       });
-  return o;
+  return t;
 }
-function h(n, e, o, r) {
-  const t = n.filter(
-    ({ helper: c }) => c.key === o
+function h(n, e, t, r) {
+  const o = n.filter(
+    ({ helper: s }) => s.key === t
   );
-  if (t.length === 0)
+  if (o.length === 0)
     return !1;
-  for (const c of t) {
-    const d = e.adjacency.get(c.id);
-    if (!d)
+  for (const s of o) {
+    const c = e.adjacency.get(s.id);
+    if (!c)
       continue;
-    d.add(r);
+    c.add(r);
     const i = e.indegree.get(r) ?? 0;
     e.indegree.set(r, i + 1);
   }
   return !0;
 }
 function g(n, e) {
-  const o = n.filter(
+  const t = n.filter(
     (i) => (e.indegree.get(i.id) ?? 0) === 0
   );
-  o.sort(f);
-  const r = [], t = new Map(e.indegree), c = /* @__PURE__ */ new Set();
-  for (; o.length > 0; ) {
-    const i = o.shift();
+  t.sort(u);
+  const r = [], o = new Map(e.indegree), s = /* @__PURE__ */ new Set();
+  for (; t.length > 0; ) {
+    const i = t.shift();
     if (!i)
       break;
-    r.push(i), c.add(i.id);
-    const u = e.adjacency.get(i.id);
-    if (u)
-      for (const s of u) {
-        const p = (t.get(s) ?? 0) - 1;
-        if (t.set(s, p), p !== 0)
+    r.push(i), s.add(i.id);
+    const p = e.adjacency.get(i.id);
+    if (p)
+      for (const d of p) {
+        const l = (o.get(d) ?? 0) - 1;
+        if (o.set(d, l), l !== 0)
           continue;
-        const l = e.entryById.get(s);
-        l && (o.push(l), o.sort(f));
+        const f = e.entryById.get(d);
+        f && (t.push(f), t.sort(u));
       }
   }
-  const d = n.filter((i) => !c.has(i.id));
-  return { ordered: r, unresolved: d };
+  const c = n.filter((i) => !s.has(i.id));
+  return { ordered: r, unresolved: c };
 }
-function w(n, e, o) {
-  const r = y(n), t = a(n, r);
-  if (t.length > 0) {
-    for (const s of t)
-      e?.onMissingDependency?.(s);
-    const i = /* @__PURE__ */ new Map();
-    for (const s of t) {
-      const p = s.dependant.helper.key, l = i.get(p) ?? [];
-      l.push(s.dependencyKey), i.set(p, l);
-    }
-    const u = Array.from(i.entries()).map(
-      ([s, p]) => `"${s}" → [${p.map((l) => `"${l}"`).join(", ")}]`
-    ).join(", ");
-    throw o(
-      "ValidationError",
-      `Helpers depend on unknown helpers: ${u}.`
-    );
-  }
-  const { ordered: c, unresolved: d } = g(n, r);
-  if (d.length > 0) {
-    e?.onUnresolvedHelpers?.({ unresolved: d });
-    const i = d.map((u) => u.helper.key);
-    throw o(
-      "ValidationError",
-      `Detected unresolved pipeline helpers: ${i.join(", ")}.`
-    );
+function k(n, e, t) {
+  if (n.length === 0)
+    return;
+  if (e?.onMissingDependency)
+    for (const s of n)
+      e.onMissingDependency(s);
+  const r = /* @__PURE__ */ new Map();
+  for (const s of n) {
+    const c = s.dependant.helper.key, i = r.get(c) ?? [];
+    i.push(s.dependencyKey), r.set(c, i);
   }
-  return { order: c, adjacency: r.adjacency };
+  const o = Array.from(r.entries()).map(
+    ([s, c]) => `"${s}" → [${c.map((i) => `"${i}"`).join(", ")}]`
+  ).join(", ");
+  throw t(
+    "ValidationError",
+    `Helpers depend on unknown helpers: ${o}.`
+  );
+}
+function w(n, e, t) {
+  if (n.length === 0)
+    return;
+  e?.onUnresolvedHelpers && e.onUnresolvedHelpers({ unresolved: n });
+  const r = n.map((o) => o.helper.key);
+  throw t(
+    "ValidationError",
+    `Detected unresolved pipeline helpers: ${r.join(", ")}.`
+  );
+}
+function j(n, e, t) {
+  const r = y(n), o = a(n, r), s = new Set(e?.providedKeys ?? []), c = o.filter(
+    (d) => !s.has(d.dependencyKey)
+  );
+  k(c, e, t);
+  const { ordered: i, unresolved: p } = g(n, r);
+  return w(p, e, t), { order: i, adjacency: r.adjacency };
 }
 export {
-  f as compareHelpers,
-  w as createDependencyGraph,
-  k as createHelperId
+  u as compareHelpers,
+  j as createDependencyGraph,
+  M as createHelperId
 };

package/dist/error-factory.d.ts

@@ -24,7 +24,7 @@ export declare function createDefaultError(code: string, message: string): Error
 /**
  * Creates an error factory that wraps a custom error class.
  *
- * @param ErrorClass - Custom error class constructor
+ * @param create - A function that creates an Error instance based on a code and message.
  * @param create
  * @returns An error factory function
  *

package/dist/extensions/index.d.ts

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

package/dist/extensions.d.ts

@@ -83,5 +83,5 @@ export declare function commitExtensionResults<TContext, TOptions, TArtifact>(re
  */
 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
+export type { OfficialExtensionBlueprint, ExtensionBlueprint, ExtensionBehaviour, ExtensionFactorySignature, } from './extensions/official.js';
+//# sourceMappingURL=extensions.d.ts.map

package/dist/extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,YAAY,EACZ,qBAAqB,EACrB,4BAA4B,EAC5B,2BAA2B,EAC3B,sCAAsC,EACtC,0BAA0B,EAC1B,MAAM,SAAS,CAAC;AAQjB;;;;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;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,OAAO,GACZ,sCAAsC,CAoBxC;AAED;;;;;;;;;;;;;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,CA2BpB;AAED,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACzE,YAAY,EACX,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,GACzB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,YAAY,EACZ,qBAAqB,EACrB,4BAA4B,EAC5B,2BAA2B,EAC3B,sCAAsC,EACtC,0BAA0B,EAC1B,MAAM,SAAS,CAAC;AASjB;;;;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;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,OAAO,GACZ,sCAAsC,CAoBxC;AAED;;;;;;;;;;;;;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;AAED,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACzE,YAAY,EACX,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,GACzB,MAAM,0BAA0B,CAAC"}

package/dist/extensions.js

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

package/dist/helper.d.ts

@@ -32,6 +32,14 @@ import { CreateHelperOptions, Helper, HelperKind, PipelineReporter } from './typ
  * - Validates dependency chains and reports missing/circular dependencies
  * - Ensures helpers run in correct order regardless of registration sequence
  *
+ * ### Apply results & rollback
+ * Helpers typically perform their work by mutating the provided `fragment` or `output` in place and optionally calling `next()` to continue the chain.
+ * For more advanced scenarios, a helper can **also return** a result object:
+ * - `output` — an updated output value to feed into subsequent helpers
+ * - `rollback` — a rollback operation created via `createPipelineRollback`, which will be executed if the pipeline fails after this helper completes
+ *
+ * Returning a result object is opt-in; existing helpers that return `void` remain valid and continue to behave as before.
+ *
  * ## Architecture
  *
  * Helpers form directed acyclic graphs (DAGs) where each node represents a transformation
@@ -41,7 +49,7 @@ import { CreateHelperOptions, Helper, HelperKind, PipelineReporter } from './typ
  * This design enables:
  * - **Composability**: Combine helpers from different packages without conflicts
  * - **Extensibility**: Third-party helpers integrate seamlessly via dependency declarations
- * - **Reliability**: Rollback support ensures atomic operations across helper chains
+ * - **Reliability**: Helper-level rollback (via `createPipelineRollback`) ensures atomic behaviour across helper chains
  * - **Observability**: Built-in diagnostics and reporter integration for debugging
  *
  * @param    options
@@ -84,46 +92,49 @@ import { CreateHelperOptions, Helper, HelperKind, PipelineReporter } from './typ
  * });
  * ```
  *
- * @example Builder helper with rollback
+ * @example Builder helper with rollback result
  * ```typescript
- * import { createPipelineCommit, createPipelineRollback } from '@wpkernel/pipeline';
+ * import { createHelper, createPipelineRollback } from '@wpkernel/pipeline';
  *
  * const writeFileHelper = createHelper({
  *   key: 'write-file',
  *   kind: 'builder',
- *   apply: ({ draft, context }) => {
+ *   apply: ({ output, context }) => {
  *     const path = context.outputPath;
- *     const backup = readFileSync(path, 'utf-8'); // Capture current state
+ *     const before = [...output]; // Capture current in-memory state
  *
- *     writeFileSync(path, draft);
+ *     output.push(context.fileContent);
  *
  *     return {
- *       commit: createPipelineCommit(
- *         () => context.reporter.info(`Wrote ${path}`)
- *       ),
  *       rollback: createPipelineRollback(
- *         () => writeFileSync(path, backup), // Restore on error
- *         () => context.reporter.warn(`Rolled back ${path}`)
+ *         () => {
+ *           output.length = 0;
+ *           output.push(...before);
+ *         },
+ *         {
+ *           key: 'write-file',
+ *           label: 'Restore file output state',
+ *         }
  *       ),
  *     };
  *   },
  * });
  * ```
  *
- * @example Async helper with error handling
+ * @example Async helper with transformed output and error handling
  * ```typescript
  * const formatCodeHelper = createHelper({
  *   key: 'format-code',
  *   kind: 'builder',
  *   dependsOn: ['write-file'],
- *   apply: async ({ artifact, context }) => {
+ *   apply: async ({ output, context }) => {
  *     try {
- *       const formatted = await prettier.format(artifact, {
+ *       const formatted = await prettier.format(output.join(''), {
  *         parser: 'php',
  *       });
- *       return { artifact: formatted };
+ *       return { output: formatted.split('') }; // Optionally return a new output value
  *     } catch (error) {
- *       context.reporter.error('Formatting failed', { error });
+ *       context.reporter.warn?.('Formatting failed', { error });
  *       throw error;
  *     }
  *   },

package/dist/helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,mBAAmB,EACnB,MAAM,EACN,UAAU,EAEV,gBAAgB,EAChB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkIG;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"}
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/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/index.d.ts

@@ -1,17 +1,18 @@
 export { createHelper } from './helper';
 export { createPipeline } from './createPipeline';
 export { createPipelineExtension } from './createExtension';
-export { CreatePipelineExtensionOptions } from "./createExtension";
+export type { CreatePipelineExtensionOptions } from './createExtension';
 export { executeHelpers } from './executor';
-export { ErrorFactory } from "./error-factory";
+export type { ErrorFactory } from './error-factory';
 export { createDefaultError, createErrorFactory } from './error-factory';
 export { registerHelper, registerExtensionHook, handleExtensionRegisterResult, } from './registration';
-export { Pipeline, CreatePipelineOptions, PipelineReporter, PipelineExtension, PipelineExtensionHook, PipelineExtensionHookOptions, PipelineExtensionHookResult, PipelineExtensionLifecycle, PipelineExtensionHookRegistration, PipelineExtensionRegisterOutput, PipelineDiagnostic, ConflictDiagnostic, MissingDependencyDiagnostic, UnusedHelperDiagnostic, Helper, HelperApplyFn, HelperDescriptor, HelperKind, HelperMode, CreateHelperOptions, HelperApplyOptions, MaybePromise, PipelineStep, PipelineRunState, HelperExecutionSnapshot, PipelineExecutionMetadata, FragmentFinalizationMetadata, PipelineExtensionRollbackErrorMetadata, } from "./types";
-export { RegisteredHelper, MissingDependencyIssue, } from "./dependency-graph";
+export { createPipelineRollback, runRollbackStack } from './rollback';
+export type { PipelineRollback, PipelineRollbackErrorMetadata, RunRollbackStackOptions, } from './rollback';
+export type { Pipeline, CreatePipelineOptions, PipelineReporter, PipelineExtension, PipelineExtensionHook, PipelineExtensionHookOptions, PipelineExtensionHookResult, PipelineExtensionLifecycle, PipelineExtensionHookRegistration, PipelineExtensionRegisterOutput, PipelineDiagnostic, ConflictDiagnostic, MissingDependencyDiagnostic, UnusedHelperDiagnostic, Helper, HelperApplyFn, HelperApplyResult, HelperDescriptor, HelperKind, HelperMode, CreateHelperOptions, HelperApplyOptions, MaybePromise, PipelineStep, PipelineRunState, HelperExecutionSnapshot, PipelineExecutionMetadata, FragmentFinalizationMetadata, PipelineExtensionRollbackErrorMetadata, } from './types';
+export type { RegisteredHelper, MissingDependencyIssue, } from './dependency-graph';
 export { createHelperId, compareHelpers } from './dependency-graph';
 export { isPromiseLike, maybeThen, maybeTry, processSequentially, } from './async-utils';
-export { ExtensionHookEntry, ExtensionHookExecution, RollbackErrorArgs, } from "./extensions";
-export { createRollbackErrorMetadata } from './extensions';
+export type { ExtensionHookEntry, ExtensionHookExecution, RollbackErrorArgs, } from './extensions';
 export { OFFICIAL_EXTENSION_BLUEPRINTS } from './extensions/official';
-export { OfficialExtensionBlueprint } from "./extensions/official";
-//# sourceMappingURL=index.d.ts.map
+export type { OfficialExtensionBlueprint } from './extensions/official';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,YAAY,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EACN,cAAc,EACd,qBAAqB,EACrB,6BAA6B,GAC7B,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAEX,QAAQ,EACR,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,4BAA4B,EAC5B,2BAA2B,EAC3B,0BAA0B,EAC1B,iCAAiC,EACjC,+BAA+B,EAC/B,kBAAkB,EAClB,kBAAkB,EAClB,2BAA2B,EAC3B,sBAAsB,EAGtB,MAAM,EACN,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,mBAAmB,EACnB,kBAAkB,EAGlB,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,sCAAsC,GACtC,MAAM,SAAS,CAAC;AAGjB,YAAY,EACX,gBAAgB,EAChB,sBAAsB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpE,OAAO,EACN,aAAa,EACb,SAAS,EACT,QAAQ,EACR,mBAAmB,GACnB,MAAM,eAAe,CAAC;AAGvB,YAAY,EACX,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,GACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAG3D,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AACtE,YAAY,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,YAAY,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EACN,cAAc,EACd,qBAAqB,EACrB,6BAA6B,GAC7B,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACtE,YAAY,EACX,gBAAgB,EAChB,6BAA6B,EAC7B,uBAAuB,GACvB,MAAM,YAAY,CAAC;AAGpB,YAAY,EAEX,QAAQ,EACR,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,4BAA4B,EAC5B,2BAA2B,EAC3B,0BAA0B,EAC1B,iCAAiC,EACjC,+BAA+B,EAC/B,kBAAkB,EAClB,kBAAkB,EAClB,2BAA2B,EAC3B,sBAAsB,EAGtB,MAAM,EACN,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,mBAAmB,EACnB,kBAAkB,EAElB,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,sCAAsC,GACtC,MAAM,SAAS,CAAC;AAGjB,YAAY,EACX,gBAAgB,EAChB,sBAAsB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpE,OAAO,EACN,aAAa,EACb,SAAS,EACT,QAAQ,EACR,mBAAmB,GACnB,MAAM,eAAe,CAAC;AAGvB,YAAY,EACX,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,GACjB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AACtE,YAAY,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC"}