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

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

@@ -1,161 +0,0 @@
-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
-};

package/dist/internal/pipeline-runner.d.ts

@@ -1,18 +0,0 @@
-import { Helper, HelperKind, PipelineReporter, PipelineDiagnostic } from '../types';
-import { PipelineRunner, PipelineRunnerDependencies } from './pipeline-runner.types';
-/**
- * Creates the orchestrator responsible for executing pipeline runs.
- *
- * The runner wires together dependency graph resolution, helper execution, and the official
- * extension framework via the {@link initExtensionCoordinator}. By extracting this logic, the
- * public {@link createPipeline} entry point remains focused on registration while the runner keeps
- * lifecycle sequencing isolated and testable.
- *
- * @param    dependencies - Bundled factory methods, diagnostics, and registered helpers
- * @category Pipeline
- * @internal
- */
-export declare function initPipelineRunner<TRunOptions, TBuildOptions, TContext extends {
-    reporter: TReporter;
-}, TReporter extends PipelineReporter, TDraft, TArtifact, TDiagnostic extends PipelineDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind extends HelperKind, TBuilderKind extends HelperKind, TFragmentHelper extends Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind>, TBuilderHelper extends Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind>>(dependencies: PipelineRunnerDependencies<TRunOptions, TBuildOptions, TContext, TReporter, TDraft, TArtifact, TDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>): PipelineRunner<TRunOptions, TBuildOptions, TContext, TReporter, TDraft, TArtifact, TDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>;
-//# sourceMappingURL=pipeline-runner.d.ts.map

package/dist/internal/pipeline-runner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipeline-runner.d.ts","sourceRoot":"","sources":["../../src/internal/pipeline-runner.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEX,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAQlB,MAAM,UAAU,CAAC;AAMlB,OAAO,KAAK,EAEX,cAAc,EACd,0BAA0B,EAM1B,MAAM,yBAAyB,CAAC;AAejC;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CACjC,WAAW,EACX,aAAa,EACb,QAAQ,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,EACxC,SAAS,SAAS,gBAAgB,EAClC,MAAM,EACN,SAAS,EACT,WAAW,SAAS,kBAAkB,EACtC,UAAU,EACV,cAAc,EACd,eAAe,EACf,aAAa,EACb,cAAc,EACd,aAAa,SAAS,UAAU,EAChC,YAAY,SAAS,UAAU,EAC/B,eAAe,SAAS,MAAM,CAC7B,QAAQ,EACR,cAAc,EACd,eAAe,EACf,SAAS,EACT,aAAa,CACb,EACD,cAAc,SAAS,MAAM,CAC5B,QAAQ,EACR,aAAa,EACb,cAAc,EACd,SAAS,EACT,YAAY,CACZ,EAED,YAAY,EAAE,0BAA0B,CACvC,WAAW,EACX,aAAa,EACb,QAAQ,EACR,SAAS,EACT,MAAM,EACN,SAAS,EACT,WAAW,EACX,UAAU,EACV,cAAc,EACd,eAAe,EACf,aAAa,EACb,cAAc,EACd,aAAa,EACb,YAAY,EACZ,eAAe,EACf,cAAc,CACd,GACC,cAAc,CAChB,WAAW,EACX,aAAa,EACb,QAAQ,EACR,SAAS,EACT,MAAM,EACN,SAAS,EACT,WAAW,EACX,UAAU,EACV,cAAc,EACd,eAAe,EACf,aAAa,EACb,cAAc,EACd,aAAa,EACb,YAAY,EACZ,eAAe,EACf,cAAc,CACd,CA2pBA"}

package/dist/internal/pipeline-runner.js

@@ -1,343 +0,0 @@
-import { maybeThen as b, composeK as j } from "../async-utils.js";
-import { createDependencyGraph as x } from "../dependency-graph.js";
-import { buildExecutionSnapshot as u, assertAllHelpersExecuted as E } from "./helper-execution.js";
-import { initExtensionCoordinator as I } from "./extension-coordinator.js";
-import { isHalt as g, makeFinalizeResultStage as J, makeCommitStage as Q, makeHelperStageFactory as W, makeAfterFragmentsStage as X, makeFinalizeFragmentsStage as Y, runRollbackToHalt as Z } from "./pipeline-program-utils.js";
-const h = "after-fragments";
-function ar(o) {
-  const p = (r) => ({
-    __halt: !0,
-    error: r
-  }), k = (r) => {
-    const t = o.options.createBuildOptions(r), n = o.options.createContext(r);
-    o.diagnosticManager.setReporter(n.reporter);
-    const l = o.options.createFragmentState({
-      options: r,
-      context: n,
-      buildOptions: t
-    }), c = x(
-      o.fragmentEntries,
-      {
-        providedKeys: o.options.fragmentProvidedKeys,
-        onMissingDependency: ({ dependant: e, dependencyKey: i }) => {
-          const a = e.helper;
-          o.diagnosticManager.flagMissingDependency(
-            a,
-            i,
-            o.fragmentKind
-          ), o.diagnosticManager.flagUnusedHelper(
-            a,
-            o.fragmentKind,
-            `could not execute because dependency "${i}" was not found`,
-            a.dependsOn
-          );
-        },
-        onUnresolvedHelpers: ({ unresolved: e }) => {
-          for (const i of e) {
-            const a = i.helper;
-            o.diagnosticManager.flagUnusedHelper(
-              a,
-              o.fragmentKind,
-              "could not execute because its dependencies never resolved",
-              a.dependsOn
-            );
-          }
-        }
-      },
-      o.createError
-    ).order, s = [], m = (e) => {
-      const i = e.helper;
-      s.push({
-        id: e.id,
-        index: s.length,
-        key: i.key,
-        kind: i.kind,
-        mode: i.mode,
-        priority: i.priority,
-        dependsOn: i.dependsOn,
-        origin: i.origin
-      });
-    }, f = {
-      providedKeys: o.options.builderProvidedKeys,
-      onMissingDependency: ({ dependant: e, dependencyKey: i }) => {
-        const a = e.helper;
-        o.diagnosticManager.flagMissingDependency(
-          a,
-          i,
-          o.builderKind
-        ), o.diagnosticManager.flagUnusedHelper(
-          a,
-          o.builderKind,
-          `could not execute because dependency "${i}" was not found`,
-          a.dependsOn
-        );
-      },
-      onUnresolvedHelpers: ({ unresolved: e }) => {
-        for (const i of e) {
-          const a = i.helper;
-          o.diagnosticManager.flagUnusedHelper(
-            a,
-            o.builderKind,
-            "could not execute because its dependencies never resolved",
-            a.dependsOn
-          );
-        }
-      }
-    }, N = o.options.createExtensionHookOptions ?? ((e) => ({
-      context: e.context,
-      options: e.options,
-      artifact: e.artifact,
-      lifecycle: e.lifecycle
-    })), $ = (e, i) => N({
-      context: n,
-      options: r,
-      buildOptions: t,
-      artifact: e,
-      lifecycle: i
-    }), q = o.options.onExtensionRollbackError ?? ((e) => {
-      const { reporter: i } = e.context, a = i.warn;
-      typeof a == "function" && a.call(i, "Pipeline extension rollback failed.", {
-        error: e.error,
-        errorName: e.errorMetadata.name,
-        errorMessage: e.errorMetadata.message,
-        errorStack: e.errorMetadata.stack,
-        errorCause: e.errorMetadata.cause,
-        extensions: e.extensionKeys,
-        hookKeys: e.hookSequence
-      });
-    });
-    return {
-      runOptions: r,
-      buildOptions: t,
-      context: n,
-      draft: l,
-      fragmentOrder: c,
-      steps: s,
-      pushStep: m,
-      builderGraphOptions: f,
-      buildHookOptions: $,
-      handleRollbackError: q
-    };
-  }, R = (r, t, n) => {
-    o.diagnosticManager.reviewUnusedHelpers(
-      r.fragmentEntries,
-      t,
-      o.fragmentKind
-    );
-    const l = u(
-      r.fragmentEntries,
-      t,
-      o.fragmentKind
-    );
-    return E(
-      r.fragmentEntries,
-      l,
-      o.fragmentKind,
-      o.diagnosticManager.describeHelper,
-      o.createError
-    ), {
-      ...r,
-      fragmentVisited: t,
-      fragmentExecution: l,
-      fragmentRollbacks: n
-    };
-  }, H = (r, t, n) => {
-    o.diagnosticManager.reviewUnusedHelpers(
-      r.builderEntries,
-      t,
-      o.builderKind
-    );
-    const l = u(
-      r.builderEntries,
-      t,
-      o.builderKind
-    );
-    return E(
-      r.builderEntries,
-      l,
-      o.builderKind,
-      o.diagnosticManager.describeHelper,
-      o.createError
-    ), {
-      ...r,
-      builderVisited: t,
-      builderExecution: l,
-      builderRollbacks: n
-    };
-  }, O = (r, t) => o.options.createFragmentArgs({
-    helper: t.helper,
-    options: r.runOptions,
-    context: r.context,
-    buildOptions: r.buildOptions,
-    draft: r.draft
-  }), y = (r, t) => o.options.createBuilderArgs({
-    helper: t.helper,
-    options: r.runOptions,
-    context: r.context,
-    buildOptions: r.buildOptions,
-    artifact: r.artifact
-  }), M = (r) => (t) => O(r, t), F = (r) => (t) => y(r, t), K = (r) => r.fragmentRollbacks, S = (r) => r.builderRollbacks ?? [], d = (r) => ({
-    context: r.context,
-    extensionCoordinator: r.extensionCoordinator,
-    extensionState: r.extensionState
-  }), A = (r) => r.fragmentExecution ?? u(
-    r.fragmentEntries,
-    r.fragmentVisited,
-    o.fragmentKind
-  ), P = (r) => {
-    const { extensionCoordinator: t, extensionState: n } = r;
-    if (!(!t || !n))
-      return t.commit(n);
-  }, v = (r) => ({
-    context: r.context,
-    rollbackContext: d(r),
-    helperRollbacks: r.builderRollbacks ?? [],
-    onHelperRollbackError: o.options.onHelperRollbackError
-  }), w = (r, t) => Z(
-    {
-      rollbackPlan: v(r),
-      halt: p
-    },
-    t
-  ), B = (r) => (t) => {
-    const n = I(
-      ({ error: c, extensionKeys: s, hookSequence: m, errorMetadata: f }) => r.handleRollbackError({
-        error: c,
-        extensionKeys: s,
-        hookSequence: m,
-        errorMetadata: f,
-        context: t.context
-      })
-    ), l = n.runLifecycle(
-      h,
-      {
-        hooks: o.extensionHooks,
-        hookOptions: r.buildHookOptions(
-          t.artifact,
-          h
-        )
-      }
-    );
-    return b(
-      l,
-      (c) => ({
-        ...t,
-        artifact: c.artifact,
-        extensionCoordinator: n,
-        extensionState: c
-      })
-    );
-  }, U = (r) => r.helpers ?? {
-    fragments: r.fragmentExecution ?? u(
-      r.fragmentEntries,
-      r.fragmentVisited,
-      o.fragmentKind
-    ),
-    builders: r.builderExecution ?? u(
-      r.builderEntries,
-      r.builderVisited,
-      o.builderKind
-    )
-  }, z = (r) => ({
-    ...r,
-    helpers: U(r),
-    diagnostics: [
-      ...o.diagnosticManager.readDiagnostics()
-    ]
-  }), D = Y({
-    isHalt: g,
-    snapshotFragments: A,
-    applyArtifact: (r, t) => ({
-      ...r,
-      artifact: o.options.finalizeFragmentState({
-        draft: r.draft,
-        options: r.runOptions,
-        context: r.context,
-        buildOptions: r.buildOptions,
-        helpers: {
-          fragments: t
-        }
-      }),
-      fragmentExecution: t
-    })
-  }), T = (r) => X({
-    isHalt: g,
-    execute: B(r)
-  }), G = Q({
-    isHalt: g,
-    commit: P,
-    rollbackToHalt: w
-  }), V = J({
-    isHalt: g,
-    finalize: z
-  }), _ = {
-    getOrder: (r) => r.fragmentOrder,
-    makeArgs: M,
-    onVisited: (r, t, n) => R(r, t, n),
-    readRollbacks: K
-  }, C = {
-    getOrder: (r) => r.builderOrder,
-    makeArgs: F,
-    onVisited: (r, t, n) => H(r, t, n),
-    readRollbacks: S
-  }, L = (r) => {
-    const t = W({
-      pushStep: r.pushStep,
-      toRollbackContext: d,
-      halt: p,
-      isHalt: g,
-      onHelperRollbackError: o.options.onHelperRollbackError
-    }), n = t(_), l = t(C), c = [
-      V,
-      G,
-      l,
-      T(r),
-      D,
-      n
-    ];
-    return j(...c);
-  };
-  return {
-    prepareContext: k,
-    executeRun: (r) => {
-      const t = x(
-        o.builderEntries,
-        r.builderGraphOptions,
-        o.createError
-      ).order, n = {
-        context: r.context,
-        reporter: r.context.reporter,
-        runOptions: r.runOptions,
-        buildOptions: r.buildOptions,
-        fragmentEntries: o.fragmentEntries,
-        builderEntries: o.builderEntries,
-        fragmentOrder: r.fragmentOrder,
-        builderOrder: t,
-        fragmentVisited: /* @__PURE__ */ new Set(),
-        builderVisited: /* @__PURE__ */ new Set(),
-        draft: r.draft,
-        artifact: null,
-        steps: r.steps,
-        diagnostics: [],
-        fragmentRollbacks: [],
-        builderRollbacks: []
-      }, l = L(r), c = (s) => {
-        if (g(s))
-          throw s.error ?? new Error("Pipeline halted");
-        return o.resolveRunResult({
-          artifact: s.artifact,
-          diagnostics: s.diagnostics,
-          steps: s.steps,
-          context: s.context,
-          buildOptions: s.buildOptions,
-          options: s.runOptions,
-          helpers: s.helpers
-        });
-      };
-      return b(l(n), c);
-    }
-  };
-}
-export {
-  ar as initPipelineRunner
-};

package/dist/internal/pipeline-runner.types.d.ts

@@ -1,167 +0,0 @@
-import { CreateDependencyGraphOptions, RegisteredHelper } from '../dependency-graph';
-import { ErrorFactory } from '../error-factory';
-import { CreatePipelineOptions, Helper, HelperApplyOptions, HelperExecutionSnapshot, HelperKind, MaybePromise, PipelineDiagnostic, PipelineExecutionMetadata, PipelineExtensionHookOptions, PipelineExtensionLifecycle, PipelineExtensionRollbackErrorMetadata, PipelineReporter, PipelineStep } from '../types';
-import { PipelineRollback } from '../rollback';
-import { ExtensionCoordinator, ExtensionLifecycleState } from './extension-coordinator.types';
-import { DiagnosticManager } from './diagnostic-manager.types';
-import { ExtensionHookEntry } from '../extensions';
-/**
- * Mutable state captured while preparing a pipeline run. This mirrors the context consumed by
- * {@link executeHelpers} and downstream extension orchestration.
- *
- * @category Pipeline
- * @internal
- */
-export interface PipelineRunContext<TRunOptions, TBuildOptions, TContext, TDraft, TArtifact, TFragmentHelper, TBuilderHelper> {
-    readonly runOptions: TRunOptions;
-    readonly buildOptions: TBuildOptions;
-    readonly context: TContext;
-    readonly draft: TDraft;
-    readonly fragmentOrder: RegisteredHelper<TFragmentHelper>[];
-    readonly steps: PipelineStep[];
-    readonly pushStep: (entry: RegisteredHelper<unknown>) => void;
-    readonly builderGraphOptions: CreateDependencyGraphOptions<TBuilderHelper>;
-    readonly buildHookOptions: (artifact: TArtifact, lifecycle: PipelineExtensionLifecycle) => PipelineExtensionHookOptions<TContext, TRunOptions, TArtifact>;
-    readonly handleRollbackError: (options: {
-        readonly error: unknown;
-        readonly extensionKeys: readonly string[];
-        readonly hookSequence: readonly string[];
-        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
-        readonly context: TContext;
-    }) => void;
-}
-/**
- * Dependency bundle consumed by {@link initPipelineRunner}. Splitting the type into a dedicated
- * module improves cognitive load in the implementation file and keeps the generics re-usable for
- * test doubles.
- *
- * @category Pipeline
- * @internal
- */
-export interface PipelineRunnerDependencies<TRunOptions, TBuildOptions, TContext extends {
-    reporter: TReporter;
-}, TReporter extends PipelineReporter, TDraft, TArtifact, TDiagnostic extends PipelineDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind extends HelperKind, TBuilderKind extends HelperKind, TFragmentHelper extends Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind>, TBuilderHelper extends Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind>> {
-    readonly options: CreatePipelineOptions<TRunOptions, TBuildOptions, TContext, TReporter, TDraft, TArtifact, TDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>;
-    readonly fragmentEntries: RegisteredHelper<TFragmentHelper>[];
-    readonly builderEntries: RegisteredHelper<TBuilderHelper>[];
-    readonly fragmentKind: TFragmentKind;
-    readonly builderKind: TBuilderKind;
-    readonly diagnosticManager: DiagnosticManager<TRunOptions, TBuildOptions, TContext, TReporter, TDraft, TArtifact, TDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind, TBuilderKind, TFragmentHelper, TBuilderHelper>;
-    readonly createError: ErrorFactory;
-    readonly resolveRunResult: (state: {
-        readonly artifact: TArtifact;
-        readonly diagnostics: readonly TDiagnostic[];
-        readonly steps: readonly PipelineStep[];
-        readonly context: TContext;
-        readonly buildOptions: TBuildOptions;
-        readonly options: TRunOptions;
-        readonly helpers: PipelineExecutionMetadata<TFragmentKind, TBuilderKind>;
-    }) => TRunResult;
-    readonly extensionHooks: ExtensionHookEntry<TContext, TRunOptions, TArtifact>[];
-}
-/**
- * Public surface returned by {@link initPipelineRunner}. Downstream consumers receive a helper to
- * prepare the context (building dependency graphs, instantiating drafts) and an executor that runs
- * the prepared context through fragments, extensions, and builders.
- *
- * @category Pipeline
- * @internal
- */
-export interface PipelineRunner<TRunOptions, TBuildOptions, TContext extends {
-    reporter: TReporter;
-}, TReporter extends PipelineReporter, TDraft, TArtifact, TDiagnostic extends PipelineDiagnostic, TRunResult, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind extends HelperKind, TBuilderKind extends HelperKind, TFragmentHelper extends Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind>, TBuilderHelper extends Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind>> {
-    readonly prepareContext: (runOptions: TRunOptions) => PipelineRunContext<TRunOptions, TBuildOptions, TContext, TDraft, TArtifact, TFragmentHelper, TBuilderHelper>;
-    readonly executeRun: (context: PipelineRunContext<TRunOptions, TBuildOptions, TContext, TDraft, TArtifact, TFragmentHelper, TBuilderHelper>) => MaybePromise<TRunResult>;
-    readonly __types?: {
-        diagnostic: TDiagnostic;
-        helperArgs: HelperApplyOptions<unknown, unknown, unknown>;
-    };
-}
-/**
- * Closed-world state threaded through composed pipeline programs. While the implementation still
- * mutates some nested values (e.g. `steps`), every program returns a new state value to keep the
- * orchestrator closed under composition.
- *
- * @category Pipeline
- * @internal
- */
-export interface PipelineState<TRunOptions, TBuildOptions, TContext extends {
-    reporter: TReporter;
-}, TReporter extends PipelineReporter, TDraft, TArtifact, TDiagnostic extends PipelineDiagnostic, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind extends HelperKind, TBuilderKind extends HelperKind, TFragmentHelper extends Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind>, TBuilderHelper extends Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind>> {
-    readonly context: TContext;
-    readonly reporter: TReporter;
-    readonly runOptions: TRunOptions;
-    readonly buildOptions: TBuildOptions;
-    readonly fragmentEntries: RegisteredHelper<TFragmentHelper>[];
-    readonly builderEntries: RegisteredHelper<TBuilderHelper>[];
-    readonly fragmentOrder: RegisteredHelper<TFragmentHelper>[];
-    readonly builderOrder: RegisteredHelper<TBuilderHelper>[];
-    readonly fragmentVisited: Set<string>;
-    readonly builderVisited: Set<string>;
-    readonly draft: TDraft;
-    readonly artifact: TArtifact | null;
-    readonly steps: PipelineStep[];
-    readonly diagnostics: TDiagnostic[];
-    readonly fragmentExecution?: HelperExecutionSnapshot<TFragmentKind>;
-    readonly builderExecution?: HelperExecutionSnapshot<TBuilderKind>;
-    readonly helpers?: PipelineExecutionMetadata<TFragmentKind, TBuilderKind>;
-    readonly fragmentRollbacks?: Array<{
-        readonly helper: TFragmentHelper;
-        readonly rollback: PipelineRollback;
-    }>;
-    readonly builderRollbacks?: Array<{
-        readonly helper: TBuilderHelper;
-        readonly rollback: PipelineRollback;
-    }>;
-    readonly extensionCoordinator?: ExtensionCoordinator<TContext, TRunOptions, TArtifact>;
-    readonly extensionState?: ExtensionLifecycleState<TContext, TRunOptions, TArtifact>;
-}
-export type { ExtensionHookEntry };
-export type RollbackCapableCoordinator<TContext, TOptions, TArtifact> = {
-    createRollbackHandler: <TResult>(state: ExtensionLifecycleState<TContext, TOptions, TArtifact>) => (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, TArtifact> = {
-    readonly context: TContext;
-    readonly extensionCoordinator?: RollbackCapableCoordinator<TContext, TOptions, TArtifact>;
-    readonly extensionState?: ExtensionLifecycleState<TContext, TOptions, TArtifact>;
-};
-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 StageEnv<TState, TRunResult, TContext, TOptions, TArtifact, TReporter extends PipelineReporter> = {
-    pushStep: (entry: RegisteredHelper<unknown>) => void;
-    toRollbackContext: (state: TState) => RollbackContext<TContext, TOptions, TArtifact>;
-    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 HelperRollbackPlan<TContext, TOptions, TArtifact, THelper extends {
-    key: string;
-}> = {
-    readonly context: TContext;
-    readonly rollbackContext: RollbackContext<TContext, TOptions, TArtifact>;
-    readonly helperRollbacks: readonly RollbackEntry<THelper>[];
-    readonly onHelperRollbackError?: (options: {
-        readonly error: unknown;
-        readonly helper: THelper;
-        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
-        readonly context: TContext;
-    }) => void;
-};
-//# sourceMappingURL=pipeline-runner.types.d.ts.map