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

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

@@ -6,12 +6,13 @@ export { executeHelpers } from './executor';
 export { 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 { createPipelineRollback, runRollbackStack } from './rollback';
+export { PipelineRollback, PipelineRollbackErrorMetadata, RunRollbackStackOptions, } from "./rollback";
+export { 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 { 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 { OFFICIAL_EXTENSION_BLUEPRINTS } from './extensions/official';
 export { 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"}

package/dist/index.js

@@ -1,29 +1,30 @@
 import { createHelper as o } from "./helper.js";
 import { createPipeline as p } from "./createPipeline.js";
-import { createPipelineExtension as i } from "./createExtension.js";
-import { executeHelpers as m } from "./executor.js";
-import { createDefaultError as s, createErrorFactory as c } from "./error-factory.js";
-import { handleExtensionRegisterResult as n, registerExtensionHook as E, registerHelper as H } from "./registration.js";
-import { compareHelpers as I, createHelperId as u } from "./dependency-graph.js";
-import { isPromiseLike as R, maybeThen as T, maybeTry as b, processSequentially as d } from "./async-utils.js";
-import { createRollbackErrorMetadata as k } from "./extensions.js";
-import { OFFICIAL_EXTENSION_BLUEPRINTS as L } from "./extensions/official.js";
+import { createPipelineExtension as l } from "./createExtension.js";
+import { executeHelpers as c } from "./executor.js";
+import { createDefaultError as x, createErrorFactory as n } from "./error-factory.js";
+import { handleExtensionRegisterResult as f, registerExtensionHook as E, registerHelper as H } from "./registration.js";
+import { createPipelineRollback as u, runRollbackStack as y } from "./rollback.js";
+import { compareHelpers as P, createHelperId as R } from "./dependency-graph.js";
+import { isPromiseLike as S, maybeThen as T, maybeTry as g, processSequentially as F } from "./async-utils.js";
+import { OFFICIAL_EXTENSION_BLUEPRINTS as N } from "./extensions/official.js";
 export {
-  L as OFFICIAL_EXTENSION_BLUEPRINTS,
-  I as compareHelpers,
-  s as createDefaultError,
-  c as createErrorFactory,
+  N as OFFICIAL_EXTENSION_BLUEPRINTS,
+  P as compareHelpers,
+  x as createDefaultError,
+  n as createErrorFactory,
   o as createHelper,
-  u as createHelperId,
+  R as createHelperId,
   p as createPipeline,
-  i as createPipelineExtension,
-  k as createRollbackErrorMetadata,
-  m as executeHelpers,
-  n as handleExtensionRegisterResult,
-  R as isPromiseLike,
+  l as createPipelineExtension,
+  u as createPipelineRollback,
+  c as executeHelpers,
+  f as handleExtensionRegisterResult,
+  S as isPromiseLike,
   T as maybeThen,
-  b as maybeTry,
-  d as processSequentially,
+  g as maybeTry,
+  F as processSequentially,
   E as registerExtensionHook,
-  H as registerHelper
+  H as registerHelper,
+  y as runRollbackStack
 };

package/dist/internal/pipeline-program-utils.d.ts

@@ -0,0 +1,127 @@
+import { Helper, HelperApplyOptions, HelperKind, MaybePromise, PipelineExtensionRollbackErrorMetadata, PipelineReporter } from '../types';
+import { RegisteredHelper } from '../dependency-graph';
+import { Program } from '../async-utils.js';
+import { HelperInvokeOptions, RollbackContext, Halt, RollbackEntry, HelperRollbackPlan, StageEnv } from './pipeline-runner.types.js';
+export declare function isHalt<TRunResult>(value: unknown): value is Halt<TRunResult>;
+/**
+ * Builds a rollback handler that first drains helper rollbacks (when present) and then defers to
+ * extension rollback handling.
+ *
+ * @param state
+ * @param state.context
+ * @param state.extensionCoordinator
+ * @param state.extensionState
+ * @param helperRollbacks
+ * @param onHelperRollbackError
+ * @internal
+ */
+export declare function makeRollbackHandler<TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}>(state: RollbackContext<TContext, TOptions, TArtifact>, helperRollbacks: RollbackEntry<THelper>[], onHelperRollbackError?: (options: {
+    readonly error: unknown;
+    readonly helper: THelper;
+    readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+    readonly context: TContext;
+}) => void): (error: unknown) => MaybePromise<void>;
+/**
+ * Generic stage constructor that executes an ordered helper list with middleware-style `next()`.
+ * Optional rollback capture keeps fragment/builder programs declarative by passing in only the
+ * stage-specific arg factories and completion logic.
+ *
+ * @param options
+ * @param options.getOrder
+ * @param options.makeArgs
+ * @param options.invoke
+ * @param options.recordStep
+ * @param options.onVisited
+ * @param options.registerRollback
+ * @internal
+ */
+export declare function createHelpersProgram<TContext, TReporter extends PipelineReporter, TKind extends HelperKind, THelper extends Helper<TContext, TInput, TOutput, TReporter, TKind>, TInput, TOutput, TState>(options: {
+    getOrder: (state: TState) => RegisteredHelper<THelper>[];
+    makeArgs: (state: TState) => (entry: RegisteredHelper<THelper>) => HelperApplyOptions<TContext, TInput, TOutput, TReporter>;
+    invoke: (invokeOptions: HelperInvokeOptions<THelper, TInput, TOutput, TContext, TReporter>) => MaybePromise<void>;
+    recordStep: (entry: RegisteredHelper<unknown>) => void;
+    onVisited: (state: TState, visited: Set<string>) => TState;
+    registerRollback?: (helper: THelper, result: unknown) => void;
+}): (state: TState) => MaybePromise<TState>;
+/**
+ * Pure finalizer for fragment state that can be composed into a pipeline without knowing the
+ * concrete runner shape. Callers supply how to detect halts, how to snapshot fragment execution,
+ * and how to apply the finalized artifact back onto state.
+ * @param options
+ * @param options.isHalt
+ * @param options.snapshotFragments
+ * @param options.applyArtifact
+ */
+export declare function makeFinalizeFragmentsStage<TState, THalt extends Halt<unknown>, TFragments>(options: {
+    isHalt: (value: TState | THalt) => value is THalt;
+    snapshotFragments: (state: TState) => TFragments;
+    applyArtifact: (state: TState, fragments: TFragments) => TState;
+}): Program<TState | THalt>;
+/**
+ * Generic stage builder for "after fragments" style hooks. The runner provides the execution logic
+ * (e.g. extension coordinator runLifecycle) and a halt predicate; the program simply short-circuits
+ * on halts and applies the provided execution otherwise.
+ * @param options
+ * @param options.isHalt
+ * @param options.execute
+ */
+export declare function makeAfterFragmentsStage<TState, THalt extends Halt<unknown>>(options: {
+    isHalt: (value: TState | THalt) => value is THalt;
+    execute: (state: TState) => MaybePromise<TState>;
+}): Program<TState | THalt>;
+/**
+ * Commit stage builder that keeps the runner point-free: supply how to commit extensions and how to
+ * roll back with a halt sentinel, and the program handles sync/async errors uniformly.
+ * @param options
+ * @param options.isHalt
+ * @param options.commit
+ * @param options.rollbackToHalt
+ */
+export declare function makeCommitStage<TState, THalt extends Halt<unknown>>(options: {
+    isHalt: (value: TState | THalt) => value is THalt;
+    commit: (state: TState) => MaybePromise<void>;
+    rollbackToHalt: (state: TState, error: unknown) => MaybePromise<THalt>;
+}): Program<TState | THalt>;
+/**
+ * Simple finalizer that snapshots helpers/diagnostics into state unless a halt is present.
+ * @param options
+ * @param options.isHalt
+ * @param options.finalize
+ */
+export declare function makeFinalizeResultStage<TState, THalt extends Halt<unknown>>(options: {
+    isHalt: (value: TState | THalt) => value is THalt;
+    finalize: (state: TState) => TState;
+}): Program<TState | THalt>;
+export type HelperStageSpec<TState, TContext, TReporter extends PipelineReporter, TKind extends HelperKind, THelper extends Helper<TContext, TInput, TOutput, TReporter, TKind>, TInput, TOutput> = {
+    readonly getOrder: (state: TState) => RegisteredHelper<THelper>[];
+    readonly makeArgs: (state: TState) => (entry: RegisteredHelper<THelper>) => HelperApplyOptions<TContext, TInput, TOutput, TReporter>;
+    readonly onVisited: (state: TState, visited: Set<string>, rollbacks: RollbackEntry<THelper>[]) => TState;
+    readonly readRollbacks?: (state: TState) => RollbackEntry<THelper>[] | undefined;
+};
+export declare function runHelperRollbackPlan<TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}>(plan: HelperRollbackPlan<TContext, TOptions, TArtifact, THelper>, error: unknown): MaybePromise<void>;
+export type HelperStageRunPlan<TState, TRunResult, TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}> = {
+    readonly state: TState;
+    readonly program: Program<TState>;
+    readonly rollbackPlan: HelperRollbackPlan<TContext, TOptions, TArtifact, THelper>;
+    readonly halt: (error?: unknown) => Halt<TRunResult>;
+};
+export declare function runHelperStageWithRollback<TState, TRunResult, TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}>(plan: HelperStageRunPlan<TState, TRunResult, TContext, TOptions, TArtifact, THelper>): MaybePromise<TState | Halt<TRunResult>>;
+export type RollbackToHaltPlan<TRunResult, TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}> = {
+    readonly rollbackPlan: HelperRollbackPlan<TContext, TOptions, TArtifact, THelper>;
+    readonly halt: (error?: unknown) => Halt<TRunResult>;
+};
+export declare function runRollbackToHalt<TRunResult, TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}>(plan: RollbackToHaltPlan<TRunResult, TContext, TOptions, TArtifact, THelper>, error: unknown): MaybePromise<Halt<TRunResult>>;
+export declare function makeHelperStageFactory<TState, TRunResult, TContext, TOptions, TArtifact, TReporter extends PipelineReporter>(config: StageEnv<TState, TRunResult, TContext, TOptions, TArtifact, TReporter>): <TKind extends HelperKind, THelper extends Helper<TContext, TInput, TOutput, TReporter, TKind>, TInput, TOutput>(spec: HelperStageSpec<TState, TContext, TReporter, TKind, THelper, TInput, TOutput>) => Program<TState | Halt<TRunResult>>;
+//# sourceMappingURL=pipeline-program-utils.d.ts.map

package/dist/internal/pipeline-program-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-program-utils.d.ts","sourceRoot":"","sources":["../../src/internal/pipeline-program-utils.ts"],"names":[],"mappings":"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"}

package/dist/internal/pipeline-program-utils.js

@@ -0,0 +1,161 @@
+import { maybeTry as g, maybeThen as H, isPromiseLike as S } from "../async-utils.js";
+import { executeHelpers as x } from "../executor.js";
+import { runRollbackStack as y } from "../rollback.js";
+function O(r) {
+  return !!(r && typeof r == "object" && "__halt" in r && r.__halt === !0);
+}
+function C(r) {
+  const {
+    getOrder: t,
+    makeArgs: n,
+    invoke: o,
+    recordStep: l,
+    onVisited: a,
+    registerRollback: k
+  } = r, b = (c, i, p) => {
+    const s = o({ helper: c, args: i, next: p });
+    return k ? S(s) ? s.then((e) => {
+      k(c, e);
+    }) : (k(c, s), s) : s;
+  };
+  return (c) => {
+    const i = t(c), p = x(i, n(c), b, l);
+    return H(
+      p,
+      (s) => a(c, s)
+    );
+  };
+}
+function T(r) {
+  const { isHalt: t, snapshotFragments: n, applyArtifact: o } = r;
+  return (l) => t(l) ? l : o(l, n(l));
+}
+function _(r) {
+  const { isHalt: t, execute: n } = r;
+  return (o) => t(o) ? o : n(o);
+}
+function z(r) {
+  const { isHalt: t, commit: n, rollbackToHalt: o } = r, l = (a) => {
+    const k = () => a;
+    return g(
+      () => H(n(a), k),
+      (c) => o(a, c)
+    );
+  };
+  return (a) => t(a) ? a : l(a);
+}
+function V(r) {
+  const { isHalt: t, finalize: n } = r;
+  return (o) => t(o) ? o : n(o);
+}
+function E(r, t) {
+  const { context: n, rollbackContext: o, helperRollbacks: l, onHelperRollbackError: a } = r, k = o.extensionCoordinator && o.extensionState ? o.extensionCoordinator.createRollbackHandler(
+    o.extensionState
+  ) : (i) => {
+    throw i;
+  };
+  return g(() => H(
+    y(
+      l.map((i) => ({
+        ...i.rollback,
+        key: i.helper.key
+      })),
+      {
+        source: "helper",
+        onError: ({
+          error: i,
+          metadata: p,
+          entry: s
+        }) => {
+          const e = l.find(
+            (u) => u.helper.key === (s.key ?? "")
+          );
+          e && a && a({
+            error: i,
+            helper: e.helper,
+            errorMetadata: p,
+            context: n
+          });
+        }
+      }
+    ),
+    () => k(t)
+  ), () => {
+  });
+}
+function P(r) {
+  const { state: t, program: n, rollbackPlan: o, halt: l } = r;
+  return g(() => n(t), (b) => F(
+    {
+      rollbackPlan: o,
+      halt: l
+    },
+    b
+  ));
+}
+function F(r, t) {
+  return H(
+    E(r.rollbackPlan, t),
+    () => r.halt(t)
+  );
+}
+function j(r) {
+  return function(n) {
+    const {
+      pushStep: o,
+      toRollbackContext: l,
+      halt: a,
+      isHalt: k,
+      onHelperRollbackError: b
+    } = r, c = ({
+      helper: e,
+      args: u,
+      next: m
+    }) => e.apply(u, m), i = (e) => o(e), p = (e) => (u, m) => {
+      if (!(!m || typeof m != "object") && "rollback" in m) {
+        const f = m.rollback;
+        f && e.push({ helper: u, rollback: f });
+      }
+    }, s = () => b ? (e) => b({
+      ...e,
+      helper: e.helper
+    }) : void 0;
+    return (e) => {
+      if (k(e))
+        return e;
+      const u = [
+        ...n.readRollbacks?.(e) ?? []
+      ], m = l(e), f = C({
+        getOrder: n.getOrder,
+        makeArgs: n.makeArgs,
+        invoke: c,
+        recordStep: i,
+        onVisited: (h, R) => n.onVisited(h, R, u),
+        registerRollback: p(u)
+      }), d = {
+        context: m.context,
+        rollbackContext: m,
+        helperRollbacks: u,
+        onHelperRollbackError: s()
+      };
+      return P({
+        state: e,
+        program: f,
+        rollbackPlan: d,
+        halt: a
+      });
+    };
+  };
+}
+export {
+  C as createHelpersProgram,
+  O as isHalt,
+  _ as makeAfterFragmentsStage,
+  z as makeCommitStage,
+  T as makeFinalizeFragmentsStage,
+  V as makeFinalizeResultStage,
+  j as makeHelperStageFactory,
+  E as runHelperRollbackPlan,
+  P as runHelperStageWithRollback,
+  F as runRollbackToHalt
+};