inngest 4.2.6 → 4.4.0

package/components/execution/InngestExecution.d.cts

@@ -93,8 +93,16 @@ interface InngestExecutionOptions {
   internalFnId?: string;
   reqArgs: unknown[];
   runId: string;
-  data: Omit<Context.Any, "step" | "group" | "publish">;
+  data: Omit<Context.Any, "step" | "group" | "publish" | "defer">;
   stepState: Record<string, MemoizedOp>;
+  /**
+   * A map of hashed defer step IDs to their backend-side metadata
+   * (e.g. `{ abortable: true }`). Defer ops are not steps in the
+   * memoization sense — they don't produce results — but the backend
+   * tracks which ones it has already received so the SDK can avoid
+   * re-emitting them on replay.
+   */
+  priorDefers?: Record<string, unknown>;
   stepCompletionOrder: string[];
   stepMode: StepMode;
   checkpointingConfig?: InternalCheckpointingOptions;
@@ -111,7 +119,16 @@ interface InngestExecutionOptions {
   headers: Record<string, string>;
   requestedRunStep?: string;
   timer?: ServerTiming;
-  isFailureHandler?: boolean;
+  /**
+   * Which handler variant is being executed. `"failure"` skips
+   * trigger-schema validation and resolves `onFailure` instead of the
+   * main handler. `"defer"` marks the fn as a standalone defer function
+   * (created via `createDefer`); incoming event data is validated
+   * against the defer function's schema.
+   *
+   * @default "main"
+   */
+  handlerKind?: "main" | "failure" | "defer";
   disableImmediateExecution?: boolean;
   /**
    * Information about the incoming HTTP request that triggered this execution.

package/components/execution/InngestExecution.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"InngestExecution.d.cts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AAkBH,UAjCO,uBAAA,CAiCP;QAQM,EAxCN,OAAA,CAAQ,GAwCS;MAvCrB,eAAA,CAAgB,GA8Ca;;;;;;;AAwBnC;EAAmC,YAAA,CAAA,EAAA,MAAA;SACxB,EAAA,OAAA,EAAA;OACN,EAAA,MAAA;EAAiB,IAAA,EA5Dd,IA4Dc,CA5DT,OAAA,CAAQ,GA4DC,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,CAAA;EAET,SAAA,EA7DA,MA6DA,CAAA,MAAgB,EA7DD,UA6DC,CAAA;EAAA,mBAAA,EAAA,MAAA,EAAA;UAGI,EA9DrB,QA8DqB;qBAFX,CAAA,EA3DE,4BA2DF;;;AAOtB;;;;aAEW,CAAA,EAAA,MAAA;;;;SAOC,EA9DD,MA8DC,CAAA,MAAA,EAAA,MAAA,CAAA;EAAM,gBAAA,CAAA,EAAA,MAAA;UA5DR;;;;;;;gBAQM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;;;;;;;uBAaZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}
+{"version":3,"file":"InngestExecution.d.cts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AA0BF,UAzCM,uBAAA,CAyCN;QAED,EA1CA,OAAA,CAAQ,GA0CR;MAzCJ,eAAA,CAAgB,GA2DK;;;;;;;;EA+Bf,YAAA,CAAA,EAAA,MAAA;EAAuB,OAAA,EAAA,OAAA,EAAA;OACxB,EAAA,MAAA;MACN,EAhFG,IAgFH,CAhFQ,OAAA,CAAQ,GAgFhB,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,GAAA,OAAA,CAAA;EAAiB,SAAA,EA/ET,MA+ES,CAAA,MAAA,EA/EM,UA+EN,CAAA;EAET;;;;;;AAQb;EAAkC,WAAA,CAAA,EAhFlB,MAgFkB,CAAA,MAAA,EAAA,OAAA,CAAA;qBACvB,EAAA,MAAA,EAAA;UACQ,EA/EP,QA+EO;qBAAR,CAAA,EA9Ea,4BA8Eb;;;;;;;;;;;WAjEA;;UAED;;;;;;;;;;;;;;;;gBAkBM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;;;;;;;uBAaZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}

package/components/execution/InngestExecution.d.ts

@@ -93,8 +93,16 @@ interface InngestExecutionOptions {
   internalFnId?: string;
   reqArgs: unknown[];
   runId: string;
-  data: Omit<Context.Any, "step" | "group" | "publish">;
+  data: Omit<Context.Any, "step" | "group" | "publish" | "defer">;
   stepState: Record<string, MemoizedOp>;
+  /**
+   * A map of hashed defer step IDs to their backend-side metadata
+   * (e.g. `{ abortable: true }`). Defer ops are not steps in the
+   * memoization sense — they don't produce results — but the backend
+   * tracks which ones it has already received so the SDK can avoid
+   * re-emitting them on replay.
+   */
+  priorDefers?: Record<string, unknown>;
   stepCompletionOrder: string[];
   stepMode: StepMode;
   checkpointingConfig?: InternalCheckpointingOptions;
@@ -111,7 +119,16 @@ interface InngestExecutionOptions {
   headers: Record<string, string>;
   requestedRunStep?: string;
   timer?: ServerTiming;
-  isFailureHandler?: boolean;
+  /**
+   * Which handler variant is being executed. `"failure"` skips
+   * trigger-schema validation and resolves `onFailure` instead of the
+   * main handler. `"defer"` marks the fn as a standalone defer function
+   * (created via `createDefer`); incoming event data is validated
+   * against the defer function's schema.
+   *
+   * @default "main"
+   */
+  handlerKind?: "main" | "failure" | "defer";
   disableImmediateExecution?: boolean;
   /**
    * Information about the incoming HTTP request that triggered this execution.

package/components/execution/InngestExecution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InngestExecution.d.ts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AAkBH,UAjCO,uBAAA,CAiCP;QAQM,EAxCN,OAAA,CAAQ,GAwCS;MAvCrB,eAAA,CAAgB,GA8Ca;;;;;;;AAwBnC;EAAmC,YAAA,CAAA,EAAA,MAAA;SACxB,EAAA,OAAA,EAAA;OACN,EAAA,MAAA;EAAiB,IAAA,EA5Dd,IA4Dc,CA5DT,OAAA,CAAQ,GA4DC,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,CAAA;EAET,SAAA,EA7DA,MA6DA,CAAA,MAAgB,EA7DD,UA6DC,CAAA;EAAA,mBAAA,EAAA,MAAA,EAAA;UAGI,EA9DrB,QA8DqB;qBAFX,CAAA,EA3DE,4BA2DF;;;AAOtB;;;;aAEW,CAAA,EAAA,MAAA;;;;SAOC,EA9DD,MA8DC,CAAA,MAAA,EAAA,MAAA,CAAA;EAAM,gBAAA,CAAA,EAAA,MAAA;UA5DR;;;;;;;gBAQM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;;;;;;;uBAaZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}
+{"version":3,"file":"InngestExecution.d.ts","names":[],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;UA6BiB,gBAAA;;;;;UAEK;;;;;;;;IAFL,KAAA,EAAA,CAIU,UAJM,EAAA,GAIS,UAJT,EAAA,CAAA;EAAA,CAAA;kBAEX,EAAA;IAEK,IAAA,EAEjB,UAFiB;IAAe,UAAA,EAG1B,cAH0B,EAAA;IAEhC,eAAA,EAAA,MAAA;;;;AAeV;;eACc,EAAA;IAEF,EAAA,EARJ,QAQI;IACD,KAAA,EAAQ,MAAA;;;AAEX,KANI,eAAA,GAMJ,QAAiB,MALX,gBAKW,GALQ,QAKR,CAAA;EALQ,IAAA,EAErB,CAFqB;EAOzB,GAAA,EAJG,OAAA,CAAQ,GAIX;EAAgB,GAAA,EAHb,MAGa,CAAA,MAAA,EAHE,UAGF,CAAA;AAEP,CAAA,GAJT,gBAIuB,CAJN,CAIM,CAAA,CAAA,EAK/B,CAAA,MAPQ,gBAOI,CAAA;AAAsB,UALjB,cAAA,CAKiB;MAAK,MAAA;aAC7B,CAAA,EAAA,MAAA;;AACL,KAFO,sBAEP,CAAA,IAFkC,cAElC,CAAA,GAAA,CAAA,MAAA,EADK,eACL,EAAA,GAAA,YAAA,CAAa,CAAb,CAAA;AAAY,KAEL,uBAFK,CAAA,IAEuB,cAFvB,CAAA,GAAA,QAGT,eADI,IACe,CADQ,CAAA,MAAA,CAAA,GAAA,CAAA,MAAA,EACa,CADb,EAAA,GACmB,YADnB,CACgC,CADhC,CAAA,EAAA;AAAK,UAIvB,UAAA,SAAmB,UAJI,CAAA;;;;;SACc,CAAA,EAAA,OAAA,EAAA;EAAY,SAAA,CAAA,EAAA,OAAA;EAGjD;;;SAAmB,CAAA,EAWxB,OAXwB,CAAA,OAAA,CAAA;EAAU,IAAA,CAAA,EAAA,OAAA;AAsB9C;AAMA;;;;;;;AAea,cArBA,iCAAA,GAqBA,gBAAA,CAAA,EAAA;;;;AA0BF,UAzCM,uBAAA,CAyCN;QAED,EA1CA,OAAA,CAAQ,GA0CR;MAzCJ,eAAA,CAAgB,GA2DK;;;;;;;;EA+Bf,YAAA,CAAA,EAAA,MAAA;EAAuB,OAAA,EAAA,OAAA,EAAA;OACxB,EAAA,MAAA;MACN,EAhFG,IAgFH,CAhFQ,OAAA,CAAQ,GAgFhB,EAAA,MAAA,GAAA,OAAA,GAAA,SAAA,GAAA,OAAA,CAAA;EAAiB,SAAA,EA/ET,MA+ES,CAAA,MAAA,EA/EM,UA+EN,CAAA;EAET;;;;;;AAQb;EAAkC,WAAA,CAAA,EAhFlB,MAgFkB,CAAA,MAAA,EAAA,OAAA,CAAA;qBACvB,EAAA,MAAA,EAAA;UACQ,EA/EP,QA+EO;qBAAR,CAAA,EA9Ea,4BA8Eb;;;;;;;;;;;WAjEA;;UAED;;;;;;;;;;;;;;;;gBAkBM,UAAA,CAAW;;;;;;wBAOH,UAAA,CAAW;;;;;;;;;;;uBAaZ,SAAS,OAAA,CAAQ,SAAS,OAAA,CAAQ;;;;;;;sCAQnB,aAAa;;KAGvC,uBAAA,aACD,4BACN;cAEQ,gBAAA;qBAGoB;sBAFX;uBAEW;;UAKhB,iBAAA;WACN;WACA,QAAQ;oCAIT,qBACC,mBACH,wBACI"}

package/components/execution/InngestExecution.js.map

@@ -1 +1 @@
-{"version":3,"file":"InngestExecution.js","names":["options: InngestExecutionOptions"],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":["import Debug, { type Debugger } from \"debug\";\nimport { debugPrefix, ExecutionVersion } from \"../../helpers/consts.ts\";\nimport type { ServerTiming } from \"../../helpers/ServerTiming.ts\";\nimport type { MaybePromise, Simplify } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  IncomingOp,\n  InternalCheckpointingOptions,\n  OutgoingOp,\n  StepMode,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { ActionResponse } from \"../InngestCommHandler.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type {\n  MetadataKind,\n  MetadataOpcode,\n  MetadataScope,\n} from \"../InngestMetadata.ts\";\nimport type { Middleware } from \"../middleware/middleware.ts\";\n\n// Re-export ExecutionVersion so it's correctly recognized as an enum and not\n// just a type. This can be lost when bundling if we don't re-export it here.\n// See `pnpm run test:dist`.\nexport { ExecutionVersion };\n\n/**\n * The possible results of an execution.\n */\nexport interface ExecutionResults {\n  \"function-resolved\": { data: unknown };\n  \"step-ran\": { step: OutgoingOp; retriable?: boolean | string };\n  \"function-rejected\": { error: unknown; retriable: boolean | string };\n  \"steps-found\": { steps: [OutgoingOp, ...OutgoingOp[]] };\n  \"step-not-found\": {\n    step: OutgoingOp;\n    foundSteps: BasicFoundStep[];\n    totalFoundSteps: number;\n  };\n\n  /**\n   * Indicates that we need to relinquish control back to Inngest in order to\n   * change step modes.\n   */\n  \"change-mode\": {\n    to: StepMode;\n    token: string;\n  };\n}\n\nexport type ExecutionResult = {\n  [K in keyof ExecutionResults]: Simplify<\n    {\n      type: K;\n      ctx: Context.Any;\n      ops: Record<string, MemoizedOp>;\n    } & ExecutionResults[K]\n  >;\n}[keyof ExecutionResults];\n\nexport interface BasicFoundStep {\n  id: string;\n  displayName?: string;\n}\n\nexport type ExecutionResultHandler<T = ActionResponse> = (\n  result: ExecutionResult,\n) => MaybePromise<T>;\n\nexport type ExecutionResultHandlers<T = ActionResponse> = {\n  [E in ExecutionResult as E[\"type\"]]: (result: E) => MaybePromise<T>;\n};\n\nexport interface MemoizedOp extends IncomingOp {\n  /**\n   * If the step has been hit during this run, these will be the arguments\n   * passed to it.\n   */\n  rawArgs?: unknown[];\n  fulfilled?: boolean;\n\n  /**\n   * The promise that has been returned to userland code.\n   */\n  promise?: Promise<unknown>;\n  seen?: boolean;\n}\n\n/**\n * The preferred execution version that will be used by the SDK when handling\n * brand new runs where the Executor is allowing us to choose.\n *\n * Changing this should not ever be a breaking change, as this will only change\n * new runs, not existing ones.\n */\nexport const PREFERRED_ASYNC_EXECUTION_VERSION =\n  ExecutionVersion.V2 satisfies ExecutionVersion;\n\n/**\n * Options for creating a new {@link InngestExecution} instance.\n */\nexport interface InngestExecutionOptions {\n  client: Inngest.Any;\n  fn: InngestFunction.Any;\n\n  /**\n   * The UUID that represents this function in Inngest.\n   *\n   * This is used to reference the function during async checkpointing, when we\n   * know the function/run already exists and just wish to reference it\n   * directly.\n   */\n  internalFnId?: string;\n  reqArgs: unknown[];\n  runId: string;\n  data: Omit<Context.Any, \"step\" | \"group\" | \"publish\">;\n  stepState: Record<string, MemoizedOp>;\n  stepCompletionOrder: string[];\n  stepMode: StepMode;\n  checkpointingConfig?: InternalCheckpointingOptions;\n\n  /**\n   * If this execution is being run from a queue job, this will be an identifier\n   * used to reference this execution in Inngest. SDKs are expected to parrot\n   * this back in some responses to correctly attribute actions to this queue\n   * item.\n   */\n  queueItemId?: string;\n\n  /**\n   * Headers to be sent with any request to Inngest during this execution.\n   */\n  headers: Record<string, string>;\n  requestedRunStep?: string;\n  timer?: ServerTiming;\n  isFailureHandler?: boolean;\n  disableImmediateExecution?: boolean;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   * Used by middleware `wrapRequest` hooks.\n   */\n  requestInfo?: Middleware.Request;\n\n  /**\n   * Pre-created middleware instances to use for this execution. When provided,\n   * the execution will use these instead of instantiating new ones from the\n   * client. This ensures `wrapRequest` and other hooks share state on `this`.\n   */\n  middlewareInstances?: Middleware.BaseMiddleware[];\n\n  /**\n   * Whether the client accepts SSE (`Accept: text/event-stream`). When true,\n   * the execution engine may deliver the result as an SSE stream even if\n   * `stream.push()` was not called.\n   */\n  acceptsSse?: boolean;\n\n  /**\n   * Provide the ability to transform the context passed to the function before\n   * the execution starts.\n   */\n  transformCtx?: (ctx: Readonly<Context.Any>) => Context.Any;\n\n  /**\n   * A hook that is called to create an {@link ActionResponse} from the returned\n   * value of an execution.\n   *\n   * This is required for checkpointing executions.\n   */\n  createResponse?: (data: unknown) => MaybePromise<ActionResponse>;\n}\n\nexport type InngestExecutionFactory = (\n  options: InngestExecutionOptions,\n) => IInngestExecution;\n\nexport class InngestExecution {\n  protected devDebug: Debugger;\n\n  constructor(protected options: InngestExecutionOptions) {\n    this.devDebug = Debug(`${debugPrefix}:${this.options.runId}`);\n  }\n}\n\nexport interface IInngestExecution {\n  version: ExecutionVersion;\n  start(): Promise<ExecutionResult>;\n\n  addMetadata(\n    stepId: string,\n    kind: MetadataKind,\n    scope: MetadataScope,\n    op: MetadataOpcode,\n    values: Record<string, unknown>,\n  ): boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA+FA,MAAa,oCACX,iBAAiB;AAiFnB,IAAa,mBAAb,MAA8B;CAC5B,AAAU;CAEV,YAAY,AAAUA,SAAkC;EAAlC;AACpB,OAAK,WAAW,MAAM,GAAG,YAAY,GAAG,KAAK,QAAQ,QAAQ"}
+{"version":3,"file":"InngestExecution.js","names":["options: InngestExecutionOptions"],"sources":["../../../src/components/execution/InngestExecution.ts"],"sourcesContent":["import Debug, { type Debugger } from \"debug\";\nimport { debugPrefix, ExecutionVersion } from \"../../helpers/consts.ts\";\nimport type { ServerTiming } from \"../../helpers/ServerTiming.ts\";\nimport type { MaybePromise, Simplify } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  IncomingOp,\n  InternalCheckpointingOptions,\n  OutgoingOp,\n  StepMode,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { ActionResponse } from \"../InngestCommHandler.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type {\n  MetadataKind,\n  MetadataOpcode,\n  MetadataScope,\n} from \"../InngestMetadata.ts\";\nimport type { Middleware } from \"../middleware/middleware.ts\";\n\n// Re-export ExecutionVersion so it's correctly recognized as an enum and not\n// just a type. This can be lost when bundling if we don't re-export it here.\n// See `pnpm run test:dist`.\nexport { ExecutionVersion };\n\n/**\n * The possible results of an execution.\n */\nexport interface ExecutionResults {\n  \"function-resolved\": { data: unknown };\n  \"step-ran\": { step: OutgoingOp; retriable?: boolean | string };\n  \"function-rejected\": { error: unknown; retriable: boolean | string };\n  \"steps-found\": { steps: [OutgoingOp, ...OutgoingOp[]] };\n  \"step-not-found\": {\n    step: OutgoingOp;\n    foundSteps: BasicFoundStep[];\n    totalFoundSteps: number;\n  };\n\n  /**\n   * Indicates that we need to relinquish control back to Inngest in order to\n   * change step modes.\n   */\n  \"change-mode\": {\n    to: StepMode;\n    token: string;\n  };\n}\n\nexport type ExecutionResult = {\n  [K in keyof ExecutionResults]: Simplify<\n    {\n      type: K;\n      ctx: Context.Any;\n      ops: Record<string, MemoizedOp>;\n    } & ExecutionResults[K]\n  >;\n}[keyof ExecutionResults];\n\nexport interface BasicFoundStep {\n  id: string;\n  displayName?: string;\n}\n\nexport type ExecutionResultHandler<T = ActionResponse> = (\n  result: ExecutionResult,\n) => MaybePromise<T>;\n\nexport type ExecutionResultHandlers<T = ActionResponse> = {\n  [E in ExecutionResult as E[\"type\"]]: (result: E) => MaybePromise<T>;\n};\n\nexport interface MemoizedOp extends IncomingOp {\n  /**\n   * If the step has been hit during this run, these will be the arguments\n   * passed to it.\n   */\n  rawArgs?: unknown[];\n  fulfilled?: boolean;\n\n  /**\n   * The promise that has been returned to userland code.\n   */\n  promise?: Promise<unknown>;\n  seen?: boolean;\n}\n\n/**\n * The preferred execution version that will be used by the SDK when handling\n * brand new runs where the Executor is allowing us to choose.\n *\n * Changing this should not ever be a breaking change, as this will only change\n * new runs, not existing ones.\n */\nexport const PREFERRED_ASYNC_EXECUTION_VERSION =\n  ExecutionVersion.V2 satisfies ExecutionVersion;\n\n/**\n * Options for creating a new {@link InngestExecution} instance.\n */\nexport interface InngestExecutionOptions {\n  client: Inngest.Any;\n  fn: InngestFunction.Any;\n\n  /**\n   * The UUID that represents this function in Inngest.\n   *\n   * This is used to reference the function during async checkpointing, when we\n   * know the function/run already exists and just wish to reference it\n   * directly.\n   */\n  internalFnId?: string;\n  reqArgs: unknown[];\n  runId: string;\n  data: Omit<Context.Any, \"step\" | \"group\" | \"publish\" | \"defer\">;\n  stepState: Record<string, MemoizedOp>;\n\n  /**\n   * A map of hashed defer step IDs to their backend-side metadata\n   * (e.g. `{ abortable: true }`). Defer ops are not steps in the\n   * memoization sense — they don't produce results — but the backend\n   * tracks which ones it has already received so the SDK can avoid\n   * re-emitting them on replay.\n   */\n  priorDefers?: Record<string, unknown>;\n\n  stepCompletionOrder: string[];\n  stepMode: StepMode;\n  checkpointingConfig?: InternalCheckpointingOptions;\n\n  /**\n   * If this execution is being run from a queue job, this will be an identifier\n   * used to reference this execution in Inngest. SDKs are expected to parrot\n   * this back in some responses to correctly attribute actions to this queue\n   * item.\n   */\n  queueItemId?: string;\n\n  /**\n   * Headers to be sent with any request to Inngest during this execution.\n   */\n  headers: Record<string, string>;\n  requestedRunStep?: string;\n  timer?: ServerTiming;\n  /**\n   * Which handler variant is being executed. `\"failure\"` skips\n   * trigger-schema validation and resolves `onFailure` instead of the\n   * main handler. `\"defer\"` marks the fn as a standalone defer function\n   * (created via `createDefer`); incoming event data is validated\n   * against the defer function's schema.\n   *\n   * @default \"main\"\n   */\n  handlerKind?: \"main\" | \"failure\" | \"defer\";\n\n  disableImmediateExecution?: boolean;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   * Used by middleware `wrapRequest` hooks.\n   */\n  requestInfo?: Middleware.Request;\n\n  /**\n   * Pre-created middleware instances to use for this execution. When provided,\n   * the execution will use these instead of instantiating new ones from the\n   * client. This ensures `wrapRequest` and other hooks share state on `this`.\n   */\n  middlewareInstances?: Middleware.BaseMiddleware[];\n\n  /**\n   * Whether the client accepts SSE (`Accept: text/event-stream`). When true,\n   * the execution engine may deliver the result as an SSE stream even if\n   * `stream.push()` was not called.\n   */\n  acceptsSse?: boolean;\n\n  /**\n   * Provide the ability to transform the context passed to the function before\n   * the execution starts.\n   */\n  transformCtx?: (ctx: Readonly<Context.Any>) => Context.Any;\n\n  /**\n   * A hook that is called to create an {@link ActionResponse} from the returned\n   * value of an execution.\n   *\n   * This is required for checkpointing executions.\n   */\n  createResponse?: (data: unknown) => MaybePromise<ActionResponse>;\n}\n\nexport type InngestExecutionFactory = (\n  options: InngestExecutionOptions,\n) => IInngestExecution;\n\nexport class InngestExecution {\n  protected devDebug: Debugger;\n\n  constructor(protected options: InngestExecutionOptions) {\n    this.devDebug = Debug(`${debugPrefix}:${this.options.runId}`);\n  }\n}\n\nexport interface IInngestExecution {\n  version: ExecutionVersion;\n  start(): Promise<ExecutionResult>;\n\n  addMetadata(\n    stepId: string,\n    kind: MetadataKind,\n    scope: MetadataScope,\n    op: MetadataOpcode,\n    values: Record<string, unknown>,\n  ): boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA+FA,MAAa,oCACX,iBAAiB;AAqGnB,IAAa,mBAAb,MAA8B;CAC5B,AAAU;CAEV,YAAY,AAAUA,SAAkC;EAAlC;AACpB,OAAK,WAAW,MAAM,GAAG,YAAY,GAAG,KAAK,QAAQ,QAAQ"}

package/components/execution/engine.cjs

@@ -7,9 +7,10 @@ const require_types = require('../../types.cjs');
 const require_InngestExecution = require('./InngestExecution.cjs');
 const require_types$1 = require('../../helpers/types.cjs');
 const require_functions = require('../../helpers/functions.cjs');
+const require_marker = require('../../helpers/marker.cjs');
+const require_temporal = require('../../helpers/temporal.cjs');
 const require_promises = require('../../helpers/promises.cjs');
 const require_als = require('./als.cjs');
-const require_temporal = require('../../helpers/temporal.cjs');
 const require_InngestStepTools = require('../InngestStepTools.cjs');
 const require_utils = require('../middleware/utils.cjs');
 const require_manager = require('../middleware/manager.cjs');
@@ -20,6 +21,7 @@ const require_StepError = require('../StepError.cjs');
 const require_streaming = require('./streaming.cjs');
 const require_StreamTools = require('../StreamTools.cjs');
 const require_utils$1 = require('../triggers/utils.cjs');
+const require_lazyOps = require('./lazyOps.cjs');
 const require_access = require('./otel/access.cjs');
 let zod_v3 = require("zod/v3");
 let hash_js = require("hash.js");
@@ -260,6 +262,8 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		throw new Error("Core loop finished without returning a value");
 	}
 	async checkpoint(steps) {
+		const lazyOps = this.state.lazyOps.drain();
+		if (lazyOps.length > 0) steps = [...steps, ...lazyOps];
 		if (this.options.stepMode === require_types.StepMode.Sync) if (!this.state.checkpointedRun) {
 			const res = await require_promises.retryWithBackoff(() => this.options.client["inngestApi"].checkpointNewRun({
 				runId: this.fnArg.runId,
@@ -517,12 +521,13 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 			return transformResult;
 		};
 		const maybeReturnNewSteps = async () => {
-			const newSteps = await this.filterNewSteps(Array.from(this.state.steps.values()));
-			if (newSteps) return {
+			const allSteps = [...await this.filterNewSteps(Array.from(this.state.steps.values())) ?? [], ...this.state.lazyOps.drain()];
+			if (allSteps.length === 0) return;
+			return {
 				type: "steps-found",
 				ctx: this.fnArg,
 				ops: this.ops,
-				steps: newSteps
+				steps: allSteps
 			};
 		};
 		const attemptCheckpointAndResume = async (stepResult, resume = true, force = false) => {
@@ -668,23 +673,36 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 					sseResponse = extractSseResponse(data, body);
 					resultData = body;
 				} else sseResponse = defaultSseResponse(resultData);
-				const newStepsResult = await maybeReturnNewSteps();
-				if (newStepsResult) return newStepsResult;
+				const newSteps = await this.filterNewSteps(Array.from(this.state.steps.values()));
+				if (newSteps?.length) return this.attachLazyOps({
+					type: "steps-found",
+					ctx: this.fnArg,
+					ops: this.ops,
+					steps: newSteps
+				});
 				await this.streamCloseSucceeded(sseResponse);
 				if (!this.streamTools.activated) this.postCheckpointStream();
 				if (this.options.createResponse) data = await this.options.createResponse(jsonResponse(resultData));
-				return this.transformOutput({ data });
+				return this.attachLazyOps(this.transformOutput({ data }));
 			},
 			"function-rejected": async (checkpoint) => {
 				if (!this.retriability(checkpoint.error)) await this.streamCloseFailed(errorMessage(checkpoint.error));
 				else await this.streamEnd();
 				if (!this.streamTools.activated) this.postCheckpointStream();
-				return this.transformOutput({ error: checkpoint.error });
+				return this.attachLazyOps(this.transformOutput({ error: checkpoint.error }));
 			},
 			"steps-found": async ({ steps }) => {
 				const stepResult = await this.tryExecuteStep(steps);
-				if (stepResult) return stepRanHandler(stepResult);
-				return maybeReturnNewSteps();
+				if (!stepResult) return maybeReturnNewSteps();
+				if (this.state.lazyOps.length === 0) return stepRanHandler(stepResult);
+				const transformed = await stepRanHandler(stepResult);
+				if (transformed.type !== "step-ran") return transformed;
+				return this.attachLazyOps({
+					type: "steps-found",
+					ctx: transformed.ctx,
+					ops: transformed.ops,
+					steps: [transformed.step]
+				});
 			},
 			"step-not-found": ({ step }) => {
 				const { foundSteps, totalFoundSteps } = this.getStepNotFoundDetails();
@@ -707,13 +725,18 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		const asyncCheckpointingHandlers = {
 			"": commonCheckpointHandler,
 			"function-resolved": async (checkpoint, i) => {
+				const lazyOps = this.state.lazyOps.drain();
 				const output = await asyncHandlers["function-resolved"](checkpoint, i);
 				if (output?.type === "function-resolved") {
-					const steps = this.state.checkpointingStepBuffer.concat({
-						op: require_types.StepOpCode.RunComplete,
-						id: hashId(RUN_COMPLETE_STEP_ID),
-						data: output.data
-					});
+					const steps = [
+						...this.state.checkpointingStepBuffer,
+						...lazyOps,
+						{
+							op: require_types.StepOpCode.RunComplete,
+							id: hashId(RUN_COMPLETE_STEP_ID),
+							data: output.data
+						}
+					];
 					if (isNonEmpty(steps)) return {
 						type: "steps-found",
 						ctx: output.ctx,
@@ -721,9 +744,14 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 						steps
 					};
 				}
+				if (output?.type === "steps-found" && lazyOps.length) return {
+					...output,
+					steps: [...output.steps, ...lazyOps]
+				};
+				return output;
 			},
 			"function-rejected": async (checkpoint) => {
-				if (this.state.checkpointingStepBuffer.length) {
+				if (this.state.checkpointingStepBuffer.length || this.state.lazyOps.length > 0) {
 					const fallback = await attemptCheckpointAndResume(void 0, false, true);
 					if (fallback) return fallback;
 				}
@@ -968,7 +996,11 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 	* Validate event data against schemas defined in function triggers.
 	*/
 	async validateEventSchemas() {
-		if (this.options.isFailureHandler) return;
+		if (this.options.handlerKind === "failure") return;
+		if (this.options.handlerKind === "defer") {
+			await this.validateDeferEventSchema();
+			return;
+		}
 		const triggers = this.options.fn.opts.triggers;
 		if (!triggers || triggers.length === 0) return;
 		const fnArgEvents = this.fnArg.events;
@@ -979,6 +1011,17 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		})), triggers);
 	}
 	/**
+	* Validate the deferred event's data against the defer function's own
+	* schema (set via `createDefer`'s `opts.schema`).
+	*/
+	async validateDeferEventSchema() {
+		const fn = this.options.fn;
+		if (!require_marker.isDeferredFunction(fn) || !fn.schema) return;
+		const eventData = this.fnArg.event?.data;
+		const result = await fn.schema["~standard"].validate(eventData);
+		if (result.issues) throw new require_NonRetriableError.NonRetriableError(`defer handler "${fn.id(this.options.client.id)}" schema validation failed: ${JSON.stringify(result.issues)}`);
+	}
+	/**
 	* Using middleware, transform output before returning.
 	*/
 	transformOutput(dataOrError) {
@@ -1001,6 +1044,64 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 			data: require_functions.undefinedToNull(data)
 		};
 	}
+	/**
+	* Drain buffered lazy ops (e.g. `DeferAdd` from `defer()`) and merge them
+	* into `result` so they ship in the same outbound message. Lazy ops are
+	* fire-and-forget and have no natural shipping moment, so each terminal code
+	* path must ship them or they're silently dropped.
+	*/
+	attachLazyOps(result, extras = []) {
+		const lazyOps = this.state.lazyOps.drain();
+		if (lazyOps.length === 0 && extras.length === 0) return result;
+		switch (result.type) {
+			case "function-resolved": {
+				const steps = [
+					...extras,
+					...lazyOps,
+					{
+						op: require_types.StepOpCode.RunComplete,
+						id: hashId(RUN_COMPLETE_STEP_ID),
+						data: require_functions.undefinedToNull(result.data)
+					}
+				];
+				return {
+					type: "steps-found",
+					ctx: result.ctx,
+					ops: result.ops,
+					steps
+				};
+			}
+			case "function-rejected": {
+				const isFinal = result.retriable === false;
+				const steps = [
+					...extras,
+					...lazyOps,
+					{
+						op: isFinal ? require_types.StepOpCode.StepFailed : require_types.StepOpCode.StepError,
+						id: hashId(RUN_COMPLETE_STEP_ID),
+						error: result.error
+					}
+				];
+				return {
+					type: "steps-found",
+					ctx: result.ctx,
+					ops: result.ops,
+					steps
+				};
+			}
+			case "steps-found": return {
+				...result,
+				steps: [
+					...result.steps,
+					...extras,
+					...lazyOps
+				]
+			};
+			default:
+				for (const op of lazyOps) this.state.lazyOps.push(op);
+				return result;
+		}
+	}
 	createExecutionState() {
 		const d = require_promises.createDeferredPromiseWithStack();
 		let checkpointResolve = d.deferred.resolve;
@@ -1023,6 +1124,7 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		const stepsToFulfill = Object.keys(this.options.stepState).length;
 		return {
 			stepState: this.options.stepState,
+			priorDefers: this.options.priorDefers ?? {},
 			stepsToFulfill,
 			steps: /* @__PURE__ */ new Map(),
 			loop,
@@ -1037,6 +1139,7 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 				return this.state.remainingStepsToBeSeen.size === 0;
 			},
 			checkpointingStepBuffer: [],
+			lazyOps: new require_lazyOps.LazyOps(),
 			metadata: /* @__PURE__ */ new Map()
 		};
 	}
@@ -1044,17 +1147,22 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		return Object.fromEntries(this.state.steps);
 	}
 	createFnArg() {
-		const step = this.createStepTools();
+		const { step, defer } = this.createStepTools();
 		const experimentStepRun = step[require_InngestStepTools.experimentStepRunSymbol];
 		let fnArg = {
 			...this.options.data,
 			step,
-			group: require_InngestGroupTools.createGroupTools({ experimentStepRun })
+			group: require_InngestGroupTools.createGroupTools({ experimentStepRun }),
+			defer
 		};
+		if (this.options.handlerKind === "defer") {
+			delete fnArg.event.data._inngest;
+			for (const event of fnArg.events) delete event.data._inngest;
+		}
 		/**
 		* Handle use of the `onFailure` option by deserializing the error.
 		*/
-		if (this.options.isFailureHandler) {
+		if (this.options.handlerKind === "failure") {
 			const eventData = zod_v3.z.object({ error: require_types.jsonErrorSchema }).parse(fnArg.event?.data);
 			fnArg = {
 				...fnArg,
@@ -1183,6 +1291,30 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		};
 		const stepHandler = async ({ args, matchOp, opts }) => {
 			const opId = matchOp(require_InngestStepTools.getStepOptions(args[0]), ...args.slice(1));
+			if (require_lazyOps.isLazyOp(opts, opId)) {
+				const hashedId$1 = _internals.hashId(opId.id);
+				if (this.state.lazyOps.hasId(hashedId$1)) {
+					this.options.client[require_Inngest.internalLoggerSymbol].warn({
+						runId: this.fnArg.runId,
+						id: opId.userland?.id ?? opId.id
+					}, "defer skipped: duplicate ID within run");
+					return;
+				}
+				if (this.state.priorDefers[hashedId$1]) {
+					this.state.lazyOps.markSeen(hashedId$1);
+					return;
+				}
+				this.state.lazyOps.push({
+					id: hashedId$1,
+					op: opId.op,
+					name: opId.name,
+					displayName: opId.displayName ?? opId.id,
+					opts: opId.opts,
+					userland: opId.userland,
+					data: null
+				});
+				return;
+			}
 			if (this.state.executingStep)
  /**
 			* If a step is found after asynchronous actions during another step's
@@ -1304,7 +1436,75 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 			} else pushStepToReport(step);
 			return promise;
 		};
-		return require_InngestStepTools.createStepTools(this.options.client, this, stepHandler);
+		return {
+			step: require_InngestStepTools.createStepTools(this.options.client, this, stepHandler),
+			defer: this.buildDefer(stepHandler)
+		};
+	}
+	/**
+	* Build the `defer(idOrOptions, { function, data })` method exposed on
+	* every handler context. Validates `data` against the target function's
+	* schema (if any) and emits a `DeferAdd` opcode that routes to the
+	* target's companion function slug.
+	*
+	* `defer()` is fire-and-forget: a misuse should not derail the user's
+	* handler. Validation failures (wrong function, async schema validator,
+	* schema mismatch) are logged and the call is silently skipped.
+	*/
+	buildDefer(stepHandler) {
+		return (idOrOptions, { function: deferFn, data }) => {
+			const log = this.options.client[require_Inngest.internalLoggerSymbol];
+			const runId = this.fnArg.runId;
+			try {
+				if (!require_marker.isDeferredFunction(deferFn)) {
+					log.error({ runId }, "defer skipped: function not created via createDefer");
+					return;
+				}
+				const { schema } = deferFn;
+				const deferFnSlug = deferFn.id(this.options.client.id);
+				let input = data;
+				if (schema) {
+					const result = schema["~standard"].validate(data);
+					if (result instanceof Promise) {
+						log.error({ runId }, "defer() requires a synchronous schema validator. The defer call was skipped.");
+						return;
+					}
+					if (result.issues) {
+						log.error({
+							runId,
+							issues: result.issues
+						}, "defer skipped: schema validation failed");
+						return;
+					}
+					input = result.value ?? data;
+				}
+				stepHandler({
+					args: [idOrOptions, input],
+					matchOp: (stepOptions, inputArg) => ({
+						id: stepOptions.id,
+						mode: require_types.StepMode.Sync,
+						op: require_types.StepOpCode.DeferAdd,
+						name: stepOptions.name ?? stepOptions.id,
+						displayName: stepOptions.name ?? stepOptions.id,
+						opts: {
+							fn_slug: deferFnSlug,
+							input: inputArg
+						},
+						userland: { id: stepOptions.id }
+					})
+				}).catch((err) => {
+					log.error({
+						runId,
+						err
+					}, "defer skipped: unexpected error");
+				});
+			} catch (err) {
+				log.error({
+					runId,
+					err
+				}, "defer skipped: unexpected error");
+			}
+		};
 	}
 	/**
 	* Applies middleware transformations to a step, resolves ID collisions,
@@ -1386,14 +1586,19 @@ var InngestExecutionEngine = class extends require_InngestExecution.InngestExecu
 		return userlandStep;
 	}
 	getUserFnToRun() {
-		if (!this.options.isFailureHandler) return this.options.fn["fn"];
-		if (!this.options.fn["onFailureFn"])
+		switch (this.options.handlerKind) {
+			case "defer": return this.options.fn["fn"];
+			case "failure":
+				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"];
+				* 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"];
+			default: return this.options.fn["fn"];
+		}
 	}
 	initializeTimer(state) {
 		if (!this.options.requestedRunStep) return;