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

package/dist/core/runner/program.js

@@ -0,0 +1,146 @@
+import { composeK as h, maybeThen as b } from "../async-utils.js";
+import { makeCommitStage as R, makeAfterFragmentsStage as H, makeFinalizeResultStage as A, isHalt as c, makeHelperStageFactory as w } from "./stage-factories.js";
+const L = (r, l) => {
+  const f = (o) => ({
+    __halt: !0,
+    error: o
+  }), g = (o) => (t) => ({
+    context: o.context,
+    reporter: o.reporter,
+    userState: o.userState
+  }), u = {
+    pushStep: l.pushStep,
+    toRollbackContext: (o) => ({
+      context: o.context,
+      extensionCoordinator: o.extensionCoordinator,
+      extensionState: o.extensionState,
+      extensionStack: o.extensionStack
+    }),
+    halt: f,
+    isHalt: c,
+    onHelperRollbackError: r.options.onHelperRollbackError
+  }, x = w({
+    pushStep: l.pushStep,
+    toRollbackContext: (o) => ({
+      context: o.context,
+      extensionCoordinator: o.extensionCoordinator,
+      extensionState: o.extensionState,
+      extensionStack: o.extensionStack
+    }),
+    halt: f,
+    isHalt: c,
+    onHelperRollbackError: r.options.onHelperRollbackError
+  }), k = (o, t, i) => {
+    const a = {
+      getOrder: (e) => e.helperOrders?.get(o) ?? [],
+      makeArgs: g,
+      onVisited: (e, n, s) => t?.onVisited ? t.onVisited(e, n, s) : e,
+      readRollbacks: (e) => e.helperRollbacks?.get(o)?.map((n) => n.helper) ?? [],
+      invoke: ({
+        helper: e,
+        args: n,
+        next: s
+      }) => {
+        if (typeof e == "function")
+          return e(n, s);
+        if (typeof e == "object" && e !== null && "apply" in e && typeof e.apply == "function")
+          return e.apply(n, s);
+        throw new Error(
+          `Invalid helper: expected function or object with .apply method. Got: ${typeof e}`
+        );
+      },
+      ...t
+    };
+    return t?.makeArgs ? a.makeArgs = t.makeArgs : i && (a.makeArgs = (e) => (n) => i({
+      state: e,
+      helper: n.helper,
+      context: e.context
+    })), x(
+      o,
+      a
+    );
+  }, m = (o) => H({
+    isHalt: c,
+    execute: (t) => {
+      t.executedLifecycles.add(o);
+      const i = t.extensionCoordinator;
+      if (!i)
+        return t;
+      const a = l.buildHookOptions(
+        t,
+        o
+      );
+      return b(
+        i.runLifecycle(
+          o,
+          {
+            hooks: r.extensionHooks,
+            hookOptions: a
+          }
+        ),
+        (e) => ({
+          ...t,
+          extensionState: e,
+          extensionStack: [
+            ...t.extensionStack ?? [],
+            {
+              coordinator: i,
+              state: e
+            }
+          ],
+          userState: e.artifact
+        })
+      );
+    }
+  }), S = R({
+    isHalt: c,
+    commit: (o) => {
+      const t = o.extensionCoordinator;
+      if (t)
+        return t.commit(o.extensionState);
+    },
+    rollbackToHalt: (o, t) => ({
+      __halt: !0,
+      error: t
+    })
+  }), p = A({
+    isHalt: c,
+    finalize: (o) => {
+      const i = {
+        ...o,
+        diagnostics: r.diagnosticManager.readDiagnostics()
+      };
+      if (r.extensionHooks.length > 0) {
+        const a = i.executedLifecycles, e = /* @__PURE__ */ new Set();
+        for (const n of r.extensionHooks)
+          a?.has(n.lifecycle) || e.add(n.lifecycle);
+        if (e.size > 0) {
+          const n = Array.from(e).map((s) => `"${s}"`).join(", ");
+          i.reporter.warn?.(
+            `The following extension hooks will be ignored because their lifecycles were not executed: ${n}`
+          );
+        }
+      }
+      return i;
+    }
+  }), y = {
+    runnerEnv: u,
+    finalizeResult: p,
+    makeLifecycleStage: m,
+    commitStage: S,
+    makeHelperStage: k,
+    extensions: {
+      lifecycles: r.extensionLifecycles
+    },
+    diagnosticManager: r.diagnosticManager
+  };
+  if (!r.stages)
+    throw new Error(
+      "Agnostic Runner requires 'stages' factory to be defined."
+    );
+  const d = r.stages(y);
+  return h(...[...d].reverse());
+};
+export {
+  L as createAgnosticProgram
+};

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

@@ -0,0 +1,48 @@
+import { Program } from '../async-utils';
+import { MaybePromise, PipelineExtensionRollbackErrorMetadata } from '../types';
+import { Halt, HelperRollbackPlan, RollbackContext, RollbackEntry } from './types';
+export type RollbackToHaltPlan<TRunResult, TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}> = {
+    readonly rollbackPlan: HelperRollbackPlan<TContext, TOptions, TArtifact, THelper>;
+    readonly halt: (error?: unknown) => Halt<TRunResult>;
+};
+/**
+ * Executes a rollback plan for a helper stage failure.
+ * It coordinates helper-specific rollbacks and extension rollbacks.
+ * @param plan
+ * @param error
+ */
+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 declare function runRollbackToHalt<TRunResult, TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}>(plan: RollbackToHaltPlan<TRunResult, TContext, TOptions, TArtifact, THelper>, error: unknown): MaybePromise<Halt<TRunResult>>;
+/**
+ * Builds a rollback handler that first drains helper rollbacks (when present) and then defers to
+ * extension rollback handling.
+ * @param state
+ * @param helperRollbacks
+ * @param onHelperRollbackError
+ */
+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>;
+//# sourceMappingURL=rollback.d.ts.map

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

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

package/dist/core/runner/rollback.js

@@ -0,0 +1,75 @@
+import { maybeTry as p, maybeThen as b } from "../async-utils.js";
+import { runRollbackStack as R } from "../rollback.js";
+function m(n, o) {
+  const { context: u, rollbackContext: e, helperRollbacks: c, onHelperRollbackError: k } = n, l = (e.extensionStack ?? []).map(
+    ({ coordinator: r, state: t }) => r.createRollbackHandler(t)
+  );
+  l.length === 0 && e.extensionCoordinator && e.extensionState && l.push(
+    e.extensionCoordinator.createRollbackHandler(
+      e.extensionState
+    )
+  );
+  const h = (r) => {
+    if (l.length === 0)
+      throw r;
+    const t = (a) => {
+      if (a < 0)
+        return;
+      const s = l[a], i = () => t(a - 1);
+      return p(
+        () => b(s(r), i),
+        i
+      );
+    };
+    return t(l.length - 1);
+  };
+  return p(() => b(
+    R(
+      c.map((r) => ({
+        ...r.rollback,
+        key: r.helper.key
+      })),
+      {
+        source: "helper",
+        onError: ({
+          error: r,
+          metadata: t,
+          entry: a
+        }) => {
+          const s = c.find(
+            (i) => i.helper.key === (a.key ?? "")
+          );
+          s && k && k({
+            error: r,
+            helper: s.helper,
+            errorMetadata: t,
+            context: u
+          });
+        }
+      }
+    ),
+    () => h(o)
+  ), () => {
+  });
+}
+function y(n) {
+  const { state: o, program: u, rollbackPlan: e, halt: c } = n;
+  return p(() => u(o), (h) => d(
+    {
+      rollbackPlan: e,
+      halt: c
+    },
+    h
+  ));
+}
+function d(n, o) {
+  return b(
+    m(n.rollbackPlan, o),
+    () => n.halt(o)
+  );
+}
+export {
+  m as runHelperRollbackPlan,
+  y as runHelperStageWithRollback,
+  d as runRollbackToHalt
+};

package/dist/core/runner/stage-factories.d.ts

@@ -0,0 +1,69 @@
+import { Program } from '../async-utils';
+import { Helper, HelperApplyOptions, HelperKind, MaybePromise, PipelineReporter } from '../types';
+import { RegisteredHelper } from '../dependency-graph';
+import { Halt, HelperInvokeOptions, StageEnv, HelperStageSpec } from './types';
+export declare function isHalt<TRunResult>(value: unknown): value is Halt<TRunResult>;
+/**
+ * Generic stage constructor that executes an ordered helper list with middleware-style `next()`.
+ * @param options
+ * @param options.getOrder
+ * @param options.makeArgs
+ * @param options.invoke
+ * @param options.recordStep
+ * @param options.onVisited
+ * @param options.registerRollback
+ */
+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.
+ * @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.
+ * @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.
+ * @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.
+ * @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 declare function makeHelperStageFactory<TState, TRunResult, TContext, TOptions, TReporter extends PipelineReporter, TUserState>(config: StageEnv<TState, TRunResult, TContext, TOptions, TReporter, TUserState>): <TKind extends HelperKind, THelper extends Helper<TContext, TInput, TOutput, TReporter, TKind>, TInput, TOutput>(kind: string, spec: HelperStageSpec<TState, TContext, TReporter, TKind, THelper, TInput, TOutput>) => Program<TState | Halt<TRunResult>>;
+//# sourceMappingURL=stage-factories.d.ts.map

package/dist/core/runner/stage-factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-factories.d.ts","sourceRoot":"","sources":["../../../src/core/runner/stage-factories.ts"],"names":[],"mappings":"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"}

package/dist/core/runner/stage-factories.js

@@ -0,0 +1,121 @@
+import { maybeTry as y, maybeThen as S, isPromiseLike as C } from "../async-utils.js";
+import { executeHelpers as E } from "../execution-utils.js";
+import { runHelperStageWithRollback as F } from "./rollback.js";
+function _(r) {
+  return !!(r && typeof r == "object" && "__halt" in r && r.__halt === !0);
+}
+function v(r) {
+  const {
+    getOrder: c,
+    makeArgs: t,
+    invoke: e,
+    recordStep: a,
+    onVisited: i,
+    registerRollback: u
+  } = r, f = (n, k, p) => {
+    const s = e({ helper: n, args: k, next: p });
+    return u ? C(s) ? s.then((o) => {
+      u(n, o);
+    }) : (u(n, s), s) : s;
+  };
+  return (n) => {
+    const k = c(n), p = E(k, t(n), f, a);
+    return S(
+      p,
+      (s) => i(n, s)
+    );
+  };
+}
+function z(r) {
+  const { isHalt: c, snapshotFragments: t, applyArtifact: e } = r;
+  return (a) => c(a) ? a : e(a, t(a));
+}
+function T(r) {
+  const { isHalt: c, execute: t } = r;
+  return (e) => c(e) ? e : t(e);
+}
+function V(r) {
+  const { isHalt: c, commit: t, rollbackToHalt: e } = r, a = (i) => {
+    const u = () => i;
+    return y(
+      () => S(t(i), u),
+      (n) => e(i, n)
+    );
+  };
+  return (i) => c(i) ? i : a(i);
+}
+function j(r) {
+  const { isHalt: c, finalize: t } = r;
+  return (e) => c(e) ? e : t(e);
+}
+function M(r) {
+  return function(t, e) {
+    const {
+      pushStep: a,
+      toRollbackContext: i,
+      halt: u,
+      isHalt: f,
+      onHelperRollbackError: n
+    } = r, k = ({
+      helper: o,
+      args: m,
+      next: l
+    }) => o.apply(m, l), p = (o) => (m, l) => {
+      if (!(!l || typeof l != "object") && "rollback" in l) {
+        const g = l.rollback;
+        g && o.push({ helper: m, rollback: g });
+      }
+    }, s = () => n ? (o) => n({
+      ...o,
+      helper: o.helper
+    }) : void 0;
+    return (o) => {
+      if (f(o))
+        return o;
+      let m = o.helperExecution;
+      m || (m = /* @__PURE__ */ new Map(), o.helperExecution = m);
+      let l = m.get(t);
+      l || (l = {
+        kind: t,
+        executed: [],
+        missing: [],
+        registered: []
+        // Registered populated by getOrder result?
+      }, m.set(t, l));
+      const g = (b) => {
+        a(b), l.executed.push(
+          b.helper.key
+        );
+      }, H = [
+        ...e.readRollbacks?.(o) ?? []
+      ], h = i(o), d = v({
+        getOrder: e.getOrder,
+        makeArgs: e.makeArgs,
+        invoke: k,
+        recordStep: g,
+        onVisited: (b, R) => e.onVisited(b, R, H),
+        registerRollback: p(H)
+      }), x = {
+        context: h.context,
+        rollbackContext: h,
+        helperRollbacks: H,
+        onHelperRollbackError: s()
+      };
+      return F({
+        state: o,
+        program: d,
+        rollbackPlan: x,
+        halt: u
+      });
+    };
+  };
+}
+export {
+  v as createHelpersProgram,
+  _ as isHalt,
+  T as makeAfterFragmentsStage,
+  V as makeCommitStage,
+  z as makeFinalizeFragmentsStage,
+  j as makeFinalizeResultStage,
+  M as makeHelperStageFactory
+};

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

@@ -0,0 +1,202 @@
+import { RegisteredHelper } from '../dependency-graph';
+import { Program } from '../async-utils';
+import { ErrorFactory } from '../error-factory';
+import { Helper, HelperApplyOptions, HelperExecutionSnapshot, HelperKind, MaybePromise, PipelineDiagnostic, PipelineExtensionHookOptions, PipelineExtensionLifecycle, PipelineExtensionRollbackErrorMetadata, PipelineReporter, PipelineStep } from '../types';
+import { PipelineRollback } from '../rollback';
+import { ExtensionCoordinator, ExtensionLifecycleState } from '../internal/extension-coordinator.types';
+import { AgnosticDiagnosticManager } from './diagnostics';
+import { ExtensionHookEntry } from '../extensions';
+export type { HelperExecutionSnapshot };
+export type { ExtensionCoordinator, ExtensionLifecycleState };
+export interface AgnosticRunnerOptions<TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter> {
+    readonly createContext: (options: TRunOptions) => TContext;
+    readonly createState: (options: {
+        readonly context: TContext;
+        readonly options: TRunOptions;
+    }) => TUserState;
+    readonly createError: ErrorFactory;
+    readonly onExtensionRollbackError?: (options: {
+        readonly error: unknown;
+        readonly extensionKeys: readonly string[];
+        readonly hookSequence: readonly string[];
+        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+        readonly context: TContext;
+    }) => void;
+    readonly onHelperRollbackError?: (options: {
+        readonly error: unknown;
+        readonly helper: unknown;
+        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+        readonly context: TContext;
+    }) => void;
+    readonly providedKeys?: Record<string, readonly string[]>;
+}
+/**
+ * Mutable state captured while preparing a pipeline run.
+ *
+ * @category Pipeline
+ * @internal
+ */
+export interface AgnosticRunContext<TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic> {
+    readonly runOptions: TRunOptions;
+    readonly context: TContext;
+    readonly state: AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>;
+    readonly steps: PipelineStep[];
+    readonly pushStep: (entry: RegisteredHelper<unknown>) => void;
+    readonly helperRegistries: Map<string, RegisteredHelper<unknown>[]>;
+    readonly helperOrders: Map<string, RegisteredHelper<unknown>[]>;
+    readonly buildHookOptions: (state: AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>, lifecycle: PipelineExtensionLifecycle) => PipelineExtensionHookOptions<TContext, TRunOptions, TUserState>;
+    readonly handleRollbackError: (options: {
+        readonly error: unknown;
+        readonly extensionKeys: readonly string[];
+        readonly hookSequence: readonly string[];
+        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+        readonly context: TContext;
+    }) => void;
+}
+/**
+ * Closed-world state threaded through composed pipeline programs.
+ *
+ * @category Pipeline
+ * @internal
+ */
+export interface AgnosticState<TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic> {
+    readonly context: TContext;
+    readonly reporter: TReporter;
+    readonly runOptions: TRunOptions;
+    readonly userState: TUserState;
+    readonly helperRegistries: Map<string, RegisteredHelper<unknown>[]>;
+    readonly helperOrders?: Map<string, RegisteredHelper<unknown>[]>;
+    readonly steps: PipelineStep[];
+    readonly diagnostics: TDiagnostic[];
+    readonly executedLifecycles: Set<string>;
+    readonly helperExecution?: Map<string, HelperExecutionSnapshot>;
+    readonly helperRollbacks?: Map<string, Array<{
+        readonly helper: unknown;
+        readonly rollback: PipelineRollback;
+    }>>;
+    readonly extensionCoordinator?: ExtensionCoordinator<TContext, TRunOptions, TUserState>;
+    readonly extensionState?: ExtensionLifecycleState<TContext, TRunOptions, TUserState>;
+    readonly extensionStack?: Array<{
+        readonly coordinator: ExtensionCoordinator<TContext, TRunOptions, TUserState>;
+        readonly state: ExtensionLifecycleState<TContext, TRunOptions, TUserState>;
+    }>;
+}
+export type { ExtensionHookEntry };
+export type RollbackCapableCoordinator<TContext, TOptions, TUserState> = {
+    createRollbackHandler: <TResult>(state: ExtensionLifecycleState<TContext, TOptions, TUserState>) => (error: unknown) => MaybePromise<TResult>;
+};
+export type RollbackEntry<THelper> = {
+    readonly helper: THelper;
+    readonly rollback: PipelineRollback;
+};
+export type Halt<TRunResult> = {
+    readonly __halt: true;
+    readonly error?: unknown;
+    readonly result?: TRunResult;
+};
+export type RollbackContext<TContext, TOptions, TUserState> = {
+    readonly context: TContext;
+    readonly extensionCoordinator?: RollbackCapableCoordinator<TContext, TOptions, TUserState>;
+    readonly extensionState?: ExtensionLifecycleState<TContext, TOptions, TUserState>;
+    readonly extensionStack?: Array<{
+        readonly coordinator: RollbackCapableCoordinator<TContext, TOptions, TUserState>;
+        readonly state: ExtensionLifecycleState<TContext, TOptions, TUserState>;
+    }>;
+};
+export type StageEnv<TState, TRunResult, TContext, TOptions, TReporter extends PipelineReporter, TUserState> = {
+    pushStep: (entry: RegisteredHelper<unknown>) => void;
+    toRollbackContext: (state: TState) => RollbackContext<TContext, TOptions, TUserState>;
+    halt: (error?: unknown) => Halt<TRunResult>;
+    isHalt: (value: unknown) => value is Halt<TRunResult>;
+    onHelperRollbackError?: (options: {
+        readonly error: unknown;
+        readonly helper: Helper<TContext, unknown, unknown, TReporter, HelperKind>;
+        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+        readonly context: TContext;
+    }) => void;
+};
+export type PipelineStage<TState, TResult> = Program<TState | TResult>;
+export type AgnosticStageDeps<TState, TResult, TContext, TRunOptions, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TUserState> = {
+    readonly runnerEnv: StageEnv<TState, TResult, TContext, TRunOptions, TReporter, TUserState>;
+    readonly finalizeResult: PipelineStage<TState, Halt<TResult>>;
+    readonly makeLifecycleStage: (lifecycle: string) => PipelineStage<TState, Halt<TResult>>;
+    readonly commitStage: PipelineStage<TState, Halt<TResult>>;
+    readonly makeHelperStage: (kind: string, spec?: {
+        makeArgs?: (state: TState) => (entry: RegisteredHelper<unknown>) => unknown;
+        onVisited?: (state: TState, visited: Set<string>, rollbacks: unknown[]) => TState;
+    }) => PipelineStage<TState, Halt<TResult>>;
+    readonly extensions: {
+        readonly lifecycles?: readonly string[];
+    };
+    readonly diagnosticManager: AgnosticDiagnosticManager<TReporter, TDiagnostic>;
+};
+/**
+ * Dependency bundle consumed by {@link initAgnosticRunner}.
+ *
+ * @category Pipeline
+ * @internal
+ */
+export interface AgnosticRunnerDependencies<TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult> {
+    readonly options: AgnosticRunnerOptions<TRunOptions, TUserState, TContext, TReporter>;
+    readonly helperRegistries: Map<string, RegisteredHelper<unknown>[]>;
+    readonly diagnosticManager: AgnosticDiagnosticManager<TReporter, TDiagnostic>;
+    readonly resolveRunResult: (state: {
+        readonly diagnostics: readonly TDiagnostic[];
+        readonly steps: readonly PipelineStep[];
+        readonly context: TContext;
+        readonly userState: TUserState;
+        readonly options: TRunOptions;
+        readonly helpers: unknown;
+        readonly state: AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>;
+    }) => TRunResult;
+    readonly extensionHooks: ExtensionHookEntry<TContext, TRunOptions, TUserState>[];
+    readonly extensionLifecycles?: readonly string[];
+    readonly stages?: (deps: AgnosticStageDeps<AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>, TRunResult, TContext, TRunOptions, TReporter, TDiagnostic, TUserState>) => PipelineStage<AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>, Halt<TRunResult>>[];
+}
+export interface AgnosticRunner<TRunOptions, TUserState, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic, TRunResult> {
+    readonly prepareContext: (runOptions: TRunOptions) => AgnosticRunContext<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>;
+    readonly executeRun: (context: AgnosticRunContext<TRunOptions, TUserState, TContext, TReporter, TDiagnostic>) => MaybePromise<TRunResult>;
+}
+export type HelperInvokeOptions<THelper, TInput, TOutput, TContext, TReporter extends PipelineReporter> = {
+    readonly helper: THelper;
+    readonly args: HelperApplyOptions<TContext, TInput, TOutput, TReporter>;
+    readonly next: () => MaybePromise<void>;
+};
+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 type HelperStageRunPlan<TState, TRunResult, TContext, TOptions, TUserState, THelper extends {
+    key: string;
+}> = {
+    readonly state: TState;
+    readonly program: Program<TState>;
+    readonly rollbackPlan: HelperRollbackPlan<TContext, TOptions, TUserState, THelper>;
+    readonly halt: (error?: unknown) => Halt<TRunResult>;
+};
+export type HelperRollbackPlan<TContext, TOptions, TUserState, THelper extends {
+    key: string;
+}> = {
+    readonly context: TContext;
+    readonly rollbackContext: RollbackContext<TContext, TOptions, TUserState>;
+    readonly helperRollbacks: readonly RollbackEntry<THelper>[];
+    readonly onHelperRollbackError?: (options: {
+        readonly error: unknown;
+        readonly helper: THelper;
+        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+        readonly context: TContext;
+    }) => void;
+};
+//# sourceMappingURL=types.d.ts.map