@wpkernel/pipeline 0.12.6-beta.3 → 1.1.0

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

@@ -1,4 +1,3 @@
 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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AAGzB,YAAY,EACX,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,GACzB,MAAM,YAAY,CAAC"}

package/dist/core/index.js

@@ -1,38 +1,36 @@
 import { composeK as o, isPromiseLike as t, maybeAll as a, maybeThen as l, maybeTry as p, processSequentially as n } from "./async-utils.js";
 import { createPipelineExtension as c } from "./createExtension.js";
 import { compareHelpers as m, createDependencyGraph as x, createHelperId as f } 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 P } from "./registration.js";
-import { createPipelineRollback as S, createRollbackErrorMetadata as T, runRollbackStack as g } from "./rollback.js";
-import { makePipeline as F } from "./makePipeline.js";
-import { executeHelpers as N } from "./execution-utils.js";
-import { OFFICIAL_EXTENSION_BLUEPRINTS as D } from "./extensions/official.js";
-import { commitExtensionResults as _, rollbackExtensionResults as q, runExtensionHooks as B } from "./extensions/runner.js";
+import { createDefaultError as E, createErrorFactory as u } from "./error-factory.js";
+import { createHelper as y } from "./helper.js";
+import { handleExtensionRegisterResult as R, registerExtensionHook as d, registerHelper as P } from "./registration.js";
+import { createPipelineRollback as h, createRollbackErrorMetadata as D, runRollbackStack as S } from "./rollback.js";
+import { makePipeline as q } from "./makePipeline.js";
+import { executeHelpers as F } from "./execution-utils.js";
+import { commitExtensionResults as I, rollbackExtensionResults as K, runExtensionHooks as L } from "./extensions/runner.js";
 export {
-  D as OFFICIAL_EXTENSION_BLUEPRINTS,
-  _ as commitExtensionResults,
+  I as commitExtensionResults,
   m as compareHelpers,
   o as composeK,
-  k as createDefaultError,
+  E as createDefaultError,
   x as createDependencyGraph,
   u as createErrorFactory,
-  b as createHelper,
+  y as createHelper,
   f as createHelperId,
   c as createPipelineExtension,
-  S as createPipelineRollback,
-  T as createRollbackErrorMetadata,
-  N as executeHelpers,
-  H as handleExtensionRegisterResult,
+  h as createPipelineRollback,
+  D as createRollbackErrorMetadata,
+  F as executeHelpers,
+  R as handleExtensionRegisterResult,
   t as isPromiseLike,
-  F as makePipeline,
+  q as makePipeline,
   a as maybeAll,
   l as maybeThen,
   p as maybeTry,
   n as processSequentially,
-  I as registerExtensionHook,
+  d as registerExtensionHook,
   P as registerHelper,
-  q as rollbackExtensionResults,
-  B as runExtensionHooks,
-  g as runRollbackStack
+  K as rollbackExtensionResults,
+  L as runExtensionHooks,
+  S as runRollbackStack
 };

package/dist/core/makeResumablePipeline.d.ts

@@ -0,0 +1,6 @@
+import { PipelineDiagnostic, PipelineReporter, PipelineRunState, AgnosticPipelineOptions, ResumablePipeline } from './types';
+import { AgnosticState } from './runner/types';
+export declare function makeResumablePipeline<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>): ResumablePipeline<TRunOptions, TRunResult, TContext, TReporter, AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>>;
+//# sourceMappingURL=makeResumablePipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeResumablePipeline.d.ts","sourceRoot":"","sources":["../../src/core/makeResumablePipeline.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAKX,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAEhB,uBAAuB,EACvB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAIjB,OAAO,KAAK,EAKX,aAAa,EACb,MAAM,gBAAgB,CAAC;AAExB,wBAAgB,qBAAqB,CACpC,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,iBAAiB,CACnB,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAC,CACxE,CAkYA"}

package/dist/core/makeResumablePipeline.js

@@ -0,0 +1,160 @@
+import { maybeThen as u, isPromiseLike as g, maybeAll as C } from "./async-utils.js";
+import { registerHelper as M, handleExtensionRegisterResult as w } from "./registration.js";
+import { initAgnosticResumableRunner as P } from "./runner/index.js";
+import { createAgnosticDiagnosticManager as S } from "./runner/diagnostics.js";
+import { isPaused as b } from "./runner/stage-factories.js";
+function O(n) {
+  const R = n.createError ?? ((e, r) => new Error(`[${e}] ${r} `)), l = /* @__PURE__ */ new Map(), h = (e) => (l.has(e) || l.set(e, []), l.get(e));
+  for (const e of n.helperKinds)
+    h(e);
+  const x = [], c = [], i = S({
+    onDiagnostic: (e) => {
+      n.onDiagnostic ? n.onDiagnostic(e) : e.reporter.warn?.(
+        "Pipeline diagnostic reported.",
+        e.diagnostic
+      );
+    },
+    createConflictDiagnostic: n.createConflictDiagnostic,
+    createMissingDependencyDiagnostic: n.createMissingDependencyDiagnostic,
+    createUnusedHelperDiagnostic: n.createUnusedHelperDiagnostic
+  }), p = (e) => {
+    const r = [];
+    for (const t of n.helperKinds)
+      r.push(e.makeHelperStage(t));
+    return r.push(e.finalizeResult), r;
+  }, E = {
+    options: {
+      createContext: n.createContext,
+      createState: (e) => n.createState ? n.createState(e) : {},
+      createError: R,
+      supportsPause: !0,
+      onExtensionRollbackError: (e) => {
+        n.onExtensionRollbackError && n.onExtensionRollbackError(e);
+        const r = {
+          ...e,
+          extensions: e.extensionKeys,
+          hookKeys: e.hookSequence,
+          errorName: e.errorMetadata?.name,
+          errorMessage: e.errorMetadata?.message,
+          errorStack: e.errorMetadata?.stack,
+          errorCause: e.errorMetadata?.cause,
+          ...e.errorMetadata
+        };
+        e.context.reporter.warn?.(
+          "Pipeline extension rollback failed.",
+          r
+        );
+      },
+      onHelperRollbackError: (e) => {
+        e.context.reporter.warn?.("Helper rollback failed", e);
+      },
+      providedKeys: n.providedKeys
+    },
+    helperRegistries: l,
+    diagnosticManager: i,
+    resolveRunResult: (e) => {
+      const {
+        userState: r,
+        diagnostics: t,
+        steps: s,
+        context: o,
+        options: a,
+        state: v
+      } = e;
+      return n.createRunResult ? n.createRunResult({
+        artifact: r,
+        diagnostics: t,
+        steps: s,
+        context: o,
+        options: a,
+        state: v
+      }) : {
+        artifact: r,
+        diagnostics: t,
+        steps: s
+      };
+    },
+    extensionHooks: x,
+    extensionLifecycles: n.extensions?.lifecycles,
+    stages: n.createStages ?? p
+  }, f = P(E), D = (e, r) => w(e, r, x), y = (e) => {
+    if (g(e)) {
+      const r = u(
+        e,
+        () => {
+        }
+      );
+      r.catch(() => {
+      }), c.push(r);
+      const t = () => {
+        const s = c.indexOf(r);
+        s !== -1 && c.splice(s, 1);
+      };
+      r.then(t, t);
+    }
+    return e;
+  }, m = () => {
+    if (c.length !== 0)
+      return u(
+        C([...c]),
+        () => {
+        }
+      );
+  }, d = (e) => (b(e) || i.endRun(), e), k = {
+    extensions: {
+      use(e) {
+        const r = e.register(k);
+        r && g(r) && Promise.resolve(r).catch(() => {
+        });
+        const t = u(
+          r,
+          (s) => D(e.key, s)
+        );
+        return y(t);
+      }
+    },
+    use(e) {
+      const r = e.kind, t = h(r);
+      M(
+        e,
+        r,
+        t,
+        r,
+        (s, o, a) => i.flagConflict(
+          s,
+          o,
+          r,
+          a
+        ),
+        R
+      );
+    },
+    run(e) {
+      try {
+        const r = () => {
+          const o = f.prepareContext(e);
+          return f.executeRun(o);
+        }, t = m(), s = u(t, () => r());
+        return g(s) ? Promise.resolve(s).then(d).catch((o) => {
+          throw i.endRun(), o;
+        }) : d(s);
+      } catch (r) {
+        throw i.endRun(), r;
+      }
+    },
+    resume(e, r) {
+      try {
+        const t = () => f.executeResume(e, r), s = m(), o = u(s, () => t());
+        return g(o) ? Promise.resolve(o).then(d).catch((a) => {
+          throw i.endRun(), a;
+        }) : d(o);
+      } catch (t) {
+        throw i.endRun(), t;
+      }
+    }
+  };
+  return k;
+}
+export {
+  O as makeResumablePipeline
+};

package/dist/core/runner/context.d.ts

@@ -1,5 +1,5 @@
-import { AgnosticRunContext, AgnosticRunnerDependencies } from './types';
-import { PipelineReporter, PipelineDiagnostic } from '../types';
+import { AgnosticRunContext, AgnosticRunnerDependencies, AgnosticState } from './types';
+import { PipelineReporter, PipelineDiagnostic, PipelinePauseSnapshot } from '../types';
 /**
  * Prepares the pipeline execution context.
  *
@@ -10,4 +10,7 @@ import { PipelineReporter, PipelineDiagnostic } from '../types';
 export declare const prepareContext: <TRunOptions, TUserState, TContext extends {
     reporter: TReporter;
 }, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult>(dependencies: AgnosticRunnerDependencies<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>, runOptions: TRunOptions) => AgnosticRunContext<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>;
+export declare const prepareResumeContext: <TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult>(dependencies: AgnosticRunnerDependencies<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>, snapshot: PipelinePauseSnapshot<AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>>) => AgnosticRunContext<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>;
 //# sourceMappingURL=context.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/core/runner/context.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACX,kBAAkB,EAClB,0BAA0B,EAE1B,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAElB,MAAM,UAAU,CAAC;AAIlB;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAC1B,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,EACD,YAAY,WAAW,KACrB,kBAAkB,CACpB,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CA6HX,CAAC"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/core/runner/context.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACX,kBAAkB,EAClB,0BAA0B,EAC1B,aAAa,EACb,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAElB,qBAAqB,EACrB,MAAM,UAAU,CAAC;AAIlB;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAC1B,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,EACD,YAAY,WAAW,KACrB,kBAAkB,CACpB,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CA6HX,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAChC,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,EACD,UAAU,qBAAqB,CAC9B,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAC,CACxE,KACC,kBAAkB,CACpB,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CAkDX,CAAC"}

package/dist/core/runner/context.js

@@ -1,57 +1,57 @@
-import { createDependencyGraph as M } from "../dependency-graph.js";
-import { initExtensionCoordinator as R } from "../internal/extension-coordinator.js";
-const E = (e, n) => {
-  const o = e.options.createContext(n);
-  e.diagnosticManager.prepareRun(), e.diagnosticManager.setReporter(o.reporter);
+import { createDependencyGraph as x } from "../dependency-graph.js";
+import { initExtensionCoordinator as f } from "../internal/extension-coordinator.js";
+const M = (e, o) => {
+  const t = e.options.createContext(o);
+  e.diagnosticManager.prepareRun(), e.diagnosticManager.setReporter(t.reporter);
   const s = /* @__PURE__ */ new Map();
-  for (const [r, i] of e.helperRegistries) {
-    const f = M(
-      i,
+  for (const [r, h] of e.helperRegistries) {
+    const d = x(
+      h,
       {
-        onMissingDependency: (t) => {
+        onMissingDependency: (a) => {
           e.diagnosticManager.flagMissingDependency(
-            t.dependant.helper,
-            t.dependencyKey,
+            a.dependant.helper,
+            a.dependencyKey,
             r
           ), e.diagnosticManager.flagUnusedHelper(
-            t.dependant.helper,
+            a.dependant.helper,
             r,
             "has missing dependencies",
-            t.dependant.helper.dependsOn ?? []
+            a.dependant.helper.dependsOn ?? []
           );
         },
-        onUnresolvedHelpers: ({ unresolved: t }) => {
-          for (const l of t)
+        onUnresolvedHelpers: ({ unresolved: a }) => {
+          for (const R of a)
             e.diagnosticManager.flagUnusedHelper(
-              l.helper,
+              R.helper,
               r,
               "has unresolved dependencies (possible cycle)",
-              l.helper.dependsOn ?? []
+              R.helper.dependsOn ?? []
             );
         },
         providedKeys: e.options.providedKeys?.[r]
       },
       e.options.createError
     );
-    s.set(r, f.order);
+    s.set(r, d.order);
   }
-  const c = e.options.createState({
-    context: o,
-    options: n
-  }), a = [], g = (r) => a.push(r), p = (r) => {
+  const i = e.options.createState({
+    context: t,
+    options: o
+  }), p = [], c = (r) => p.push(r), l = (r) => {
     e.options.onExtensionRollbackError && e.options.onExtensionRollbackError(r);
-  }, h = (r, i) => ({
-    context: o,
-    options: n,
+  }, n = (r, h) => ({
+    context: t,
+    options: o,
     artifact: r.userState,
     // Extension expects UserState
-    lifecycle: i
-  }), d = {
-    context: o,
-    reporter: o.reporter,
-    runOptions: n,
-    userState: c,
-    steps: a,
+    lifecycle: h
+  }), g = {
+    context: t,
+    reporter: t.reporter,
+    runOptions: o,
+    userState: i,
+    steps: p,
     diagnostics: e.diagnosticManager.getDiagnostics(),
     // Live reference
     // AgnosticState definition has diagnostics: TDiagnostic[]. Programs read it from here.
@@ -62,25 +62,48 @@ const E = (e, n) => {
     // Runtime maps
     helperExecution: /* @__PURE__ */ new Map(),
     helperRollbacks: /* @__PURE__ */ new Map(),
-    extensionCoordinator: R(
-      (r) => p({
+    extensionCoordinator: f(
+      (r) => l({
         ...r,
-        context: o
+        context: t
       })
     )
   };
   return {
-    runOptions: n,
-    context: o,
-    state: d,
-    steps: a,
-    pushStep: g,
+    runOptions: o,
+    context: t,
+    state: g,
+    steps: p,
+    pushStep: c,
     helperRegistries: e.helperRegistries,
     helperOrders: s,
-    buildHookOptions: h,
-    handleRollbackError: p
+    buildHookOptions: n,
+    handleRollbackError: l
+  };
+}, b = (e, o) => {
+  const t = o.state, s = t.context;
+  e.diagnosticManager.setReporter(s.reporter);
+  const i = t.steps, p = (n) => i.push(n), c = (n) => {
+    e.options.onExtensionRollbackError && e.options.onExtensionRollbackError(n);
+  }, l = (n, g) => ({
+    context: s,
+    options: t.runOptions,
+    artifact: n.userState,
+    lifecycle: g
+  });
+  return {
+    runOptions: t.runOptions,
+    context: s,
+    state: t,
+    steps: i,
+    pushStep: p,
+    helperRegistries: t.helperRegistries,
+    helperOrders: t.helperOrders ?? /* @__PURE__ */ new Map(),
+    buildHookOptions: l,
+    handleRollbackError: c
   };
 };
 export {
-  E as prepareContext
+  M as prepareContext,
+  b as prepareResumeContext
 };

package/dist/core/runner/execution.d.ts

@@ -1,6 +1,12 @@
-import { AgnosticRunContext, AgnosticRunnerDependencies } from './types';
-import { PipelineReporter, PipelineDiagnostic, MaybePromise } from '../types';
+import { AgnosticRunContext, AgnosticRunnerDependencies, AgnosticState } from './types';
+import { PipelineReporter, PipelineDiagnostic, MaybePromise, PipelinePauseSnapshot, PipelinePaused } from '../types';
 export declare const executeRun: <TRunOptions, TUserState, TContext extends {
     reporter: TReporter;
 }, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult>(dependencies: AgnosticRunnerDependencies<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>, runContext: AgnosticRunContext<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>) => MaybePromise<TRunResult>;
+export declare const executeRunWithPause: <TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult>(dependencies: AgnosticRunnerDependencies<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>, runContext: AgnosticRunContext<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>) => MaybePromise<TRunResult | PipelinePaused<AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>>>;
+export declare const executeResume: <TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult>(dependencies: AgnosticRunnerDependencies<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>, snapshot: PipelinePauseSnapshot<AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>>, resumeInput?: unknown) => MaybePromise<TRunResult | PipelinePaused<AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>>>;
 //# sourceMappingURL=execution.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../../../src/core/runner/execution.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,kBAAkB,EAClB,0BAA0B,EAM1B,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACZ,MAAM,UAAU,CAAC;AAalB,eAAO,MAAM,UAAU,GACtB,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,EACD,YAAY,kBAAkB,CAC7B,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CACX,KACC,YAAY,CAAC,UAAU,CAkHzB,CAAC"}
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../../../src/core/runner/execution.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,kBAAkB,EAClB,0BAA0B,EAC1B,aAAa,EAOb,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,MAAM,UAAU,CAAC;AAyMlB,eAAO,MAAM,UAAU,GACtB,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,EACD,YAAY,kBAAkB,CAC7B,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CACX,KACC,YAAY,CAAC,UAAU,CA2EzB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC/B,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,EACD,YAAY,kBAAkB,CAC7B,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CACX,KACC,YAAY,CACZ,UAAU,GACV,cAAc,CACd,aAAa,CACZ,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CACX,CACA,CAqCH,CAAC;AAEF,eAAO,MAAM,aAAa,GACzB,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,EACD,UAAU,qBAAqB,CAC9B,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAC,CACxE,EACD,cAAc,OAAO,KACnB,YAAY,CACZ,UAAU,GACV,cAAc,CACd,aAAa,CACZ,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,CACX,CACA,CAgCH,CAAC"}

package/dist/core/runner/execution.js

@@ -1,66 +1,136 @@
-import { maybeThen as i } from "../async-utils.js";
-import { createAgnosticProgram as f } from "./program.js";
-const s = (o) => ({
-  kind: o,
+import { maybeThen as m, isPromiseLike as y } from "../async-utils.js";
+import { createAgnosticStages as R, createAgnosticProgram as P } from "./program.js";
+import { isHalt as c, isPaused as f } from "./stage-factories.js";
+import { prepareResumeContext as l } from "./context.js";
+const S = (e) => ({
+  kind: e,
   registered: [],
   executed: [],
   missing: []
-}), h = (o, e) => {
+}), k = (e, t) => ({
+  ...e,
+  stageIndex: t
+}), x = (e, t) => {
+  const i = t.extensionStack ?? [], s = i.length === 0 && t.extensionCoordinator && t.extensionState ? () => t.extensionCoordinator.commit(t.extensionState) : void 0, n = s ? s() : i.reduce(
+    (a, {
+      coordinator: o,
+      state: r
+    }) => m(a, () => o.commit(r)),
+    void 0
+  );
+  return m(
+    n,
+    () => e.resolveRunResult({
+      diagnostics: t.diagnostics,
+      steps: t.steps,
+      context: t.context,
+      userState: t.userState,
+      options: t.runOptions,
+      helpers: {
+        fragments: S("dummy-fragment"),
+        builders: S("dummy-builder")
+      },
+      state: t
+    })
+  );
+}, h = (e, t, i) => {
+  const s = (n, a) => {
+    let o = n;
+    for (let r = a; r < e.length; r += 1) {
+      const p = e[r];
+      if (!p)
+        return o;
+      const b = k(o, r), u = p(b);
+      if (y(u))
+        return Promise.resolve(u).then((g) => c(g) || f(g) ? g : s(
+          g,
+          r + 1
+        ));
+      if (c(u) || f(u))
+        return u;
+      o = u;
+    }
+    return o;
+  };
+  return s(t, i);
+}, O = (e, t) => {
   const {
-    runOptions: m,
-    context: c
-  } = e, n = e.state;
-  if (!o.stages)
-    return o.resolveRunResult({
+    runOptions: i,
+    context: s
+  } = t, n = t.state;
+  if (!e.stages)
+    return e.resolveRunResult({
       diagnostics: [],
       steps: [],
-      context: c,
+      context: s,
       userState: n.userState,
-      options: m,
+      options: i,
       helpers: {
-        builders: s("dummy-builder")
+        builders: S("dummy-builder")
       },
       state: n
     });
-  const p = f(o, e);
-  return i(
-    p(n),
-    (t) => {
-      if (t && typeof t == "object" && "__halt" in t) {
-        if (t.error)
-          throw t.error;
-        return t.result;
+  const a = P(e, t);
+  return m(
+    a(n),
+    (o) => {
+      if (c(o)) {
+        if (o.error)
+          throw o.error;
+        return o.result;
       }
-      const r = t.extensionStack ?? [], a = r.length === 0 && t.extensionCoordinator && t.extensionState ? () => t.extensionCoordinator.commit(
-        t.extensionState
-      ) : void 0, g = a ? a() : r.reduce(
-        (d, {
-          coordinator: x,
-          state: S
-        }) => i(
-          d,
-          () => x.commit(S)
-        ),
-        void 0
-      );
-      return i(
-        g,
-        () => o.resolveRunResult({
-          diagnostics: t.diagnostics,
-          steps: t.steps,
-          context: t.context,
-          userState: t.userState,
-          options: t.runOptions,
-          helpers: {
-            fragments: s("dummy-fragment"),
-            builders: s("dummy-builder")
-          },
-          state: t
-        })
-      );
+      if (f(o))
+        throw new Error(
+          "Pipeline paused during executeRun. Use makeResumablePipeline to enable pause/resume."
+        );
+      return x(e, o);
     }
   );
+}, A = (e, t) => {
+  const { runOptions: i, context: s } = t, n = t.state;
+  if (!e.stages)
+    return e.resolveRunResult({
+      diagnostics: [],
+      steps: [],
+      context: s,
+      userState: n.userState,
+      options: i,
+      helpers: {
+        builders: S("dummy-builder")
+      },
+      state: n
+    });
+  const a = R(e, t), o = h(a, n, 0);
+  return m(o, (r) => {
+    if (c(r)) {
+      if (r.error)
+        throw r.error;
+      return r.result;
+    }
+    return f(r) ? r : x(e, r);
+  });
+}, E = (e, t, i) => {
+  if (!e.stages)
+    return x(e, t.state);
+  const s = l(e, t), n = {
+    ...s.state,
+    resumeInput: i
+  }, a = R(e, s), o = h(
+    a,
+    n,
+    t.stageIndex
+  );
+  return m(o, (r) => {
+    if (c(r)) {
+      if (r.error)
+        throw r.error;
+      return r.result;
+    }
+    return f(r) ? r : x(e, r);
+  });
 };
 export {
-  h as executeRun
+  E as executeResume,
+  O as executeRun,
+  A as executeRunWithPause
 };

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

@@ -1,4 +1,4 @@
-import { AgnosticRunner, AgnosticRunnerDependencies } from './types';
+import { AgnosticResumableRunner, AgnosticRunner, AgnosticRunnerDependencies } from './types';
 import { PipelineReporter, PipelineDiagnostic } from '../types';
 /**
  * Initializes an agnostic pipeline runner.
@@ -11,4 +11,7 @@ import { PipelineReporter, PipelineDiagnostic } from '../types';
 export declare const initAgnosticRunner: <TRunOptions, TUserState, TContext extends {
     reporter: TReporter;
 }, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult>(dependencies: AgnosticRunnerDependencies<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>) => AgnosticRunner<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>;
+export declare const initAgnosticResumableRunner: <TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult>(dependencies: AgnosticRunnerDependencies<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>) => AgnosticResumableRunner<TRunOptions, TUserState, TContext, TReporter, TDiagnostic, TRunResult>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/runner/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC9B,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,KACC,cAAc,CAChB,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CAOV,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/runner/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,uBAAuB,EACvB,cAAc,EACd,0BAA0B,EAC1B,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC9B,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,KACC,cAAc,CAChB,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CAOV,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACvC,WAAW,EACX,UAAU,EACV,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EACtC,UAAU,EAEV,cAAc,0BAA0B,CACvC,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CACV,KACC,uBAAuB,CACzB,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,WAAW,EACX,UAAU,CASV,CAAC"}