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

package/dist/core/makePipeline.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"makePipeline.d.ts","sourceRoot":"","sources":["../../src/core/makePipeline.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAKX,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAEhB,gBAAgB,EAChB,uBAAuB,EACvB,MAAM,SAAS,CAAC;AAWjB,wBAAgB,YAAY,CAC3B,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,gBAAgB,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,CA4VhE"}

package/dist/core/makePipeline.js

@@ -0,0 +1,147 @@
+import { maybeThen as l, isPromiseLike as d, maybeAll as y } from "./async-utils.js";
+import { registerHelper as C, handleExtensionRegisterResult as v } from "./registration.js";
+import { initAgnosticRunner as S } from "./runner/index.js";
+import { createAgnosticDiagnosticManager as w } from "./runner/diagnostics.js";
+function A(n) {
+  const g = n.createError ?? ((e, r) => new Error(`[${e}] ${r} `)), c = /* @__PURE__ */ new Map(), f = (e) => (c.has(e) || c.set(e, []), c.get(e));
+  for (const e of n.helperKinds)
+    f(e);
+  const R = [], o = [], a = w({
+    onDiagnostic: (e) => {
+      n.onDiagnostic ? n.onDiagnostic(e) : e.reporter.warn?.(
+        "Pipeline diagnostic reported.",
+        e.diagnostic
+      );
+    },
+    createConflictDiagnostic: n.createConflictDiagnostic,
+    createMissingDependencyDiagnostic: n.createMissingDependencyDiagnostic,
+    createUnusedHelperDiagnostic: n.createUnusedHelperDiagnostic
+  }), k = (e) => {
+    const r = [];
+    for (const t of n.helperKinds)
+      r.push(e.makeHelperStage(t));
+    return r.push(e.finalizeResult), r;
+  }, m = {
+    options: {
+      createContext: n.createContext,
+      createState: (e) => n.createState ? n.createState(e) : {},
+      createError: g,
+      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: c,
+    diagnosticManager: a,
+    resolveRunResult: (e) => {
+      const {
+        userState: r,
+        diagnostics: t,
+        steps: i,
+        context: s,
+        options: u,
+        state: M
+      } = e;
+      return n.createRunResult ? n.createRunResult({
+        artifact: r,
+        diagnostics: t,
+        steps: i,
+        context: s,
+        options: u,
+        state: M
+      }) : {
+        artifact: r,
+        diagnostics: t,
+        steps: i
+      };
+    },
+    extensionHooks: R,
+    extensionLifecycles: n.extensions?.lifecycles,
+    stages: n.createStages ?? k
+  }, x = S(m), p = (e, r) => v(e, r, R), E = (e) => {
+    if (d(e)) {
+      const r = l(
+        e,
+        () => {
+        }
+      );
+      r.catch(() => {
+      }), o.push(r);
+      const t = () => {
+        const i = o.indexOf(r);
+        i !== -1 && o.splice(i, 1);
+      };
+      r.then(t, t);
+    }
+    return e;
+  }, D = () => {
+    if (o.length !== 0)
+      return l(
+        y([...o]),
+        () => {
+        }
+      );
+  }, h = {
+    extensions: {
+      use(e) {
+        const r = e.register(h);
+        r && d(r) && Promise.resolve(r).catch(() => {
+        });
+        const t = l(
+          r,
+          (i) => p(e.key, i)
+        );
+        return E(t);
+      }
+    },
+    use(e) {
+      const r = e.kind, t = f(r);
+      C(
+        e,
+        r,
+        t,
+        r,
+        (i, s, u) => a.flagConflict(
+          i,
+          s,
+          r,
+          u
+        ),
+        g
+      );
+    },
+    run(e) {
+      const r = () => {
+        const s = x.prepareContext(e);
+        return x.executeRun(s);
+      }, t = D(), i = l(t, () => r());
+      return d(i) ? i.then(
+        (s) => (a.endRun(), s),
+        (s) => {
+          throw a.endRun(), s;
+        }
+      ) : (a.endRun(), i);
+    }
+  };
+  return h;
+}
+export {
+  A as makePipeline
+};

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

@@ -0,0 +1 @@
+{"version":3,"file":"registration.d.ts","sourceRoot":"","sources":["../../src/core/registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EACN,UAAU,EACV,qBAAqB,EAErB,0BAA0B,EAC1B,gBAAgB,EAChB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,SAAS,gBAAgB,EAClC,KAAK,SAAS,UAAU,EACxB,OAAO,SAAS,MAAM,CACrB,QAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,EACT,KAAK,CACL,GAAG,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,EAEvD,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,UAAU,EACxB,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,EACpC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACzE,WAAW,EAAE,YAAY,GACvB,IAAI,CA+CN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAClE,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAC1D,cAAc,EAAE,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,EACnE,SAAS,GAAE,0BAA8C,GACvD,MAAM,CASR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAC1E,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,MAAM,EAAE,OAAO,EACf,cAAc,EAAE,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GACjE,OAAO,CAqCT"}

package/dist/core/registration.js

@@ -0,0 +1,59 @@
+import { createHelperId as g } from "./dependency-graph.js";
+function m(e, o, i, n, r, f) {
+  if (e.kind !== o)
+    throw f(
+      "ValidationError",
+      `Attempted to register helper "${e.key}" as ${n} but received kind "${e.kind}".`
+    );
+  if (e.mode === "override") {
+    const d = i.find(
+      (t) => t.helper.key === e.key && t.helper.mode === "override"
+    );
+    if (d) {
+      const t = `Multiple overrides registered for helper "${e.key}".`;
+      throw r(e, d.helper, t), f("ValidationError", t);
+    }
+    for (let t = i.length - 1; t >= 0; t--)
+      i[t].helper.key === e.key && i.splice(t, 1);
+  }
+  const c = (i.length > 0 ? i.reduce((d, t) => Math.max(d, t.index), 0) : -1) + 1;
+  i.push({
+    helper: e,
+    id: g(e, c),
+    index: c
+  });
+}
+function a(e, o, i, n = "after-fragments") {
+  const r = e ?? `pipeline.extension#${i.length + 1}`;
+  return i.push({
+    key: r,
+    lifecycle: n,
+    hook: o
+  }), r;
+}
+function y(e, o, i) {
+  if (typeof o == "function") {
+    a(
+      e,
+      o,
+      i
+    );
+    return;
+  }
+  if (o && typeof o == "object" && "hook" in o && typeof o.hook == "function") {
+    const n = o;
+    a(
+      e,
+      n.hook,
+      i,
+      n.lifecycle
+    );
+    return;
+  }
+  return o;
+}
+export {
+  y as handleExtensionRegisterResult,
+  a as registerExtensionHook,
+  m as registerHelper
+};

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

@@ -0,0 +1 @@
+{"version":3,"file":"rollback.d.ts","sourceRoot":"","sources":["../../src/core/rollback.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IACxC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE;QACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QACxB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;QACjC,QAAQ,CAAC,QAAQ,EAAE,6BAA6B,CAAC;KACjD,KAAK,IAAI,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACrC,GAAG,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACrC,OAAO,GAAE;IACR,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACnB,GACJ,gBAAgB,CAElB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,OAAO,GACZ,6BAA6B,CAoB/B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,OAAO,EAAE,uBAAuB,GAC9B,YAAY,CAAC,IAAI,CAAC,CAyCpB"}

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

@@ -0,0 +1,13 @@
+import { AgnosticRunContext, AgnosticRunnerDependencies } from './types';
+import { PipelineReporter, PipelineDiagnostic } from '../types';
+/**
+ * Prepares the pipeline execution context.
+ *
+ * @param dependencies
+ * @param runOptions
+ * @internal
+ */
+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>;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/runner/context.js

@@ -0,0 +1,86 @@
+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);
+  const s = /* @__PURE__ */ new Map();
+  for (const [r, i] of e.helperRegistries) {
+    const f = M(
+      i,
+      {
+        onMissingDependency: (t) => {
+          e.diagnosticManager.flagMissingDependency(
+            t.dependant.helper,
+            t.dependencyKey,
+            r
+          ), e.diagnosticManager.flagUnusedHelper(
+            t.dependant.helper,
+            r,
+            "has missing dependencies",
+            t.dependant.helper.dependsOn ?? []
+          );
+        },
+        onUnresolvedHelpers: ({ unresolved: t }) => {
+          for (const l of t)
+            e.diagnosticManager.flagUnusedHelper(
+              l.helper,
+              r,
+              "has unresolved dependencies (possible cycle)",
+              l.helper.dependsOn ?? []
+            );
+        },
+        providedKeys: e.options.providedKeys?.[r]
+      },
+      e.options.createError
+    );
+    s.set(r, f.order);
+  }
+  const c = e.options.createState({
+    context: o,
+    options: n
+  }), a = [], g = (r) => a.push(r), p = (r) => {
+    e.options.onExtensionRollbackError && e.options.onExtensionRollbackError(r);
+  }, h = (r, i) => ({
+    context: o,
+    options: n,
+    artifact: r.userState,
+    // Extension expects UserState
+    lifecycle: i
+  }), d = {
+    context: o,
+    reporter: o.reporter,
+    runOptions: n,
+    userState: c,
+    steps: a,
+    diagnostics: e.diagnosticManager.getDiagnostics(),
+    // Live reference
+    // AgnosticState definition has diagnostics: TDiagnostic[]. Programs read it from here.
+    // finalizeResultStage updates it from manager.
+    helperRegistries: e.helperRegistries,
+    helperOrders: s,
+    executedLifecycles: /* @__PURE__ */ new Set(),
+    // Runtime maps
+    helperExecution: /* @__PURE__ */ new Map(),
+    helperRollbacks: /* @__PURE__ */ new Map(),
+    extensionCoordinator: R(
+      (r) => p({
+        ...r,
+        context: o
+      })
+    )
+  };
+  return {
+    runOptions: n,
+    context: o,
+    state: d,
+    steps: a,
+    pushStep: g,
+    helperRegistries: e.helperRegistries,
+    helperOrders: s,
+    buildHookOptions: h,
+    handleRollbackError: p
+  };
+};
+export {
+  E as prepareContext
+};

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

@@ -0,0 +1,48 @@
+import { HelperDescriptor, PipelineDiagnostic, PipelineReporter } from '../types';
+/**
+ * Agnostic configuration for the diagnostic manager.
+ */
+export interface DiagnosticManagerOptions<TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic> {
+    /**
+     * Callback for observing diagnostics as they are added.
+     */
+    readonly onDiagnostic?: (options: {
+        readonly reporter: TReporter;
+        readonly diagnostic: TDiagnostic;
+    }) => void;
+    readonly createConflictDiagnostic?: (options: {
+        readonly helper: HelperDescriptor;
+        readonly existing: HelperDescriptor;
+        readonly message: string;
+    }) => TDiagnostic;
+    readonly createMissingDependencyDiagnostic?: (options: {
+        readonly helper: HelperDescriptor;
+        readonly dependency: string;
+        readonly message: string;
+    }) => TDiagnostic;
+    readonly createUnusedHelperDiagnostic?: (options: {
+        readonly helper: HelperDescriptor;
+        readonly message: string;
+    }) => TDiagnostic;
+}
+/**
+ * Generic diagnostic manager that tracks conflicts, missing dependencies, and other issues
+ * without knowledge of specific helper kinds (fragments/builders).
+ */
+export interface AgnosticDiagnosticManager<TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic> {
+    record: (diagnostic: TDiagnostic) => void;
+    setReporter: (reporter: TReporter) => void;
+    readDiagnostics: () => readonly TDiagnostic[];
+    getDiagnostics: () => readonly TDiagnostic[];
+    flagConflict: (helper: HelperDescriptor, existing: HelperDescriptor, kind: string, message: string) => void;
+    flagMissingDependency: (helper: HelperDescriptor, dependency: string, kind: string) => void;
+    flagUnusedHelper: (helper: HelperDescriptor, kind: string, reason: string, dependsOn: readonly string[]) => void;
+    prepareRun: () => void;
+    endRun: () => void;
+}
+/**
+ * Creates a truly agnostic diagnostic manager.
+ * @param options
+ */
+export declare function createAgnosticDiagnosticManager<TReporter extends PipelineReporter, TDiagnostic extends PipelineDiagnostic>(options?: DiagnosticManagerOptions<TReporter, TDiagnostic>): AgnosticDiagnosticManager<TReporter, TDiagnostic>;
+//# sourceMappingURL=diagnostics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/core/runner/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,MAAM,UAAU,CAAC;AAElB;;GAEG;AACH,MAAM,WAAW,wBAAwB,CACxC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB;IAEtC;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE;QACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;QAC7B,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;KACjC,KAAK,IAAI,CAAC;IAEX,QAAQ,CAAC,wBAAwB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC7C,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;QAClC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;QACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KACzB,KAAK,WAAW,CAAC;IAClB,QAAQ,CAAC,iCAAiC,CAAC,EAAE,CAAC,OAAO,EAAE;QACtD,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;QAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KACzB,KAAK,WAAW,CAAC;IAClB,QAAQ,CAAC,4BAA4B,CAAC,EAAE,CAAC,OAAO,EAAE;QACjD,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;QAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KACzB,KAAK,WAAW,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB,CACzC,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB;IAEtC,MAAM,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1C,WAAW,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC;IAC3C,eAAe,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IAC9C,cAAc,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IAG7C,YAAY,EAAE,CACb,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,KACX,IAAI,CAAC;IACV,qBAAqB,EAAE,CACtB,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,KACR,IAAI,CAAC;IACV,gBAAgB,EAAE,CACjB,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,MAAM,EAAE,KACxB,IAAI,CAAC;IAEV,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC9C,SAAS,SAAS,gBAAgB,EAClC,WAAW,SAAS,kBAAkB,EAEtC,OAAO,GAAE,wBAAwB,CAAC,SAAS,EAAE,WAAW,CAAM,GAC5D,yBAAyB,CAAC,SAAS,EAAE,WAAW,CAAC,CAwInD"}

package/dist/core/runner/diagnostics.js

@@ -0,0 +1,82 @@
+function l(s = {}) {
+  const d = [], i = [];
+  let u = !1;
+  const y = /* @__PURE__ */ new WeakMap();
+  let o;
+  const f = (e) => {
+    if (!o || !s.onDiagnostic)
+      return;
+    let n = y.get(o);
+    n || (n = /* @__PURE__ */ new Set(), y.set(o, n)), !n.has(e) && (s.onDiagnostic({
+      reporter: o,
+      diagnostic: e
+    }), n.add(e));
+  }, a = (e) => {
+    u ? i.push(e) : d.push(e), f(e);
+  }, D = (e, n) => `${e} helper "${n.key}"`;
+  return {
+    record: a,
+    setReporter(e) {
+      o = e, [...d, ...i].forEach(f);
+    },
+    readDiagnostics: () => [...d, ...i],
+    getDiagnostics: () => i,
+    prepareRun() {
+      u = !0, i.length = 0;
+    },
+    endRun() {
+      u = !1;
+    },
+    flagConflict(e, n, t, c) {
+      const r = s.createConflictDiagnostic?.({
+        helper: e,
+        existing: n,
+        message: c
+      }) ?? {
+        type: "conflict",
+        key: e.key,
+        mode: e.mode,
+        helpers: [
+          n.origin ?? n.key,
+          e.origin ?? e.key
+        ],
+        message: c,
+        kind: t
+      };
+      a(r);
+    },
+    flagMissingDependency(e, n, t) {
+      const r = `${D(t, e)} depends on unknown helper "${n}".`, g = s.createMissingDependencyDiagnostic?.({
+        helper: e,
+        dependency: n,
+        message: r
+      }) ?? {
+        type: "missing-dependency",
+        key: e.key,
+        dependency: n,
+        message: r,
+        kind: t,
+        helper: e.origin ?? e.key,
+        dependsOn: e.dependsOn
+      };
+      a(g);
+    },
+    flagUnusedHelper(e, n, t, c) {
+      const g = `${D(n, e)} ${t}.`, p = s.createUnusedHelperDiagnostic?.({
+        helper: e,
+        message: g
+      }) ?? {
+        type: "unused-helper",
+        key: e.key,
+        message: g,
+        kind: n,
+        helper: e.origin ?? e.key,
+        dependsOn: c
+      };
+      a(p);
+    }
+  };
+}
+export {
+  l as createAgnosticDiagnosticManager
+};

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

@@ -0,0 +1,6 @@
+import { AgnosticRunContext, AgnosticRunnerDependencies } from './types';
+import { PipelineReporter, PipelineDiagnostic, MaybePromise } 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>;
+//# sourceMappingURL=execution.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/runner/execution.js

@@ -0,0 +1,66 @@
+import { maybeThen as i } from "../async-utils.js";
+import { createAgnosticProgram as f } from "./program.js";
+const s = (o) => ({
+  kind: o,
+  registered: [],
+  executed: [],
+  missing: []
+}), h = (o, e) => {
+  const {
+    runOptions: m,
+    context: c
+  } = e, n = e.state;
+  if (!o.stages)
+    return o.resolveRunResult({
+      diagnostics: [],
+      steps: [],
+      context: c,
+      userState: n.userState,
+      options: m,
+      helpers: {
+        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 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
+        })
+      );
+    }
+  );
+};
+export {
+  h as executeRun
+};

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

@@ -0,0 +1,14 @@
+import { AgnosticRunner, AgnosticRunnerDependencies } from './types';
+import { PipelineReporter, PipelineDiagnostic } from '../types';
+/**
+ * Initializes an agnostic pipeline runner.
+ *
+ * @param dependencies - The dependencies required by the runner.
+ * @returns An `AgnosticRunner` instance.
+ *
+ * @internal
+ */
+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>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/core/runner/index.js

@@ -0,0 +1,9 @@
+import { executeRun as e } from "./execution.js";
+import { prepareContext as o } from "./context.js";
+const u = (r) => ({
+  prepareContext: (t) => o(r, t),
+  executeRun: (t) => e(r, t)
+});
+export {
+  u as initAgnosticRunner
+};

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

@@ -0,0 +1,7 @@
+import { Program } from '../async-utils';
+import { AgnosticRunnerDependencies, AgnosticRunContext, AgnosticState, Halt } from './types';
+import { PipelineReporter, PipelineDiagnostic } from '../types';
+export declare const createAgnosticProgram: <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>) => Program<AgnosticState<TRunOptions, TUserState, TContext, TReporter, TDiagnostic> | Halt<TRunResult>>;
+//# sourceMappingURL=program.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../../src/core/runner/program.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,KAAK,EACX,0BAA0B,EAC1B,kBAAkB,EAElB,aAAa,EACb,IAAI,EAGJ,MAAM,SAAS,CAAC;AASjB,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAIlB,MAAM,UAAU,CAAC;AAElB,eAAO,MAAM,qBAAqB,GACjC,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,OAAO,CACP,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAC,GACxE,IAAI,CAAC,UAAU,CAAC,CA6SlB,CAAC"}