inngest 2.7.1 → 3.0.0

package/components/execution/v1.js

@@ -0,0 +1,673 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var _V1InngestExecution_instances, _V1InngestExecution_state, _V1InngestExecution_fnArg, _V1InngestExecution_checkpointHandlers, _V1InngestExecution_timeoutDuration, _V1InngestExecution_execution, _V1InngestExecution_userFnToRun, _V1InngestExecution_timeout, _V1InngestExecution_start, _V1InngestExecution_createCheckpointHandlers, _V1InngestExecution_getCheckpointHandler, _V1InngestExecution_tryExecuteStep, _V1InngestExecution_getEarlyExecRunStep, _V1InngestExecution_filterNewSteps, _V1InngestExecution_executeStep, _V1InngestExecution_startExecution, _V1InngestExecution_transformInput, _V1InngestExecution_transformOutput, _V1InngestExecution_createExecutionState, _V1InngestExecution_createFnArg, _V1InngestExecution_createStepTools, _V1InngestExecution_getUserFnToRun, _V1InngestExecution_initializeTimer, _V1InngestExecution_initializeMiddleware;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._internals = exports.createV1InngestExecution = void 0;
+const hash_js_1 = require("hash.js");
+const zod_1 = require("zod");
+const consts_1 = require("../../helpers/consts");
+const errors_1 = require("../../helpers/errors");
+const functions_1 = require("../../helpers/functions");
+const promises_1 = require("../../helpers/promises");
+const types_1 = require("../../types");
+const InngestMiddleware_1 = require("../InngestMiddleware");
+const InngestStepTools_1 = require("../InngestStepTools");
+const NonRetriableError_1 = require("../NonRetriableError");
+const RetryAfterError_1 = require("../RetryAfterError");
+const InngestExecution_1 = require("./InngestExecution");
+const createV1InngestExecution = (options) => {
+    return new V1InngestExecution(options);
+};
+exports.createV1InngestExecution = createV1InngestExecution;
+class V1InngestExecution extends InngestExecution_1.InngestExecution {
+    constructor(options) {
+        super(options);
+        _V1InngestExecution_instances.add(this);
+        _V1InngestExecution_state.set(this, void 0);
+        _V1InngestExecution_fnArg.set(this, void 0);
+        _V1InngestExecution_checkpointHandlers.set(this, void 0);
+        _V1InngestExecution_timeoutDuration.set(this, 1000 * 10);
+        _V1InngestExecution_execution.set(this, void 0);
+        _V1InngestExecution_userFnToRun.set(this, void 0);
+        /**
+         * If we're supposed to run a particular step via `requestedRunStep`, this
+         * will be a `Promise` that resolves after no steps have been found for
+         * `timeoutDuration` milliseconds.
+         *
+         * If we're not supposed to run a particular step, this will be `undefined`.
+         */
+        _V1InngestExecution_timeout.set(this, void 0);
+        __classPrivateFieldSet(this, _V1InngestExecution_userFnToRun, __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_getUserFnToRun).call(this), "f");
+        __classPrivateFieldSet(this, _V1InngestExecution_state, __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_createExecutionState).call(this), "f");
+        __classPrivateFieldSet(this, _V1InngestExecution_fnArg, __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_createFnArg).call(this), "f");
+        __classPrivateFieldSet(this, _V1InngestExecution_checkpointHandlers, __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_createCheckpointHandlers).call(this), "f");
+        __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_initializeTimer).call(this, __classPrivateFieldGet(this, _V1InngestExecution_state, "f"));
+        this.debug("created new V1 execution for run;", this.options.requestedRunStep
+            ? `wanting to run step "${this.options.requestedRunStep}"`
+            : "discovering steps");
+        this.debug("existing state keys:", Object.keys(__classPrivateFieldGet(this, _V1InngestExecution_state, "f").stepState));
+    }
+    /**
+     * Idempotently start the execution of the user's function.
+     */
+    start() {
+        var _a;
+        this.debug("starting V1 execution");
+        return (__classPrivateFieldSet(this, _V1InngestExecution_execution, (_a = __classPrivateFieldGet(this, _V1InngestExecution_execution, "f")) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_start).call(this).then((result) => {
+            this.debug("result:", result);
+            return result;
+        }), "f"));
+    }
+}
+_V1InngestExecution_state = new WeakMap(), _V1InngestExecution_fnArg = new WeakMap(), _V1InngestExecution_checkpointHandlers = new WeakMap(), _V1InngestExecution_timeoutDuration = new WeakMap(), _V1InngestExecution_execution = new WeakMap(), _V1InngestExecution_userFnToRun = new WeakMap(), _V1InngestExecution_timeout = new WeakMap(), _V1InngestExecution_instances = new WeakSet(), _V1InngestExecution_start = 
+/**
+ * Starts execution of the user's function and the core loop.
+ */
+async function _V1InngestExecution_start() {
+    var _a, e_1, _b, _c;
+    var _d, _e;
+    try {
+        const allCheckpointHandler = __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_getCheckpointHandler).call(this, "");
+        __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks = await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_initializeMiddleware).call(this);
+        await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_startExecution).call(this);
+        try {
+            for (var _f = true, _g = __asyncValues(__classPrivateFieldGet(this, _V1InngestExecution_state, "f").loop), _h; _h = await _g.next(), _a = _h.done, !_a; _f = true) {
+                _c = _h.value;
+                _f = false;
+                const checkpoint = _c;
+                await allCheckpointHandler(checkpoint);
+                const handler = __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_getCheckpointHandler).call(this, checkpoint.type);
+                const result = await handler(checkpoint);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_f && !_a && (_b = _g.return)) await _b.call(_g);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    catch (error) {
+        return await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_transformOutput).call(this, { error });
+    }
+    finally {
+        void __classPrivateFieldGet(this, _V1InngestExecution_state, "f").loop.return();
+        await ((_e = (_d = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _d === void 0 ? void 0 : _d.beforeResponse) === null || _e === void 0 ? void 0 : _e.call(_d));
+    }
+    /**
+     * If we're here, the generator somehow finished without returning a value.
+     * This should never happen.
+     */
+    throw new Error("Core loop finished without returning a value");
+}, _V1InngestExecution_createCheckpointHandlers = function _V1InngestExecution_createCheckpointHandlers() {
+    return {
+        /**
+         * Run for all checkpoints. Best used for logging or common actions.
+         * Use other handlers to return values and interrupt the core loop.
+         */
+        "": (checkpoint) => {
+            this.debug("checkpoint:", checkpoint);
+        },
+        /**
+         * The user's function has completed and returned a value.
+         */
+        "function-resolved": async (checkpoint) => {
+            return await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_transformOutput).call(this, { data: checkpoint.data });
+        },
+        /**
+         * The user's function has thrown an error.
+         */
+        "function-rejected": async (checkpoint) => {
+            return await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_transformOutput).call(this, { error: checkpoint.error });
+        },
+        /**
+         * We've found one or more steps. Here we may want to run a step or report
+         * them back to Inngest.
+         */
+        "steps-found": async ({ steps }) => {
+            const stepResult = await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_tryExecuteStep).call(this, steps);
+            if (stepResult) {
+                const transformResult = await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_transformOutput).call(this, stepResult);
+                /**
+                 * Transforming output will always return either function rejection or
+                 * resolution. In most cases, this can be immediately returned, but in
+                 * this particular case we want to handle it differently.
+                 */
+                if (transformResult.type === "function-resolved") {
+                    return {
+                        type: "step-ran",
+                        step: exports._internals.hashOp(Object.assign(Object.assign({}, stepResult), { data: { data: transformResult.data } })),
+                    };
+                }
+                return transformResult;
+            }
+            const newSteps = await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_filterNewSteps).call(this, Object.values(__classPrivateFieldGet(this, _V1InngestExecution_state, "f").steps));
+            if (newSteps) {
+                return {
+                    type: "steps-found",
+                    steps: newSteps,
+                };
+            }
+        },
+        /**
+         * While trying to find a step that Inngest has told us to run, we've
+         * timed out or have otherwise decided that it doesn't exist.
+         */
+        "step-not-found": ({ step }) => {
+            return { type: "step-not-found", step };
+        },
+    };
+}, _V1InngestExecution_getCheckpointHandler = function _V1InngestExecution_getCheckpointHandler(type) {
+    return __classPrivateFieldGet(this, _V1InngestExecution_checkpointHandlers, "f")[type];
+}, _V1InngestExecution_tryExecuteStep = async function _V1InngestExecution_tryExecuteStep(steps) {
+    var _a;
+    const hashedStepIdToRun = this.options.requestedRunStep || __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_getEarlyExecRunStep).call(this, steps);
+    if (!hashedStepIdToRun) {
+        return;
+    }
+    const step = steps.find((step) => step.hashedId === hashedStepIdToRun && step.fn);
+    if (step) {
+        return await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_executeStep).call(this, step);
+    }
+    /**
+     * Ensure we reset the timeout if we have a requested run step but couldn't
+     * find it, but also that we don't reset if we found and executed it.
+     */
+    void ((_a = __classPrivateFieldGet(this, _V1InngestExecution_timeout, "f")) === null || _a === void 0 ? void 0 : _a.reset());
+}, _V1InngestExecution_getEarlyExecRunStep = function _V1InngestExecution_getEarlyExecRunStep(steps) {
+    /**
+     * We may have been disabled due to parallelism, in which case we can't
+     * immediately execute unless explicitly requested.
+     */
+    if (this.options.disableImmediateExecution)
+        return;
+    const unfulfilledSteps = steps.filter((step) => !step.fulfilled);
+    if (unfulfilledSteps.length !== 1)
+        return;
+    const op = unfulfilledSteps[0];
+    if (op &&
+        op.op === types_1.StepOpCode.StepPlanned &&
+        typeof op.opts === "undefined") {
+        return op.hashedId;
+    }
+}, _V1InngestExecution_filterNewSteps = async function _V1InngestExecution_filterNewSteps(steps) {
+    var _a, _b, _c, _d, _e, _f;
+    if (this.options.requestedRunStep) {
+        return;
+    }
+    /**
+     * Gather any steps that aren't memoized and report them.
+     */
+    const newSteps = steps.filter((step) => !step.fulfilled);
+    if (!newSteps.length) {
+        return;
+    }
+    /**
+     * Warn if we've found new steps but haven't yet seen all previous
+     * steps. This may indicate that step presence isn't determinate.
+     */
+    const stepsToFulfil = Object.keys(__classPrivateFieldGet(this, _V1InngestExecution_state, "f").stepState).length;
+    const fulfilledSteps = steps.filter((step) => step.fulfilled).length;
+    const foundAllCompletedSteps = stepsToFulfil === fulfilledSteps;
+    if (!foundAllCompletedSteps) {
+        // TODO Tag
+        console.warn((0, errors_1.prettyError)({
+            type: "warn",
+            whatHappened: "Function may be indeterminate",
+            why: "We found new steps before seeing all previous steps, which may indicate that the function is non-deterministic.",
+            consequences: "This may cause unexpected behaviour as Inngest executes your function.",
+            reassurance: "This is expected if a function is updated in the middle of a run, but may indicate a bug if not.",
+        }));
+    }
+    /**
+     * We're finishing up; let's trigger the last of the hooks.
+     */
+    await ((_b = (_a = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _a === void 0 ? void 0 : _a.afterMemoization) === null || _b === void 0 ? void 0 : _b.call(_a));
+    await ((_d = (_c = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _c === void 0 ? void 0 : _c.beforeExecution) === null || _d === void 0 ? void 0 : _d.call(_c));
+    await ((_f = (_e = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _e === void 0 ? void 0 : _e.afterExecution) === null || _f === void 0 ? void 0 : _f.call(_e));
+    return newSteps.map((step) => ({
+        op: step.op,
+        id: step.hashedId,
+        name: step.name,
+        opts: step.opts,
+    }));
+}, _V1InngestExecution_executeStep = async function _V1InngestExecution_executeStep({ id, name, opts, fn }) {
+    var _a, _b, _c, _d, _e;
+    (_a = __classPrivateFieldGet(this, _V1InngestExecution_timeout, "f")) === null || _a === void 0 ? void 0 : _a.clear();
+    await ((_c = (_b = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _b === void 0 ? void 0 : _b.afterMemoization) === null || _c === void 0 ? void 0 : _c.call(_b));
+    await ((_e = (_d = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _d === void 0 ? void 0 : _d.beforeExecution) === null || _e === void 0 ? void 0 : _e.call(_d));
+    const outgoingOp = { id, op: types_1.StepOpCode.RunStep, name, opts };
+    __classPrivateFieldGet(this, _V1InngestExecution_state, "f").executingStep = outgoingOp;
+    this.debug(`executing step "${id}"`);
+    return ((0, promises_1.runAsPromise)(fn)
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        .finally(async () => {
+        var _a, _b;
+        await ((_b = (_a = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _a === void 0 ? void 0 : _a.afterExecution) === null || _b === void 0 ? void 0 : _b.call(_a));
+    })
+        .then((data) => {
+        return Object.assign(Object.assign({}, outgoingOp), { data });
+    })
+        .catch((error) => {
+        return Object.assign(Object.assign({}, outgoingOp), { 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            error });
+    }));
+}, _V1InngestExecution_startExecution = 
+/**
+ * Starts execution of the user's function, including triggering checkpoints
+ * and middleware hooks where appropriate.
+ */
+async function _V1InngestExecution_startExecution() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    /**
+     * Mutate input as neccessary based on middleware.
+     */
+    await __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_transformInput).call(this);
+    /**
+     * Start the timer to time out the run if needed.
+     */
+    void ((_a = __classPrivateFieldGet(this, _V1InngestExecution_timeout, "f")) === null || _a === void 0 ? void 0 : _a.start());
+    await ((_c = (_b = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _b === void 0 ? void 0 : _b.beforeMemoization) === null || _c === void 0 ? void 0 : _c.call(_b));
+    /**
+     * If we had no state to begin with, immediately end the memoization phase.
+     */
+    if (__classPrivateFieldGet(this, _V1InngestExecution_state, "f").allStateUsed()) {
+        await ((_e = (_d = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _d === void 0 ? void 0 : _d.afterMemoization) === null || _e === void 0 ? void 0 : _e.call(_d));
+        await ((_g = (_f = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _f === void 0 ? void 0 : _f.beforeExecution) === null || _g === void 0 ? void 0 : _g.call(_f));
+    }
+    /**
+     * Trigger the user's function.
+     */
+    (0, promises_1.runAsPromise)(() => __classPrivateFieldGet(this, _V1InngestExecution_userFnToRun, "f").call(this, __classPrivateFieldGet(this, _V1InngestExecution_fnArg, "f")))
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        .finally(async () => {
+        var _a, _b, _c, _d, _e, _f;
+        await ((_b = (_a = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _a === void 0 ? void 0 : _a.afterMemoization) === null || _b === void 0 ? void 0 : _b.call(_a));
+        await ((_d = (_c = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _c === void 0 ? void 0 : _c.beforeExecution) === null || _d === void 0 ? void 0 : _d.call(_c));
+        await ((_f = (_e = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _e === void 0 ? void 0 : _e.afterExecution) === null || _f === void 0 ? void 0 : _f.call(_e));
+    })
+        .then((data) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        __classPrivateFieldGet(this, _V1InngestExecution_state, "f").setCheckpoint({ type: "function-resolved", data });
+    })
+        .catch((error) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        __classPrivateFieldGet(this, _V1InngestExecution_state, "f").setCheckpoint({ type: "function-rejected", error });
+    });
+}, _V1InngestExecution_transformInput = 
+/**
+ * Using middleware, transform input before running.
+ */
+async function _V1InngestExecution_transformInput() {
+    var _a, _b;
+    const inputMutations = await ((_b = (_a = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _a === void 0 ? void 0 : _a.transformInput) === null || _b === void 0 ? void 0 : _b.call(_a, {
+        ctx: Object.assign({}, __classPrivateFieldGet(this, _V1InngestExecution_fnArg, "f")),
+        steps: Object.values(__classPrivateFieldGet(this, _V1InngestExecution_state, "f").stepState),
+        fn: this.options.fn,
+    }));
+    if (inputMutations === null || inputMutations === void 0 ? void 0 : inputMutations.ctx) {
+        __classPrivateFieldSet(this, _V1InngestExecution_fnArg, inputMutations.ctx, "f");
+    }
+    if (inputMutations === null || inputMutations === void 0 ? void 0 : inputMutations.steps) {
+        __classPrivateFieldGet(this, _V1InngestExecution_state, "f").stepState = inputMutations.steps.reduce((steps, step) => (Object.assign(Object.assign({}, steps), { [step.id]: step })), {});
+    }
+}, _V1InngestExecution_transformOutput = 
+/**
+ * Using middleware, transform output before returning.
+ */
+async function _V1InngestExecution_transformOutput(dataOrError) {
+    var _a, _b;
+    const output = Object.assign({}, dataOrError);
+    if (typeof output.error !== "undefined") {
+        output.data = (0, errors_1.serializeError)(output.error);
+    }
+    const transformedOutput = await ((_b = (_a = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _a === void 0 ? void 0 : _a.transformOutput) === null || _b === void 0 ? void 0 : _b.call(_a, {
+        result: Object.assign({}, output),
+        step: __classPrivateFieldGet(this, _V1InngestExecution_state, "f").executingStep,
+    }));
+    const { data, error } = Object.assign(Object.assign({}, output), transformedOutput === null || transformedOutput === void 0 ? void 0 : transformedOutput.result);
+    if (typeof error !== "undefined") {
+        /**
+         * Ensure we give middleware the chance to decide on retriable behaviour
+         * by looking at the error returned from output transformation.
+         */
+        let retriable = !(error instanceof NonRetriableError_1.NonRetriableError);
+        if (retriable && error instanceof RetryAfterError_1.RetryAfterError) {
+            retriable = error.retryAfter;
+        }
+        const serializedError = (0, errors_1.serializeError)(error);
+        return { type: "function-rejected", error: serializedError, retriable };
+    }
+    return { type: "function-resolved", data: (0, functions_1.undefinedToNull)(data) };
+}, _V1InngestExecution_createExecutionState = function _V1InngestExecution_createExecutionState() {
+    let { promise: checkpointPromise, resolve: checkpointResolve } = (0, promises_1.createDeferredPromise)();
+    const loop = (function (cleanUp) {
+        return __asyncGenerator(this, arguments, function* () {
+            try {
+                while (true) {
+                    yield yield __await(yield __await(checkpointPromise));
+                }
+            }
+            finally {
+                cleanUp === null || cleanUp === void 0 ? void 0 : cleanUp();
+            }
+        });
+    })(() => {
+        var _a;
+        (_a = __classPrivateFieldGet(this, _V1InngestExecution_timeout, "f")) === null || _a === void 0 ? void 0 : _a.clear();
+    });
+    const state = {
+        stepState: this.options.stepState,
+        steps: {},
+        loop,
+        hasSteps: Boolean(Object.keys(this.options.stepState).length),
+        stepCompletionOrder: this.options.stepCompletionOrder,
+        setCheckpoint: (checkpoint) => {
+            ({ promise: checkpointPromise, resolve: checkpointResolve } =
+                checkpointResolve(checkpoint));
+        },
+        allStateUsed: () => {
+            return Object.values(state.stepState).every((step) => {
+                return step.seen;
+            });
+        },
+    };
+    return state;
+}, _V1InngestExecution_createFnArg = function _V1InngestExecution_createFnArg() {
+    var _a;
+    const step = __classPrivateFieldGet(this, _V1InngestExecution_instances, "m", _V1InngestExecution_createStepTools).call(this);
+    let fnArg = Object.assign(Object.assign({}, this.options.data), { step });
+    /**
+     * Handle use of the `onFailure` option by deserializing the error.
+     */
+    if (this.options.isFailureHandler) {
+        const eventData = zod_1.z
+            .object({ error: types_1.failureEventErrorSchema })
+            .parse((_a = fnArg.event) === null || _a === void 0 ? void 0 : _a.data);
+        fnArg = Object.assign(Object.assign({}, fnArg), { error: (0, errors_1.deserializeError)(eventData.error) });
+    }
+    return fnArg;
+}, _V1InngestExecution_createStepTools = function _V1InngestExecution_createStepTools() {
+    /**
+     * A list of steps that have been found and are being rolled up before being
+     * reported to the core loop.
+     */
+    let foundStepsToReport = [];
+    /**
+     * A promise that's used to ensure that step reporting cannot be run more than
+     * once in a given asynchronous time span.
+     */
+    let foundStepsReportPromise;
+    /**
+     * A promise that's used to represent middleware hooks running before
+     * execution.
+     */
+    let beforeExecHooksPromise;
+    /**
+     * A flag used to ensure that we only warn about parallel indexing once per
+     * execution to avoid spamming the console.
+     */
+    let warnOfParallelIndexing = false;
+    /**
+     * Given a colliding step ID, maybe warn the user about parallel indexing.
+     */
+    const maybeWarnOfParallelIndexing = (collisionId) => {
+        if (warnOfParallelIndexing) {
+            return;
+        }
+        const stepExists = Boolean(__classPrivateFieldGet(this, _V1InngestExecution_state, "f").steps[collisionId]);
+        const stepFoundThisTick = foundStepsToReport.some((step) => {
+            return step.id === collisionId;
+        });
+        if (stepExists && !stepFoundThisTick) {
+            warnOfParallelIndexing = true;
+            console.warn((0, errors_1.prettyError)({
+                type: "warn",
+                whatHappened: "We detected that you have multiple steps with the same ID.",
+                code: errors_1.ErrCode.AUTOMATIC_PARALLEL_INDEXING,
+                why: `This can happen if you're using the same ID for multiple steps across different chains of parallel work. We found the issue with step "${collisionId}".`,
+                reassurance: "Your function is still running, though it may exhibit unexpected behaviour.",
+                consequences: "Using the same IDs across parallel chains of work can cause unexpected behaviour.",
+                toFixNow: "We recommend using a unique ID for each step, especially those happening in parallel.",
+            }));
+        }
+    };
+    /**
+     * A helper used to report steps to the core loop. Used after adding an item
+     * to `foundStepsToReport`.
+     */
+    const reportNextTick = () => {
+        // Being explicit instead of using `??=` to appease TypeScript.
+        if (foundStepsReportPromise) {
+            return;
+        }
+        foundStepsReportPromise = (0, promises_1.resolveAfterPending)()
+            /**
+             * Ensure that we wait for this promise to resolve before continuing.
+             *
+             * The groups in which steps are reported can affect how we detect some
+             * more complex determinism issues like parallel indexing. This promise
+             * can represent middleware hooks being run early, in the middle of
+             * ingesting steps to report.
+             *
+             * Because of this, it's important we wait for this middleware to resolve
+             * before continuing to report steps to ensure that all steps have a
+             * chance to be reported throughout this asynchronous action.
+             */
+            .then(() => beforeExecHooksPromise)
+            .then(() => {
+            var _a;
+            foundStepsReportPromise = undefined;
+            for (let i = 0; i < __classPrivateFieldGet(this, _V1InngestExecution_state, "f").stepCompletionOrder.length; i++) {
+                const handled = (_a = foundStepsToReport
+                    .find((step) => {
+                    return step.hashedId === __classPrivateFieldGet(this, _V1InngestExecution_state, "f").stepCompletionOrder[i];
+                })) === null || _a === void 0 ? void 0 : _a.handle();
+                if (handled) {
+                    return void reportNextTick();
+                }
+            }
+            // If we've handled no steps in this "tick," roll up everything we've
+            // found and report it.
+            const steps = [...foundStepsToReport];
+            foundStepsToReport = [];
+            return void __classPrivateFieldGet(this, _V1InngestExecution_state, "f").setCheckpoint({
+                type: "steps-found",
+                steps: steps,
+            });
+        });
+    };
+    /**
+     * A helper used to push a step to the list of steps to report.
+     */
+    const pushStepToReport = (step) => {
+        foundStepsToReport.push(step);
+        reportNextTick();
+    };
+    const stepHandler = async ({ args, matchOp, opts, }) => {
+        var _a;
+        await beforeExecHooksPromise;
+        if (!__classPrivateFieldGet(this, _V1InngestExecution_state, "f").hasSteps && (opts === null || opts === void 0 ? void 0 : opts.nonStepExecuteInline) && opts.fn) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return (0, promises_1.runAsPromise)(() => { var _a; return (_a = opts.fn) === null || _a === void 0 ? void 0 : _a.call(opts, ...args); });
+        }
+        if (__classPrivateFieldGet(this, _V1InngestExecution_state, "f").executingStep) {
+            /**
+             * If a step is found after asynchronous actions during another step's
+             * execution, everything is fine. The problem here is if we've found
+             * that a step nested inside another a step, which is something we don't
+             * support at the time of writing.
+             *
+             * In this case, we could use something like Async Hooks to understand
+             * how the step is being triggered, though this isn't available in all
+             * environments.
+             *
+             * Therefore, we'll only show a warning here to indicate that this is
+             * potentially an issue.
+             */
+            console.warn((0, errors_1.prettyError)({
+                whatHappened: "We detected that you have nested `step.*` tooling.",
+                consequences: "Nesting `step.*` tooling is not supported.",
+                type: "warn",
+                reassurance: "It's possible to see this warning if steps are separated by regular asynchronous calls, which is fine.",
+                stack: true,
+                toFixNow: "Make sure you're not using `step.*` tooling inside of other `step.*` tooling. If you need to compose steps together, you can create a new async function and call it from within your step function, or use promise chaining.",
+                code: errors_1.ErrCode.NESTING_STEPS,
+            }));
+        }
+        const stepOptions = (0, InngestStepTools_1.getStepOptions)(args[0]);
+        const opId = matchOp(stepOptions, ...args.slice(1));
+        if (__classPrivateFieldGet(this, _V1InngestExecution_state, "f").steps[opId.id]) {
+            const originalId = opId.id;
+            maybeWarnOfParallelIndexing(originalId);
+            for (let i = 1;; i++) {
+                const newId = [originalId, InngestStepTools_1.STEP_INDEXING_SUFFIX, i].join("");
+                if (!__classPrivateFieldGet(this, _V1InngestExecution_state, "f").steps[newId]) {
+                    opId.id = newId;
+                    break;
+                }
+            }
+            console.debug(`${consts_1.logPrefix} debug - Step "${originalId}" already exists; automatically indexing to "${opId.id}"`);
+        }
+        const { promise, resolve, reject } = (0, promises_1.createDeferredPromise)();
+        const hashedId = exports._internals.hashId(opId.id);
+        const stepState = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").stepState[hashedId];
+        if (stepState) {
+            stepState.seen = true;
+        }
+        const step = Object.assign(Object.assign({}, opId), { hashedId, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            fn: (opts === null || opts === void 0 ? void 0 : opts.fn) ? () => { var _a; return (_a = opts.fn) === null || _a === void 0 ? void 0 : _a.call(opts, ...args); } : undefined, fulfilled: Boolean(stepState), displayName: (_a = opId.displayName) !== null && _a !== void 0 ? _a : opId.id, handled: false, handle: () => {
+                if (step.handled) {
+                    return false;
+                }
+                step.handled = true;
+                if (stepState) {
+                    stepState.fulfilled = true;
+                    if (typeof stepState.data !== "undefined") {
+                        resolve(stepState.data);
+                    }
+                    else {
+                        reject(stepState.error);
+                    }
+                }
+                return true;
+            } });
+        __classPrivateFieldGet(this, _V1InngestExecution_state, "f").steps[opId.id] = step;
+        __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hasSteps = true;
+        pushStepToReport(step);
+        /**
+         * If this is the last piece of state we had, we've now finished
+         * memoizing.
+         */
+        if (!beforeExecHooksPromise && __classPrivateFieldGet(this, _V1InngestExecution_state, "f").allStateUsed()) {
+            await (beforeExecHooksPromise = (async () => {
+                var _a, _b, _c, _d;
+                await ((_b = (_a = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _a === void 0 ? void 0 : _a.beforeExecution) === null || _b === void 0 ? void 0 : _b.call(_a));
+                await ((_d = (_c = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _c === void 0 ? void 0 : _c.afterMemoization) === null || _d === void 0 ? void 0 : _d.call(_c));
+            })());
+        }
+        return promise;
+    };
+    return (0, InngestStepTools_1.createStepTools)(this.options.client, stepHandler);
+}, _V1InngestExecution_getUserFnToRun = function _V1InngestExecution_getUserFnToRun() {
+    if (!this.options.isFailureHandler) {
+        return this.options.fn["fn"];
+    }
+    if (!this.options.fn["onFailureFn"]) {
+        /**
+         * Somehow, we've ended up detecting that this is a failure handler but
+         * doesn't have an `onFailure` function. This should never happen.
+         */
+        throw new Error("Cannot find function `onFailure` handler");
+    }
+    return this.options.fn["onFailureFn"];
+}, _V1InngestExecution_initializeTimer = function _V1InngestExecution_initializeTimer(state) {
+    if (!this.options.requestedRunStep) {
+        return;
+    }
+    __classPrivateFieldSet(this, _V1InngestExecution_timeout, (0, promises_1.createTimeoutPromise)(__classPrivateFieldGet(this, _V1InngestExecution_timeoutDuration, "f")), "f");
+    void __classPrivateFieldGet(this, _V1InngestExecution_timeout, "f").then(async () => {
+        var _a, _b, _c, _d, _e, _f;
+        await ((_b = (_a = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _a === void 0 ? void 0 : _a.afterMemoization) === null || _b === void 0 ? void 0 : _b.call(_a));
+        await ((_d = (_c = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _c === void 0 ? void 0 : _c.beforeExecution) === null || _d === void 0 ? void 0 : _d.call(_c));
+        await ((_f = (_e = __classPrivateFieldGet(this, _V1InngestExecution_state, "f").hooks) === null || _e === void 0 ? void 0 : _e.afterExecution) === null || _f === void 0 ? void 0 : _f.call(_e));
+        state.setCheckpoint({
+            type: "step-not-found",
+            step: {
+                id: this.options.requestedRunStep,
+                op: types_1.StepOpCode.StepNotFound,
+            },
+        });
+    });
+}, _V1InngestExecution_initializeMiddleware = async function _V1InngestExecution_initializeMiddleware() {
+    const ctx = this.options.data;
+    const hooks = await (0, InngestMiddleware_1.getHookStack)(this.options.fn["middleware"], "onFunctionRun", {
+        ctx,
+        fn: this.options.fn,
+        steps: Object.values(this.options.stepState),
+    }, {
+        transformInput: (prev, output) => {
+            return {
+                ctx: Object.assign(Object.assign({}, prev.ctx), output === null || output === void 0 ? void 0 : output.ctx),
+                fn: this.options.fn,
+                steps: prev.steps.map((step, i) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, step), (_a = output === null || output === void 0 ? void 0 : output.steps) === null || _a === void 0 ? void 0 : _a[i]));
+                }),
+            };
+        },
+        transformOutput: (prev, output) => {
+            return {
+                result: Object.assign(Object.assign({}, prev.result), output === null || output === void 0 ? void 0 : output.result),
+                step: prev.step,
+            };
+        },
+    });
+    return hooks;
+};
+const hashId = (id) => {
+    return (0, hash_js_1.sha1)().update(id).digest("hex");
+};
+const hashOp = (op) => {
+    return Object.assign(Object.assign({}, op), { id: hashId(op.id) });
+};
+/**
+ * Exported for testing.
+ */
+exports._internals = { hashOp, hashId };
+//# sourceMappingURL=v1.js.map