inngest 4.3.0 → 4.4.0

package/components/execution/lazyOps.cjs

@@ -0,0 +1,64 @@
+const require_types = require('../../types.cjs');
+
+//#region src/components/execution/lazyOps.ts
+/**
+* Buffer for opcode-only sync ops (e.g. `DeferAdd`). These ops need to be
+* buffered until the next outbound wire message (e.g. checkpointing a
+* `step.run`).
+*
+* The engine owns shipping. This helper owns the buffer.
+*/
+var LazyOps = class {
+	buffer = [];
+	pushedIds = /* @__PURE__ */ new Set();
+	/**
+	* Number of ops waiting to ship.
+	*/
+	get length() {
+		return this.buffer.length;
+	}
+	/**
+	* Whether an op with this hashed id has been pushed in this execution
+	* (whether or not it has since been drained).
+	*/
+	hasId(id) {
+		return this.pushedIds.has(id);
+	}
+	/**
+	* Take ownership of buffered ops and clear the buffer. Callers ship them on
+	* whichever wire message comes next.
+	*/
+	drain() {
+		if (this.buffer.length === 0) return [];
+		const ops = this.buffer;
+		this.buffer = [];
+		return ops;
+	}
+	/**
+	* Buffer an op for later shipment.
+	*/
+	push(op) {
+		this.buffer.push(op);
+		this.pushedIds.add(op.id);
+	}
+	/**
+	* Record that an id has been observed in this execution without buffering
+	* an op for it. Used to consume a `priorDefers` replay match so that
+	* subsequent encounters of the same id surface as duplicates.
+	*/
+	markSeen(id) {
+		this.pushedIds.add(id);
+	}
+};
+/**
+* True when a step being registered is an opcode-only sync op (no local
+* handler, sync mode).
+*/
+function isLazyOp(opts, opId) {
+	return !opts?.fn && opId.mode === require_types.StepMode.Sync;
+}
+
+//#endregion
+exports.LazyOps = LazyOps;
+exports.isLazyOp = isLazyOp;
+//# sourceMappingURL=lazyOps.cjs.map

package/components/execution/lazyOps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyOps.cjs","names":["StepMode"],"sources":["../../../src/components/execution/lazyOps.ts"],"sourcesContent":["import { type OutgoingOp, StepMode } from \"../../types.ts\";\nimport type { MatchOpFn, StepToolOptions } from \"../InngestStepTools.ts\";\n\n/**\n * Buffer for opcode-only sync ops (e.g. `DeferAdd`). These ops need to be\n * buffered until the next outbound wire message (e.g. checkpointing a\n * `step.run`).\n *\n * The engine owns shipping. This helper owns the buffer.\n */\nexport class LazyOps {\n  private buffer: OutgoingOp[] = [];\n\n  // Tracks every id pushed during this execution, including those already\n  // drained. `buffer` alone can't answer \"have we seen this id?\" once a\n  // checkpoint ships its contents, so duplicates that straddle a drain would\n  // otherwise slip through.\n  private pushedIds: Set<string> = new Set();\n\n  /**\n   * Number of ops waiting to ship.\n   */\n  get length(): number {\n    return this.buffer.length;\n  }\n\n  /**\n   * Whether an op with this hashed id has been pushed in this execution\n   * (whether or not it has since been drained).\n   */\n  hasId(id: string): boolean {\n    return this.pushedIds.has(id);\n  }\n\n  /**\n   * Take ownership of buffered ops and clear the buffer. Callers ship them on\n   * whichever wire message comes next.\n   */\n  drain(): OutgoingOp[] {\n    if (this.buffer.length === 0) {\n      return [];\n    }\n    const ops = this.buffer;\n    this.buffer = [];\n    return ops;\n  }\n\n  /**\n   * Buffer an op for later shipment.\n   */\n  push(op: OutgoingOp): void {\n    this.buffer.push(op);\n    this.pushedIds.add(op.id);\n  }\n\n  /**\n   * Record that an id has been observed in this execution without buffering\n   * an op for it. Used to consume a `priorDefers` replay match so that\n   * subsequent encounters of the same id surface as duplicates.\n   */\n  markSeen(id: string): void {\n    this.pushedIds.add(id);\n  }\n}\n\n/**\n * True when a step being registered is an opcode-only sync op (no local\n * handler, sync mode).\n */\nexport function isLazyOp(\n  opts: StepToolOptions | undefined,\n  opId: ReturnType<MatchOpFn>,\n): boolean {\n  return !opts?.fn && opId.mode === StepMode.Sync;\n}\n"],"mappings":";;;;;;;;;;AAUA,IAAa,UAAb,MAAqB;CACnB,AAAQ,SAAuB,EAAE;CAMjC,AAAQ,4BAAyB,IAAI,KAAK;;;;CAK1C,IAAI,SAAiB;AACnB,SAAO,KAAK,OAAO;;;;;;CAOrB,MAAM,IAAqB;AACzB,SAAO,KAAK,UAAU,IAAI,GAAG;;;;;;CAO/B,QAAsB;AACpB,MAAI,KAAK,OAAO,WAAW,EACzB,QAAO,EAAE;EAEX,MAAM,MAAM,KAAK;AACjB,OAAK,SAAS,EAAE;AAChB,SAAO;;;;;CAMT,KAAK,IAAsB;AACzB,OAAK,OAAO,KAAK,GAAG;AACpB,OAAK,UAAU,IAAI,GAAG,GAAG;;;;;;;CAQ3B,SAAS,IAAkB;AACzB,OAAK,UAAU,IAAI,GAAG;;;;;;;AAQ1B,SAAgB,SACd,MACA,MACS;AACT,QAAO,CAAC,MAAM,MAAM,KAAK,SAASA,uBAAS"}

package/components/execution/lazyOps.d.cts

@@ -0,0 +1,42 @@
+import { OutgoingOp } from "../../types.cjs";
+
+//#region src/components/execution/lazyOps.d.ts
+
+/**
+ * Buffer for opcode-only sync ops (e.g. `DeferAdd`). These ops need to be
+ * buffered until the next outbound wire message (e.g. checkpointing a
+ * `step.run`).
+ *
+ * The engine owns shipping. This helper owns the buffer.
+ */
+declare class LazyOps {
+  private buffer;
+  private pushedIds;
+  /**
+   * Number of ops waiting to ship.
+   */
+  get length(): number;
+  /**
+   * Whether an op with this hashed id has been pushed in this execution
+   * (whether or not it has since been drained).
+   */
+  hasId(id: string): boolean;
+  /**
+   * Take ownership of buffered ops and clear the buffer. Callers ship them on
+   * whichever wire message comes next.
+   */
+  drain(): OutgoingOp[];
+  /**
+   * Buffer an op for later shipment.
+   */
+  push(op: OutgoingOp): void;
+  /**
+   * Record that an id has been observed in this execution without buffering
+   * an op for it. Used to consume a `priorDefers` replay match so that
+   * subsequent encounters of the same id surface as duplicates.
+   */
+  markSeen(id: string): void;
+}
+//#endregion
+export { LazyOps };
+//# sourceMappingURL=lazyOps.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazyOps.d.cts","names":[],"sources":["../../../src/components/execution/lazyOps.ts"],"sourcesContent":[],"mappings":";;;;;AAUA;;;;;;cAAa,OAAA;;;;;;;;;;;;;;;;WA4BF;;;;WAYA"}

package/components/execution/lazyOps.d.ts

@@ -0,0 +1,42 @@
+import { OutgoingOp } from "../../types.js";
+
+//#region src/components/execution/lazyOps.d.ts
+
+/**
+ * Buffer for opcode-only sync ops (e.g. `DeferAdd`). These ops need to be
+ * buffered until the next outbound wire message (e.g. checkpointing a
+ * `step.run`).
+ *
+ * The engine owns shipping. This helper owns the buffer.
+ */
+declare class LazyOps {
+  private buffer;
+  private pushedIds;
+  /**
+   * Number of ops waiting to ship.
+   */
+  get length(): number;
+  /**
+   * Whether an op with this hashed id has been pushed in this execution
+   * (whether or not it has since been drained).
+   */
+  hasId(id: string): boolean;
+  /**
+   * Take ownership of buffered ops and clear the buffer. Callers ship them on
+   * whichever wire message comes next.
+   */
+  drain(): OutgoingOp[];
+  /**
+   * Buffer an op for later shipment.
+   */
+  push(op: OutgoingOp): void;
+  /**
+   * Record that an id has been observed in this execution without buffering
+   * an op for it. Used to consume a `priorDefers` replay match so that
+   * subsequent encounters of the same id surface as duplicates.
+   */
+  markSeen(id: string): void;
+}
+//#endregion
+export { LazyOps };
+//# sourceMappingURL=lazyOps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazyOps.d.ts","names":[],"sources":["../../../src/components/execution/lazyOps.ts"],"sourcesContent":[],"mappings":";;;;;AAUA;;;;;;cAAa,OAAA;;;;;;;;;;;;;;;;WA4BF;;;;WAYA"}

package/components/execution/lazyOps.js

@@ -0,0 +1,63 @@
+import { StepMode } from "../../types.js";
+
+//#region src/components/execution/lazyOps.ts
+/**
+* Buffer for opcode-only sync ops (e.g. `DeferAdd`). These ops need to be
+* buffered until the next outbound wire message (e.g. checkpointing a
+* `step.run`).
+*
+* The engine owns shipping. This helper owns the buffer.
+*/
+var LazyOps = class {
+	buffer = [];
+	pushedIds = /* @__PURE__ */ new Set();
+	/**
+	* Number of ops waiting to ship.
+	*/
+	get length() {
+		return this.buffer.length;
+	}
+	/**
+	* Whether an op with this hashed id has been pushed in this execution
+	* (whether or not it has since been drained).
+	*/
+	hasId(id) {
+		return this.pushedIds.has(id);
+	}
+	/**
+	* Take ownership of buffered ops and clear the buffer. Callers ship them on
+	* whichever wire message comes next.
+	*/
+	drain() {
+		if (this.buffer.length === 0) return [];
+		const ops = this.buffer;
+		this.buffer = [];
+		return ops;
+	}
+	/**
+	* Buffer an op for later shipment.
+	*/
+	push(op) {
+		this.buffer.push(op);
+		this.pushedIds.add(op.id);
+	}
+	/**
+	* Record that an id has been observed in this execution without buffering
+	* an op for it. Used to consume a `priorDefers` replay match so that
+	* subsequent encounters of the same id surface as duplicates.
+	*/
+	markSeen(id) {
+		this.pushedIds.add(id);
+	}
+};
+/**
+* True when a step being registered is an opcode-only sync op (no local
+* handler, sync mode).
+*/
+function isLazyOp(opts, opId) {
+	return !opts?.fn && opId.mode === StepMode.Sync;
+}
+
+//#endregion
+export { LazyOps, isLazyOp };
+//# sourceMappingURL=lazyOps.js.map

package/components/execution/lazyOps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyOps.js","names":[],"sources":["../../../src/components/execution/lazyOps.ts"],"sourcesContent":["import { type OutgoingOp, StepMode } from \"../../types.ts\";\nimport type { MatchOpFn, StepToolOptions } from \"../InngestStepTools.ts\";\n\n/**\n * Buffer for opcode-only sync ops (e.g. `DeferAdd`). These ops need to be\n * buffered until the next outbound wire message (e.g. checkpointing a\n * `step.run`).\n *\n * The engine owns shipping. This helper owns the buffer.\n */\nexport class LazyOps {\n  private buffer: OutgoingOp[] = [];\n\n  // Tracks every id pushed during this execution, including those already\n  // drained. `buffer` alone can't answer \"have we seen this id?\" once a\n  // checkpoint ships its contents, so duplicates that straddle a drain would\n  // otherwise slip through.\n  private pushedIds: Set<string> = new Set();\n\n  /**\n   * Number of ops waiting to ship.\n   */\n  get length(): number {\n    return this.buffer.length;\n  }\n\n  /**\n   * Whether an op with this hashed id has been pushed in this execution\n   * (whether or not it has since been drained).\n   */\n  hasId(id: string): boolean {\n    return this.pushedIds.has(id);\n  }\n\n  /**\n   * Take ownership of buffered ops and clear the buffer. Callers ship them on\n   * whichever wire message comes next.\n   */\n  drain(): OutgoingOp[] {\n    if (this.buffer.length === 0) {\n      return [];\n    }\n    const ops = this.buffer;\n    this.buffer = [];\n    return ops;\n  }\n\n  /**\n   * Buffer an op for later shipment.\n   */\n  push(op: OutgoingOp): void {\n    this.buffer.push(op);\n    this.pushedIds.add(op.id);\n  }\n\n  /**\n   * Record that an id has been observed in this execution without buffering\n   * an op for it. Used to consume a `priorDefers` replay match so that\n   * subsequent encounters of the same id surface as duplicates.\n   */\n  markSeen(id: string): void {\n    this.pushedIds.add(id);\n  }\n}\n\n/**\n * True when a step being registered is an opcode-only sync op (no local\n * handler, sync mode).\n */\nexport function isLazyOp(\n  opts: StepToolOptions | undefined,\n  opId: ReturnType<MatchOpFn>,\n): boolean {\n  return !opts?.fn && opId.mode === StepMode.Sync;\n}\n"],"mappings":";;;;;;;;;;AAUA,IAAa,UAAb,MAAqB;CACnB,AAAQ,SAAuB,EAAE;CAMjC,AAAQ,4BAAyB,IAAI,KAAK;;;;CAK1C,IAAI,SAAiB;AACnB,SAAO,KAAK,OAAO;;;;;;CAOrB,MAAM,IAAqB;AACzB,SAAO,KAAK,UAAU,IAAI,GAAG;;;;;;CAO/B,QAAsB;AACpB,MAAI,KAAK,OAAO,WAAW,EACzB,QAAO,EAAE;EAEX,MAAM,MAAM,KAAK;AACjB,OAAK,SAAS,EAAE;AAChB,SAAO;;;;;CAMT,KAAK,IAAsB;AACzB,OAAK,OAAO,KAAK,GAAG;AACpB,OAAK,UAAU,IAAI,GAAG,GAAG;;;;;;;CAQ3B,SAAS,IAAkB;AACzB,OAAK,UAAU,IAAI,GAAG;;;;;;;AAQ1B,SAAgB,SACd,MACA,MACS;AACT,QAAO,CAAC,MAAM,MAAM,KAAK,SAAS,SAAS"}

package/components/execution/otel/middleware.d.cts

@@ -8,7 +8,7 @@ import { Middleware } from "../../middleware/middleware.cjs";
 import { Realtime } from "../../realtime/types.cjs";
 import { EventType } from "../../triggers/triggers.cjs";
 import { InngestFunction } from "../../InngestFunction.cjs";
-import { ClientOptions, EventPayload, InvocationResult, InvokeTargetFunctionDefinition, JsonError, SendEventBaseOutput, SendEventOutput, StepOptionsOrId, TimeStr, TimeStrBatch, TriggerEventFromFunction } from "../../../types.cjs";
+import { ClientOptions, DeferFn, EventPayload, InvocationResult, InvokeTargetFunctionDefinition, JsonError, SendEventBaseOutput, SendEventOutput, StepOptionsOrId, TimeStr, TimeStrBatch, TriggerEventFromFunction } from "../../../types.cjs";
 import { GetFunctionOutputRaw, Inngest } from "../../Inngest.cjs";
 import { Behaviour, Instrumentations } from "./util.cjs";
 import * as _standard_schema_spec0 from "@standard-schema/spec";
@@ -72,8 +72,6 @@ declare const extendedTracesMiddleware: ({
       ctx: {
         tracer: _opentelemetry_api0.Tracer;
         event: Simplify<EventPayload>;
-        events: AsTuple<Simplify<EventPayload>>;
-        runId: string;
         step: {
           sendEvent: (idOrOptions: StepOptionsOrId, payload: SendEventPayload) => Promise<SendEventOutput<ClientOptions>>;
           waitForSignal: <TData>(idOrOptions: StepOptionsOrId, opts: {
@@ -155,6 +153,11 @@ declare const extendedTracesMiddleware: ({
           }) => InvocationResult<Jsonify<GetFunctionOutputRaw<TFunction>>>;
           fetch: StepFetch;
         };
+        defer: DeferFn;
+        events: AsTuple<Simplify<EventPayload>>;
+        runId: string;
+        requestId?: string | undefined;
+        jobId?: string | undefined;
         group: ReturnType<typeof createGroupTools>;
         attempt: number;
         maxAttempts?: number | undefined;

package/components/execution/otel/middleware.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.cts","names":[],"sources":["../../../../src/components/execution/otel/middleware.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;UA6BiB,+BAAA;;;;;;;;;;;;;EAAA,SAAA,CAAA,EAaH,SAbG;EAA+B;;;;;AAwChD;;kBAAyC,CAAA,EAlBpB,gBAkBoB;;;;;;;UA6GO,CAAA,EAvHnC,YAuHmC;;;;;;;;;cA7GnC;;;;IAIV;;;;;;;gCAyGQ,UAAA,CAAW;;gBAA0B,mBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAWI,EAAA,CAAA,EAAA,MAAA;gBAAe,EAAA,CAAA,EAAA,MAAA;gBAAA,CAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YApCb,SAAA,WAAA,CAAA,EAAA,MAAA,GAAA,MAAA,GAAA;cAAc,6BAAA,EAAA,mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoC3B,UAAA,CAAW,kBAAe,QAAA,UAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;KApCxB,UAAA,CAAW"}
+{"version":3,"file":"middleware.d.cts","names":[],"sources":["../../../../src/components/execution/otel/middleware.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;UA6BiB,+BAAA;;;;;;;;;;;;;EAAA,SAAA,CAAA,EAaH,SAbG;EAA+B;;;;;AAwChD;;kBAAyC,CAAA,EAlBpB,gBAkBoB;;;;;;;UA6GO,CAAA,EAvHnC,YAuHmC;;;;;;;;;cA7GnC;;;;IAIV;;;;;;;gCAyGQ,UAAA,CAAW;;gBAA0B,mBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAWI,SAAA,OAAA,CAAA,EAAA,MAAA,GAAA,SAAA;cAAe,SAAA,MAAA,EAAA,CAAA,GAAA,IAAA,EAAA,CAAA,IAAA,SAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA,EAAA,OAAA,GAAA;gBAAA,EAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YApCb,CAAA,GAAA,SAAA;YAAc,SAAA,aAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoC3B,UAAA,CAAW,kBAAe,QAAA,UAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;KApCxB,UAAA,CAAW"}

package/components/execution/otel/middleware.d.ts

@@ -8,7 +8,7 @@ import { Middleware } from "../../middleware/middleware.js";
 import { Realtime } from "../../realtime/types.js";
 import { EventType } from "../../triggers/triggers.js";
 import { InngestFunction } from "../../InngestFunction.js";
-import { ClientOptions, EventPayload, InvocationResult, InvokeTargetFunctionDefinition, JsonError, SendEventBaseOutput, SendEventOutput, StepOptionsOrId, TimeStr, TimeStrBatch, TriggerEventFromFunction } from "../../../types.js";
+import { ClientOptions, DeferFn, EventPayload, InvocationResult, InvokeTargetFunctionDefinition, JsonError, SendEventBaseOutput, SendEventOutput, StepOptionsOrId, TimeStr, TimeStrBatch, TriggerEventFromFunction } from "../../../types.js";
 import { GetFunctionOutputRaw, Inngest } from "../../Inngest.js";
 import { Behaviour, Instrumentations } from "./util.js";
 import * as _opentelemetry_api0 from "@opentelemetry/api";
@@ -72,8 +72,6 @@ declare const extendedTracesMiddleware: ({
       ctx: {
         tracer: _opentelemetry_api0.Tracer;
         event: Simplify<EventPayload>;
-        events: AsTuple<Simplify<EventPayload>>;
-        runId: string;
         step: {
           sendEvent: (idOrOptions: StepOptionsOrId, payload: SendEventPayload) => Promise<SendEventOutput<ClientOptions>>;
           waitForSignal: <TData>(idOrOptions: StepOptionsOrId, opts: {
@@ -155,6 +153,11 @@ declare const extendedTracesMiddleware: ({
           }) => InvocationResult<Jsonify<GetFunctionOutputRaw<TFunction>>>;
           fetch: StepFetch;
         };
+        defer: DeferFn;
+        events: AsTuple<Simplify<EventPayload>>;
+        runId: string;
+        requestId?: string | undefined;
+        jobId?: string | undefined;
         group: ReturnType<typeof createGroupTools>;
         attempt: number;
         maxAttempts?: number | undefined;

package/components/execution/otel/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../../../src/components/execution/otel/middleware.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;UA6BiB,+BAAA;;;;;;;;;;;;;EAAA,SAAA,CAAA,EAaH,SAbG;EAA+B;;;;;AAwChD;;kBAAyC,CAAA,EAlBpB,gBAkBoB;;;;;;;UA6GO,CAAA,EAvHnC,YAuHmC;;;;;;;;;cA7GnC;;;;IAIV;;;;;;;gCAyGQ,UAAA,CAAW;;gBAA0B,mBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAWI,EAAA,CAAA,EAAA,MAAA;gBAAe,EAAA,CAAA,EAAA,MAAA;gBAAA,CAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YApCb,SAAA,WAAA,CAAA,EAAA,MAAA,GAAA,MAAA,GAAA;cAAc,6BAAA,EAAA,mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoC3B,UAAA,CAAW,kBAAe,QAAA,UAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;KApCxB,UAAA,CAAW"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../../../src/components/execution/otel/middleware.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;UA6BiB,+BAAA;;;;;;;;;;;;;EAAA,SAAA,CAAA,EAaH,SAbG;EAA+B;;;;;AAwChD;;kBAAyC,CAAA,EAlBpB,gBAkBoB;;;;;;;UA6GO,CAAA,EAvHnC,YAuHmC;;;;;;;;;cA7GnC;;;;IAIV;;;;;;;gCAyGQ,UAAA,CAAW;;gBAA0B,mBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAWI,SAAA,OAAA,CAAA,EAAA,MAAA,GAAA,SAAA;cAAe,SAAA,MAAA,EAAA,CAAA,GAAA,IAAA,EAAA,CAAA,IAAA,SAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA,EAAA,OAAA,GAAA;gBAAA,EAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YApCb,CAAA,GAAA,SAAA;YAAc,SAAA,aAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoC3B,UAAA,CAAW,kBAAe,QAAA,UAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;KApCxB,UAAA,CAAW"}

package/components/middleware/middleware.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.cjs","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":["import type { Jsonify } from \"../../helpers/jsonify.ts\";\nimport type { MaybePromise } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  EventPayload,\n  JsonError,\n  SendEventBaseOutput,\n  StepOptions,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { createStepTools } from \"../InngestStepTools.ts\";\nimport type { OpenStringUnion } from \"./types.ts\";\n\n/**\n * Namespace containing middleware-related types and base class.\n */\nexport namespace Middleware {\n  /**\n   * Base interface for output transformers. Extend this and override `Out` to\n   * create custom transformers. This is necessary because TypeScript doesn't\n   * support higher-kinded types.\n   *\n   * @example\n   * ```ts\n   * interface BooleanToStringTransform extends Middleware.StaticTransform {\n   *   Out: this[\"In\"] extends boolean ? string : this[\"In\"];\n   * }\n   * ```\n   */\n  export type StaticTransform = {\n    In: unknown;\n    Out: unknown;\n  };\n\n  /**\n   * Default transform. Applies the same transform as `JSON.stringify`.\n   */\n  export interface DefaultStaticTransform extends StaticTransform {\n    Out: Jsonify<this[\"In\"]>;\n  }\n\n  /**\n   * The step tools available to middleware for extending step functionality.\n   * This is the same type as `step` in the function handler context.\n   */\n  export type StepTools = ReturnType<typeof createStepTools<Inngest.Any>>;\n\n  /**\n   * The argument passed to `transformSendEvent`.\n   */\n  export type TransformSendEventArgs = {\n    events: EventPayload<Record<string, unknown>>[];\n    readonly fn: DeepReadonly<InngestFunction.Any> | null;\n  };\n\n  /**\n   * The argument passed to `transformStepInput`.\n   */\n  export type TransformStepInputArgs = {\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    readonly stepInfo: Readonly<\n      Pick<StepInfo, \"hashedId\" | \"memoized\" | \"stepType\">\n    >;\n    stepOptions: StepOptions;\n    input: unknown[];\n  };\n\n  /** The argument passed to `wrapStepHandler`. */\n  export type WrapStepHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * A single memoized step entry received in `transformFunctionInput`.\n   */\n  type MemoizedStep =\n    | { type: \"data\"; data: unknown }\n    | { type: \"error\"; error: JsonError }\n    | { type: \"input\"; input: unknown };\n\n  /**\n   * Memoized step state keyed by hashed step ID.\n   */\n  type MemoizedSteps = Record<string, MemoizedStep>;\n\n  /**\n   * The argument passed to `transformFunctionInput`.\n   */\n  export type TransformFunctionInputArgs = {\n    ctx: Context.Any;\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    steps: MemoizedSteps;\n  };\n\n  /**\n   * The argument passed to the static `onRegister` hook.\n   */\n  export type OnRegisterArgs = Readonly<{\n    client: Inngest.Any;\n    fn: InngestFunction.Any | null;\n  }>;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   */\n  export type Request = {\n    body: () => Promise<unknown>;\n    headers: Readonly<Record<string, string>>;\n    method: string;\n    url: URL;\n  };\n\n  /** The argument passed to `wrapFunctionHandler`. */\n  export type WrapFunctionHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n  }>;\n\n  /** The argument passed to `wrapRequest`. */\n  export type WrapRequestArgs = DeepReadonly<{\n    fn: InngestFunction.Any | null;\n    next: () => Promise<Response>;\n    requestArgs: readonly unknown[];\n    requestInfo: Request;\n    runId: string;\n  }>;\n\n  /** The argument passed to `wrapSendEvent`. */\n  export type WrapSendEventArgs = DeepReadonly<{\n    events: EventPayload<Record<string, unknown>>[];\n    fn: InngestFunction.Any | null;\n    next: () => Promise<SendEventBaseOutput>;\n  }>;\n\n  /** The argument passed to `wrapStep`. */\n  export type WrapStepArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The shape of the HTTP response returned by the middleware chain.\n   * This is what `next()` resolves with inside `wrapRequest`.\n   */\n  export type Response = {\n    body: string;\n    headers: Record<string, string>;\n    status: number;\n  };\n\n  /**\n   * The argument passed to `onMemoizationEnd`.\n   */\n  export type OnMemoizationEndArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onStepStart`.\n   */\n  export type OnStepStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepError`.\n   */\n  export type OnStepErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the step, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the step will be\n     * retried.\n     */\n    isFinalAttempt: boolean;\n\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepComplete`.\n   */\n  export type OnStepCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onRunStart`.\n   */\n  export type OnRunStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onRunComplete`.\n   */\n  export type OnRunCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n  }>;\n\n  /**\n   * The argument passed to `onRunError`.\n   */\n  export type OnRunErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the function, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the function will\n     * be retried.\n     */\n    isFinalAttempt: boolean;\n  }>;\n\n  /**\n   * The type of step. This union may be extended in the future, and will not be\n   * considered a breaking change.\n   */\n  export type StepType = OpenStringUnion<\n    | \"ai.infer\"\n    | \"ai.wrap\"\n    | \"fetch\"\n    | \"group.experiment\"\n    | \"invoke\"\n    | \"realtime.publish\"\n    | \"run\"\n    | \"sendEvent\"\n    | \"sleep\"\n    | \"waitForEvent\"\n  >;\n\n  export type StepInfo = {\n    /**\n     * Unique ID for the step. This is a hash of the user-defined step ID,\n     * including the implicit index if the user-defined ID is not unique.\n     */\n    hashedId: string;\n\n    /**\n     * The arguments passed to the step function, if any. For `step.run()`,\n     * these are the arguments after the id and handler function.\n     */\n    input?: unknown[];\n\n    /**\n     * Whether the step result is being retrieved from memoized state (true)\n     * or being executed fresh (false).\n     */\n    memoized: boolean;\n\n    /**\n     * Based on the first argument passed to the `step` method.\n     */\n    options: StepOptions;\n\n    stepType: StepType;\n  };\n\n  /**\n   * Base class for creating middleware. Extend this class to create custom\n   * middleware with hooks for step execution.\n   */\n  // @privateRemark\n  // Methods are nullish instead of noops as a performance optimization. This is\n  // primarily because of `wrapStep`. Each defined `wrapStep` method adds 1 more\n  // promise to the chain for each step. This chain runs every time the step\n  // completes/errors (even when memoized).\n  export abstract class BaseMiddleware {\n    readonly client: Inngest.Any;\n\n    /**\n     * Used to identify the middleware instance in logs. Uniqueness is not\n     * required, though using multiple middleware with the same ID in the same\n     * app may cause confusion when debugging.\n     */\n    abstract readonly id: string;\n\n    /**\n     * Declare this to statically specify how function return types are\n     * transformed. By default, the function return type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare functionOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare functionOutputTransform: DefaultStaticTransform;\n\n    /**\n     * Declare this to statically specify how step output types are transformed.\n     * By default, the step output type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare stepOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare stepOutputTransform: DefaultStaticTransform;\n\n    constructor({ client }: { client: Inngest.Any }) {\n      this.client = client;\n    }\n\n    /**\n     * Called when the middleware class is added to an Inngest client or Inngest\n     * function. Use this for one-time setup that needs a reference to the\n     * client instance (e.g. registering processors, setting feature flags).\n     *\n     * Do not mutate arguments.\n     */\n    static onRegister?(args: Middleware.OnRegisterArgs): void;\n\n    /**\n     * Called 1 time per request, after memoization completes.\n     *\n     * If all memoized steps have been resolved/rejected, then this hook calls.\n     * This is at the top of the function handler when there are 0 memoized\n     * steps.\n     *\n     * If a new step is found before resolving/rejecting all memoized steps,\n     * then this calls.\n     *\n     * Do not mutate arguments.\n     */\n    onMemoizationEnd?(arg: Middleware.OnMemoizationEndArgs): MaybePromise<void>;\n\n    /**\n     * Called when the run completes successfully. Does NOT call when the run\n     * errors: `onRunError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onRunComplete?(arg: Middleware.OnRunCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called when the function throws an error.\n     *\n     * Do not mutate arguments.\n     */\n    onRunError?(arg: Middleware.OnRunErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per run on the very first request (0 memoized steps,\n     * attempt 0). Does NOT call on subsequent requests where steps are being\n     * replayed.\n     *\n     * Do not mutate arguments.\n     */\n    onRunStart?(arg: Middleware.OnRunStartArgs): MaybePromise<void>;\n\n    /**\n     * Called when a step successfully completes. Only called for `step.run`\n     * and `step.sendEvent`. Never called for memoized step outputs. Does NOT\n     * call when the step errors: `onStepError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onStepComplete?(arg: Middleware.OnStepCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called each time a step errors. Only called for `step.run` and\n     * `step.sendEvent`. Never called for memoized errors.\n     *\n     * Do not mutate arguments.\n     */\n    onStepError?(arg: Middleware.OnStepErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per step before running its handler. Only called for\n     * `step.run` and `step.sendEvent`.\n     *\n     * Do not mutate arguments.\n     */\n    onStepStart?(arg: Middleware.OnStepStartArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per request (likely multiple times per run). Return the\n     * (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Dependency injection.\n     * - Deserialize events before passing it to the function handler.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because `wrapFunctionHandler` can't be used for the\n    // transformation's static type inference. For example, if the user added\n    // `ctx.db` in `wrapFunctionHandler` then the static types wouldn't show\n    // `ctx.db` in the function handler.\n    transformFunctionInput?(\n      arg: Middleware.TransformFunctionInputArgs,\n    ): MaybePromise<Middleware.TransformFunctionInputArgs>;\n\n    /**\n     * Called when sending events. This is either `step.sendEvent` or\n     * `client.send`. Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Serialize event data before sending it to the Inngest Server.\n     *\n     * Do not mutate arguments.\n     */\n    transformSendEvent?(\n      arg: Middleware.TransformSendEventArgs,\n    ): MaybePromise<Middleware.TransformSendEventArgs>;\n\n    /**\n     * Called 1 time per step per request (likely multiple times per step).\n     * Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Modify step options (e.g. the step ID).\n     * - Modify step input args.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // Step input transformation could happen in `wrapStep`, but we chose not to\n    // for the following reasons:\n    // 1. `wrapStep` may have a negative performance impact under certain\n    //    workloads.\n    // 2. `wrapStep` is a little more complicated to use.\n    // 3. Since `transformFunctionInput` must exist, having this hook\n    //    establishes a consistent pattern for input transformation.\n    transformStepInput?(\n      arg: TransformStepInputArgs,\n    ): MaybePromise<TransformStepInputArgs>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - AsyncLocalStorage context.\n     * - Function-level output/error transformation.\n     * - Prepend/append steps around the function handler.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * **Important:** `next()` only resolves when the function completes. On\n     * requests where a fresh step is discovered, control flow is interrupted\n     * and `next()` never resolves.\n     */\n    wrapFunctionHandler?(args: WrapFunctionHandlerArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - Custom auth.\n     * - Expose request data to the Inngest function handler.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapRequest?(args: WrapRequestArgs): Promise<Response>;\n\n    /**\n     * Called each time events are sent (either `client.send` or\n     * `step.sendEvent`).\n     *\n     * Use cases:\n     * - Backup events (e.g. blob store) when they fail to send.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapSendEvent?(args: WrapSendEventArgs): Promise<SendEventBaseOutput>;\n\n    /**\n     * Called 1 time per step per request. Called for all step kinds. Depending\n     * on your use case, you may want `wrapStepHandler` instead.\n     *\n     * Use cases:\n     * - Deserialize step output before returning it to the function handler.\n     * - Handle step failure errors (after exhausting retries).\n     * - Prepend/append steps around a step.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * NOTE: `next()` only resolves when the step completes/fails. On requests\n     * where a fresh step is discovered, control flow is interrupted and\n     * `next()` never resolves.\n     */\n    wrapStep?(args: WrapStepArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per step attempt. Wraps the step's handler. Only called for\n     * `step.run` and `step.sendEvent`. Use this to modify the handler's\n     * returned output or thrown error before it's sent to the Inngest Server.\n     *\n     * Use cases:\n     * - Serialize step output before sending it to the Inngest Server.\n     * - Handle step attempt errors (before exhausting retries).\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because of checkpointing. For serialization middleware\n    // to work with checkpointing, we need to both:\n    // 1. Serialize the step output before sending it to the Inngest Server.\n    // 2. Deserialize the step output before returning it to the function handler.\n    //\n    // We initially solved this by calling `wrapStep` twice per step per\n    // request. But this breaks the \"prepend with step\" logic since we'd\n    // encounter the prepended step twice; this caused us to run the prepended\n    // step twice.\n    //\n    // Now that we have `wrapStepHandler`, it can be responsible for\n    // serialization and `wrapStep` can be responsible for deserialization.\n    wrapStepHandler?(args: WrapStepHandlerArgs): Promise<unknown>;\n  }\n\n  /**\n   * A no-arg constructor for a BaseMiddleware subclass. Used in client and\n   * function options so that fresh instances are created per-request.\n   */\n  export type Class = (new (args: {\n    client: Inngest.Any;\n  }) => BaseMiddleware) & {\n    // Static methods aren't captured by `new () => ...`, so we repeat it here.\n    onRegister?(arg: OnRegisterArgs): void;\n  };\n}\n\ntype DeepReadonly<T> = T extends (infer U)[]\n  ? readonly DeepReadonly<U>[]\n  : // Do not make functions readonly, since that leads to weird stuff like not\n    // being able to call `.catch()` on the returned promise.\n    T extends Function\n    ? T\n    : // Do not recurse into these types. If that happens, then the resulting\n      // type will not be compatible with the original type\n      T extends Date | RegExp | Error | Map<unknown, unknown> | Set<unknown>\n      ? Readonly<T>\n      : T extends object\n        ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n        : T;\n"],"mappings":";;;;CAgSS,MAAe,eAAe;EACnC,AAAS;EAqDT,YAAY,EAAE,UAAmC;AAC/C,QAAK,SAAS"}
+{"version":3,"file":"middleware.cjs","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":["import type { Jsonify } from \"../../helpers/jsonify.ts\";\nimport type { MaybePromise } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  EventPayload,\n  JsonError,\n  SendEventBaseOutput,\n  StepOptions,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { createStepTools } from \"../InngestStepTools.ts\";\nimport type { OpenStringUnion } from \"./types.ts\";\n\n/**\n * Namespace containing middleware-related types and base class.\n */\nexport namespace Middleware {\n  /**\n   * Base interface for output transformers. Extend this and override `Out` to\n   * create custom transformers. This is necessary because TypeScript doesn't\n   * support higher-kinded types.\n   *\n   * @example\n   * ```ts\n   * interface BooleanToStringTransform extends Middleware.StaticTransform {\n   *   Out: this[\"In\"] extends boolean ? string : this[\"In\"];\n   * }\n   * ```\n   */\n  export type StaticTransform = {\n    In: unknown;\n    Out: unknown;\n  };\n\n  /**\n   * Default transform. Applies the same transform as `JSON.stringify`.\n   */\n  export interface DefaultStaticTransform extends StaticTransform {\n    Out: Jsonify<this[\"In\"]>;\n  }\n\n  /**\n   * The step tools available to middleware for extending step functionality.\n   * This is the same type as `step` in the function handler context.\n   */\n  export type StepTools = ReturnType<typeof createStepTools<Inngest.Any>>;\n\n  /**\n   * The argument passed to `transformSendEvent`.\n   */\n  export type TransformSendEventArgs = {\n    events: EventPayload<Record<string, unknown>>[];\n    readonly fn: DeepReadonly<InngestFunction.Any> | null;\n  };\n\n  /**\n   * The argument passed to `transformStepInput`.\n   */\n  export type TransformStepInputArgs = {\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    readonly stepInfo: Readonly<\n      Pick<StepInfo, \"hashedId\" | \"memoized\" | \"stepType\">\n    >;\n    stepOptions: StepOptions;\n    input: unknown[];\n  };\n\n  /** The argument passed to `wrapStepHandler`. */\n  export type WrapStepHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * A single memoized step entry received in `transformFunctionInput`.\n   */\n  type MemoizedStep =\n    | { type: \"data\"; data: unknown }\n    | { type: \"error\"; error: JsonError }\n    | { type: \"input\"; input: unknown };\n\n  /**\n   * Memoized step state keyed by hashed step ID.\n   */\n  type MemoizedSteps = Record<string, MemoizedStep>;\n\n  /**\n   * The argument passed to `transformFunctionInput`.\n   */\n  export type TransformFunctionInputArgs = {\n    ctx: Context.Any;\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    steps: MemoizedSteps;\n  };\n\n  /**\n   * The argument passed to the static `onRegister` hook.\n   */\n  export type OnRegisterArgs = Readonly<{\n    client: Inngest.Any;\n    fn: InngestFunction.Any | null;\n  }>;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   */\n  export type Request = {\n    body: () => Promise<unknown>;\n    headers: Readonly<Record<string, string>>;\n    method: string;\n    url: URL;\n  };\n\n  /** The argument passed to `wrapFunctionHandler`. */\n  export type WrapFunctionHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n  }>;\n\n  /** The argument passed to `wrapRequest`. */\n  export type WrapRequestArgs = DeepReadonly<{\n    fn: InngestFunction.Any | null;\n    next: () => Promise<Response>;\n    requestArgs: readonly unknown[];\n    requestInfo: Request;\n    runId: string;\n  }>;\n\n  /** The argument passed to `wrapSendEvent`. */\n  export type WrapSendEventArgs = DeepReadonly<{\n    events: EventPayload<Record<string, unknown>>[];\n    fn: InngestFunction.Any | null;\n    next: () => Promise<SendEventBaseOutput>;\n  }>;\n\n  /** The argument passed to `wrapStep`. */\n  export type WrapStepArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The shape of the HTTP response returned by the middleware chain.\n   * This is what `next()` resolves with inside `wrapRequest`.\n   */\n  export type Response = {\n    body: string;\n    headers: Record<string, string>;\n    status: number;\n  };\n\n  /**\n   * The argument passed to `onMemoizationEnd`.\n   */\n  export type OnMemoizationEndArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onStepStart`.\n   */\n  export type OnStepStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepError`.\n   */\n  export type OnStepErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the step, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the step will be\n     * retried.\n     */\n    isFinalAttempt: boolean;\n\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepComplete`.\n   */\n  export type OnStepCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onRunStart`.\n   */\n  export type OnRunStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onRunComplete`.\n   */\n  export type OnRunCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n  }>;\n\n  /**\n   * The argument passed to `onRunError`.\n   */\n  export type OnRunErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the function, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the function will\n     * be retried.\n     */\n    isFinalAttempt: boolean;\n  }>;\n\n  /**\n   * The type of step. This union may be extended in the future, and will not be\n   * considered a breaking change.\n   */\n  export type StepType = OpenStringUnion<\n    | \"ai.infer\"\n    | \"ai.wrap\"\n    | \"fetch\"\n    | \"group.experiment\"\n    | \"invoke\"\n    | \"realtime.publish\"\n    | \"run\"\n    | \"sendEvent\"\n    | \"sleep\"\n    | \"waitForEvent\"\n    | \"waitForSignal\"\n  >;\n\n  export type StepInfo = {\n    /**\n     * Unique ID for the step. This is a hash of the user-defined step ID,\n     * including the implicit index if the user-defined ID is not unique.\n     */\n    hashedId: string;\n\n    /**\n     * The arguments passed to the step function, if any. For `step.run()`,\n     * these are the arguments after the id and handler function.\n     */\n    input?: unknown[];\n\n    /**\n     * Whether the step result is being retrieved from memoized state (true)\n     * or being executed fresh (false).\n     */\n    memoized: boolean;\n\n    /**\n     * Based on the first argument passed to the `step` method.\n     */\n    options: StepOptions;\n\n    stepType: StepType;\n  };\n\n  /**\n   * Base class for creating middleware. Extend this class to create custom\n   * middleware with hooks for step execution.\n   */\n  // @privateRemark\n  // Methods are nullish instead of noops as a performance optimization. This is\n  // primarily because of `wrapStep`. Each defined `wrapStep` method adds 1 more\n  // promise to the chain for each step. This chain runs every time the step\n  // completes/errors (even when memoized).\n  export abstract class BaseMiddleware {\n    readonly client: Inngest.Any;\n\n    /**\n     * Used to identify the middleware instance in logs. Uniqueness is not\n     * required, though using multiple middleware with the same ID in the same\n     * app may cause confusion when debugging.\n     */\n    abstract readonly id: string;\n\n    /**\n     * Declare this to statically specify how function return types are\n     * transformed. By default, the function return type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare functionOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare functionOutputTransform: DefaultStaticTransform;\n\n    /**\n     * Declare this to statically specify how step output types are transformed.\n     * By default, the step output type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare stepOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare stepOutputTransform: DefaultStaticTransform;\n\n    constructor({ client }: { client: Inngest.Any }) {\n      this.client = client;\n    }\n\n    /**\n     * Called when the middleware class is added to an Inngest client or Inngest\n     * function. Use this for one-time setup that needs a reference to the\n     * client instance (e.g. registering processors, setting feature flags).\n     *\n     * Do not mutate arguments.\n     */\n    static onRegister?(args: Middleware.OnRegisterArgs): void;\n\n    /**\n     * Called 1 time per request, after memoization completes.\n     *\n     * If all memoized steps have been resolved/rejected, then this hook calls.\n     * This is at the top of the function handler when there are 0 memoized\n     * steps.\n     *\n     * If a new step is found before resolving/rejecting all memoized steps,\n     * then this calls.\n     *\n     * Do not mutate arguments.\n     */\n    onMemoizationEnd?(arg: Middleware.OnMemoizationEndArgs): MaybePromise<void>;\n\n    /**\n     * Called when the run completes successfully. Does NOT call when the run\n     * errors: `onRunError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onRunComplete?(arg: Middleware.OnRunCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called when the function throws an error.\n     *\n     * Do not mutate arguments.\n     */\n    onRunError?(arg: Middleware.OnRunErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per run on the very first request (0 memoized steps,\n     * attempt 0). Does NOT call on subsequent requests where steps are being\n     * replayed.\n     *\n     * Do not mutate arguments.\n     */\n    onRunStart?(arg: Middleware.OnRunStartArgs): MaybePromise<void>;\n\n    /**\n     * Called when a step successfully completes. Only called for `step.run`\n     * and `step.sendEvent`. Never called for memoized step outputs. Does NOT\n     * call when the step errors: `onStepError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onStepComplete?(arg: Middleware.OnStepCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called each time a step errors. Only called for `step.run` and\n     * `step.sendEvent`. Never called for memoized errors.\n     *\n     * Do not mutate arguments.\n     */\n    onStepError?(arg: Middleware.OnStepErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per step before running its handler. Only called for\n     * `step.run` and `step.sendEvent`.\n     *\n     * Do not mutate arguments.\n     */\n    onStepStart?(arg: Middleware.OnStepStartArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per request (likely multiple times per run). Return the\n     * (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Dependency injection.\n     * - Deserialize events before passing it to the function handler.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because `wrapFunctionHandler` can't be used for the\n    // transformation's static type inference. For example, if the user added\n    // `ctx.db` in `wrapFunctionHandler` then the static types wouldn't show\n    // `ctx.db` in the function handler.\n    transformFunctionInput?(\n      arg: Middleware.TransformFunctionInputArgs,\n    ): MaybePromise<Middleware.TransformFunctionInputArgs>;\n\n    /**\n     * Called when sending events. This is either `step.sendEvent` or\n     * `client.send`. Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Serialize event data before sending it to the Inngest Server.\n     *\n     * Do not mutate arguments.\n     */\n    transformSendEvent?(\n      arg: Middleware.TransformSendEventArgs,\n    ): MaybePromise<Middleware.TransformSendEventArgs>;\n\n    /**\n     * Called 1 time per step per request (likely multiple times per step).\n     * Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Modify step options (e.g. the step ID).\n     * - Modify step input args.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // Step input transformation could happen in `wrapStep`, but we chose not to\n    // for the following reasons:\n    // 1. `wrapStep` may have a negative performance impact under certain\n    //    workloads.\n    // 2. `wrapStep` is a little more complicated to use.\n    // 3. Since `transformFunctionInput` must exist, having this hook\n    //    establishes a consistent pattern for input transformation.\n    transformStepInput?(\n      arg: TransformStepInputArgs,\n    ): MaybePromise<TransformStepInputArgs>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - AsyncLocalStorage context.\n     * - Function-level output/error transformation.\n     * - Prepend/append steps around the function handler.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * **Important:** `next()` only resolves when the function completes. On\n     * requests where a fresh step is discovered, control flow is interrupted\n     * and `next()` never resolves.\n     */\n    wrapFunctionHandler?(args: WrapFunctionHandlerArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - Custom auth.\n     * - Expose request data to the Inngest function handler.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapRequest?(args: WrapRequestArgs): Promise<Response>;\n\n    /**\n     * Called each time events are sent (either `client.send` or\n     * `step.sendEvent`).\n     *\n     * Use cases:\n     * - Backup events (e.g. blob store) when they fail to send.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapSendEvent?(args: WrapSendEventArgs): Promise<SendEventBaseOutput>;\n\n    /**\n     * Called 1 time per step per request. Called for all step kinds. Depending\n     * on your use case, you may want `wrapStepHandler` instead.\n     *\n     * Use cases:\n     * - Deserialize step output before returning it to the function handler.\n     * - Handle step failure errors (after exhausting retries).\n     * - Prepend/append steps around a step.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * NOTE: `next()` only resolves when the step completes/fails. On requests\n     * where a fresh step is discovered, control flow is interrupted and\n     * `next()` never resolves.\n     */\n    wrapStep?(args: WrapStepArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per step attempt. Wraps the step's handler. Only called for\n     * `step.run` and `step.sendEvent`. Use this to modify the handler's\n     * returned output or thrown error before it's sent to the Inngest Server.\n     *\n     * Use cases:\n     * - Serialize step output before sending it to the Inngest Server.\n     * - Handle step attempt errors (before exhausting retries).\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because of checkpointing. For serialization middleware\n    // to work with checkpointing, we need to both:\n    // 1. Serialize the step output before sending it to the Inngest Server.\n    // 2. Deserialize the step output before returning it to the function handler.\n    //\n    // We initially solved this by calling `wrapStep` twice per step per\n    // request. But this breaks the \"prepend with step\" logic since we'd\n    // encounter the prepended step twice; this caused us to run the prepended\n    // step twice.\n    //\n    // Now that we have `wrapStepHandler`, it can be responsible for\n    // serialization and `wrapStep` can be responsible for deserialization.\n    wrapStepHandler?(args: WrapStepHandlerArgs): Promise<unknown>;\n  }\n\n  /**\n   * A no-arg constructor for a BaseMiddleware subclass. Used in client and\n   * function options so that fresh instances are created per-request.\n   */\n  export type Class = (new (args: {\n    client: Inngest.Any;\n  }) => BaseMiddleware) & {\n    // Static methods aren't captured by `new () => ...`, so we repeat it here.\n    onRegister?(arg: OnRegisterArgs): void;\n  };\n}\n\ntype DeepReadonly<T> = T extends (infer U)[]\n  ? readonly DeepReadonly<U>[]\n  : // Do not make functions readonly, since that leads to weird stuff like not\n    // being able to call `.catch()` on the returned promise.\n    T extends Function\n    ? T\n    : // Do not recurse into these types. If that happens, then the resulting\n      // type will not be compatible with the original type\n      T extends Date | RegExp | Error | Map<unknown, unknown> | Set<unknown>\n      ? Readonly<T>\n      : T extends object\n        ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n        : T;\n"],"mappings":";;;;CAiSS,MAAe,eAAe;EACnC,AAAS;EAqDT,YAAY,EAAE,UAAmC;AAC/C,QAAK,SAAS"}

package/components/middleware/middleware.d.cts

@@ -211,7 +211,7 @@ declare namespace Middleware {
    * The type of step. This union may be extended in the future, and will not be
    * considered a breaking change.
    */
-  export type StepType = OpenStringUnion<"ai.infer" | "ai.wrap" | "fetch" | "group.experiment" | "invoke" | "realtime.publish" | "run" | "sendEvent" | "sleep" | "waitForEvent">;
+  export type StepType = OpenStringUnion<"ai.infer" | "ai.wrap" | "fetch" | "group.experiment" | "invoke" | "realtime.publish" | "run" | "sendEvent" | "sleep" | "waitForEvent" | "waitForSignal">;
   export type StepInfo = {
     /**
      * Unique ID for the step. This is a hash of the user-defined step ID,

package/components/middleware/middleware.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.cts","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"middleware.d.cts","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":[],"mappings":"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"}

package/components/middleware/middleware.d.ts

@@ -211,7 +211,7 @@ declare namespace Middleware {
    * The type of step. This union may be extended in the future, and will not be
    * considered a breaking change.
    */
-  export type StepType = OpenStringUnion<"ai.infer" | "ai.wrap" | "fetch" | "group.experiment" | "invoke" | "realtime.publish" | "run" | "sendEvent" | "sleep" | "waitForEvent">;
+  export type StepType = OpenStringUnion<"ai.infer" | "ai.wrap" | "fetch" | "group.experiment" | "invoke" | "realtime.publish" | "run" | "sendEvent" | "sleep" | "waitForEvent" | "waitForSignal">;
   export type StepInfo = {
     /**
      * Unique ID for the step. This is a hash of the user-defined step ID,

package/components/middleware/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":[],"mappings":"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"}

package/components/middleware/middleware.js.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.js","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":["import type { Jsonify } from \"../../helpers/jsonify.ts\";\nimport type { MaybePromise } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  EventPayload,\n  JsonError,\n  SendEventBaseOutput,\n  StepOptions,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { createStepTools } from \"../InngestStepTools.ts\";\nimport type { OpenStringUnion } from \"./types.ts\";\n\n/**\n * Namespace containing middleware-related types and base class.\n */\nexport namespace Middleware {\n  /**\n   * Base interface for output transformers. Extend this and override `Out` to\n   * create custom transformers. This is necessary because TypeScript doesn't\n   * support higher-kinded types.\n   *\n   * @example\n   * ```ts\n   * interface BooleanToStringTransform extends Middleware.StaticTransform {\n   *   Out: this[\"In\"] extends boolean ? string : this[\"In\"];\n   * }\n   * ```\n   */\n  export type StaticTransform = {\n    In: unknown;\n    Out: unknown;\n  };\n\n  /**\n   * Default transform. Applies the same transform as `JSON.stringify`.\n   */\n  export interface DefaultStaticTransform extends StaticTransform {\n    Out: Jsonify<this[\"In\"]>;\n  }\n\n  /**\n   * The step tools available to middleware for extending step functionality.\n   * This is the same type as `step` in the function handler context.\n   */\n  export type StepTools = ReturnType<typeof createStepTools<Inngest.Any>>;\n\n  /**\n   * The argument passed to `transformSendEvent`.\n   */\n  export type TransformSendEventArgs = {\n    events: EventPayload<Record<string, unknown>>[];\n    readonly fn: DeepReadonly<InngestFunction.Any> | null;\n  };\n\n  /**\n   * The argument passed to `transformStepInput`.\n   */\n  export type TransformStepInputArgs = {\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    readonly stepInfo: Readonly<\n      Pick<StepInfo, \"hashedId\" | \"memoized\" | \"stepType\">\n    >;\n    stepOptions: StepOptions;\n    input: unknown[];\n  };\n\n  /** The argument passed to `wrapStepHandler`. */\n  export type WrapStepHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * A single memoized step entry received in `transformFunctionInput`.\n   */\n  type MemoizedStep =\n    | { type: \"data\"; data: unknown }\n    | { type: \"error\"; error: JsonError }\n    | { type: \"input\"; input: unknown };\n\n  /**\n   * Memoized step state keyed by hashed step ID.\n   */\n  type MemoizedSteps = Record<string, MemoizedStep>;\n\n  /**\n   * The argument passed to `transformFunctionInput`.\n   */\n  export type TransformFunctionInputArgs = {\n    ctx: Context.Any;\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    steps: MemoizedSteps;\n  };\n\n  /**\n   * The argument passed to the static `onRegister` hook.\n   */\n  export type OnRegisterArgs = Readonly<{\n    client: Inngest.Any;\n    fn: InngestFunction.Any | null;\n  }>;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   */\n  export type Request = {\n    body: () => Promise<unknown>;\n    headers: Readonly<Record<string, string>>;\n    method: string;\n    url: URL;\n  };\n\n  /** The argument passed to `wrapFunctionHandler`. */\n  export type WrapFunctionHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n  }>;\n\n  /** The argument passed to `wrapRequest`. */\n  export type WrapRequestArgs = DeepReadonly<{\n    fn: InngestFunction.Any | null;\n    next: () => Promise<Response>;\n    requestArgs: readonly unknown[];\n    requestInfo: Request;\n    runId: string;\n  }>;\n\n  /** The argument passed to `wrapSendEvent`. */\n  export type WrapSendEventArgs = DeepReadonly<{\n    events: EventPayload<Record<string, unknown>>[];\n    fn: InngestFunction.Any | null;\n    next: () => Promise<SendEventBaseOutput>;\n  }>;\n\n  /** The argument passed to `wrapStep`. */\n  export type WrapStepArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The shape of the HTTP response returned by the middleware chain.\n   * This is what `next()` resolves with inside `wrapRequest`.\n   */\n  export type Response = {\n    body: string;\n    headers: Record<string, string>;\n    status: number;\n  };\n\n  /**\n   * The argument passed to `onMemoizationEnd`.\n   */\n  export type OnMemoizationEndArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onStepStart`.\n   */\n  export type OnStepStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepError`.\n   */\n  export type OnStepErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the step, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the step will be\n     * retried.\n     */\n    isFinalAttempt: boolean;\n\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepComplete`.\n   */\n  export type OnStepCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onRunStart`.\n   */\n  export type OnRunStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onRunComplete`.\n   */\n  export type OnRunCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n  }>;\n\n  /**\n   * The argument passed to `onRunError`.\n   */\n  export type OnRunErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the function, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the function will\n     * be retried.\n     */\n    isFinalAttempt: boolean;\n  }>;\n\n  /**\n   * The type of step. This union may be extended in the future, and will not be\n   * considered a breaking change.\n   */\n  export type StepType = OpenStringUnion<\n    | \"ai.infer\"\n    | \"ai.wrap\"\n    | \"fetch\"\n    | \"group.experiment\"\n    | \"invoke\"\n    | \"realtime.publish\"\n    | \"run\"\n    | \"sendEvent\"\n    | \"sleep\"\n    | \"waitForEvent\"\n  >;\n\n  export type StepInfo = {\n    /**\n     * Unique ID for the step. This is a hash of the user-defined step ID,\n     * including the implicit index if the user-defined ID is not unique.\n     */\n    hashedId: string;\n\n    /**\n     * The arguments passed to the step function, if any. For `step.run()`,\n     * these are the arguments after the id and handler function.\n     */\n    input?: unknown[];\n\n    /**\n     * Whether the step result is being retrieved from memoized state (true)\n     * or being executed fresh (false).\n     */\n    memoized: boolean;\n\n    /**\n     * Based on the first argument passed to the `step` method.\n     */\n    options: StepOptions;\n\n    stepType: StepType;\n  };\n\n  /**\n   * Base class for creating middleware. Extend this class to create custom\n   * middleware with hooks for step execution.\n   */\n  // @privateRemark\n  // Methods are nullish instead of noops as a performance optimization. This is\n  // primarily because of `wrapStep`. Each defined `wrapStep` method adds 1 more\n  // promise to the chain for each step. This chain runs every time the step\n  // completes/errors (even when memoized).\n  export abstract class BaseMiddleware {\n    readonly client: Inngest.Any;\n\n    /**\n     * Used to identify the middleware instance in logs. Uniqueness is not\n     * required, though using multiple middleware with the same ID in the same\n     * app may cause confusion when debugging.\n     */\n    abstract readonly id: string;\n\n    /**\n     * Declare this to statically specify how function return types are\n     * transformed. By default, the function return type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare functionOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare functionOutputTransform: DefaultStaticTransform;\n\n    /**\n     * Declare this to statically specify how step output types are transformed.\n     * By default, the step output type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare stepOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare stepOutputTransform: DefaultStaticTransform;\n\n    constructor({ client }: { client: Inngest.Any }) {\n      this.client = client;\n    }\n\n    /**\n     * Called when the middleware class is added to an Inngest client or Inngest\n     * function. Use this for one-time setup that needs a reference to the\n     * client instance (e.g. registering processors, setting feature flags).\n     *\n     * Do not mutate arguments.\n     */\n    static onRegister?(args: Middleware.OnRegisterArgs): void;\n\n    /**\n     * Called 1 time per request, after memoization completes.\n     *\n     * If all memoized steps have been resolved/rejected, then this hook calls.\n     * This is at the top of the function handler when there are 0 memoized\n     * steps.\n     *\n     * If a new step is found before resolving/rejecting all memoized steps,\n     * then this calls.\n     *\n     * Do not mutate arguments.\n     */\n    onMemoizationEnd?(arg: Middleware.OnMemoizationEndArgs): MaybePromise<void>;\n\n    /**\n     * Called when the run completes successfully. Does NOT call when the run\n     * errors: `onRunError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onRunComplete?(arg: Middleware.OnRunCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called when the function throws an error.\n     *\n     * Do not mutate arguments.\n     */\n    onRunError?(arg: Middleware.OnRunErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per run on the very first request (0 memoized steps,\n     * attempt 0). Does NOT call on subsequent requests where steps are being\n     * replayed.\n     *\n     * Do not mutate arguments.\n     */\n    onRunStart?(arg: Middleware.OnRunStartArgs): MaybePromise<void>;\n\n    /**\n     * Called when a step successfully completes. Only called for `step.run`\n     * and `step.sendEvent`. Never called for memoized step outputs. Does NOT\n     * call when the step errors: `onStepError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onStepComplete?(arg: Middleware.OnStepCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called each time a step errors. Only called for `step.run` and\n     * `step.sendEvent`. Never called for memoized errors.\n     *\n     * Do not mutate arguments.\n     */\n    onStepError?(arg: Middleware.OnStepErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per step before running its handler. Only called for\n     * `step.run` and `step.sendEvent`.\n     *\n     * Do not mutate arguments.\n     */\n    onStepStart?(arg: Middleware.OnStepStartArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per request (likely multiple times per run). Return the\n     * (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Dependency injection.\n     * - Deserialize events before passing it to the function handler.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because `wrapFunctionHandler` can't be used for the\n    // transformation's static type inference. For example, if the user added\n    // `ctx.db` in `wrapFunctionHandler` then the static types wouldn't show\n    // `ctx.db` in the function handler.\n    transformFunctionInput?(\n      arg: Middleware.TransformFunctionInputArgs,\n    ): MaybePromise<Middleware.TransformFunctionInputArgs>;\n\n    /**\n     * Called when sending events. This is either `step.sendEvent` or\n     * `client.send`. Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Serialize event data before sending it to the Inngest Server.\n     *\n     * Do not mutate arguments.\n     */\n    transformSendEvent?(\n      arg: Middleware.TransformSendEventArgs,\n    ): MaybePromise<Middleware.TransformSendEventArgs>;\n\n    /**\n     * Called 1 time per step per request (likely multiple times per step).\n     * Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Modify step options (e.g. the step ID).\n     * - Modify step input args.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // Step input transformation could happen in `wrapStep`, but we chose not to\n    // for the following reasons:\n    // 1. `wrapStep` may have a negative performance impact under certain\n    //    workloads.\n    // 2. `wrapStep` is a little more complicated to use.\n    // 3. Since `transformFunctionInput` must exist, having this hook\n    //    establishes a consistent pattern for input transformation.\n    transformStepInput?(\n      arg: TransformStepInputArgs,\n    ): MaybePromise<TransformStepInputArgs>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - AsyncLocalStorage context.\n     * - Function-level output/error transformation.\n     * - Prepend/append steps around the function handler.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * **Important:** `next()` only resolves when the function completes. On\n     * requests where a fresh step is discovered, control flow is interrupted\n     * and `next()` never resolves.\n     */\n    wrapFunctionHandler?(args: WrapFunctionHandlerArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - Custom auth.\n     * - Expose request data to the Inngest function handler.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapRequest?(args: WrapRequestArgs): Promise<Response>;\n\n    /**\n     * Called each time events are sent (either `client.send` or\n     * `step.sendEvent`).\n     *\n     * Use cases:\n     * - Backup events (e.g. blob store) when they fail to send.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapSendEvent?(args: WrapSendEventArgs): Promise<SendEventBaseOutput>;\n\n    /**\n     * Called 1 time per step per request. Called for all step kinds. Depending\n     * on your use case, you may want `wrapStepHandler` instead.\n     *\n     * Use cases:\n     * - Deserialize step output before returning it to the function handler.\n     * - Handle step failure errors (after exhausting retries).\n     * - Prepend/append steps around a step.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * NOTE: `next()` only resolves when the step completes/fails. On requests\n     * where a fresh step is discovered, control flow is interrupted and\n     * `next()` never resolves.\n     */\n    wrapStep?(args: WrapStepArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per step attempt. Wraps the step's handler. Only called for\n     * `step.run` and `step.sendEvent`. Use this to modify the handler's\n     * returned output or thrown error before it's sent to the Inngest Server.\n     *\n     * Use cases:\n     * - Serialize step output before sending it to the Inngest Server.\n     * - Handle step attempt errors (before exhausting retries).\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because of checkpointing. For serialization middleware\n    // to work with checkpointing, we need to both:\n    // 1. Serialize the step output before sending it to the Inngest Server.\n    // 2. Deserialize the step output before returning it to the function handler.\n    //\n    // We initially solved this by calling `wrapStep` twice per step per\n    // request. But this breaks the \"prepend with step\" logic since we'd\n    // encounter the prepended step twice; this caused us to run the prepended\n    // step twice.\n    //\n    // Now that we have `wrapStepHandler`, it can be responsible for\n    // serialization and `wrapStep` can be responsible for deserialization.\n    wrapStepHandler?(args: WrapStepHandlerArgs): Promise<unknown>;\n  }\n\n  /**\n   * A no-arg constructor for a BaseMiddleware subclass. Used in client and\n   * function options so that fresh instances are created per-request.\n   */\n  export type Class = (new (args: {\n    client: Inngest.Any;\n  }) => BaseMiddleware) & {\n    // Static methods aren't captured by `new () => ...`, so we repeat it here.\n    onRegister?(arg: OnRegisterArgs): void;\n  };\n}\n\ntype DeepReadonly<T> = T extends (infer U)[]\n  ? readonly DeepReadonly<U>[]\n  : // Do not make functions readonly, since that leads to weird stuff like not\n    // being able to call `.catch()` on the returned promise.\n    T extends Function\n    ? T\n    : // Do not recurse into these types. If that happens, then the resulting\n      // type will not be compatible with the original type\n      T extends Date | RegExp | Error | Map<unknown, unknown> | Set<unknown>\n      ? Readonly<T>\n      : T extends object\n        ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n        : T;\n"],"mappings":";;;CAgSS,MAAe,eAAe;EACnC,AAAS;EAqDT,YAAY,EAAE,UAAmC;AAC/C,QAAK,SAAS"}
+{"version":3,"file":"middleware.js","names":[],"sources":["../../../src/components/middleware/middleware.ts"],"sourcesContent":["import type { Jsonify } from \"../../helpers/jsonify.ts\";\nimport type { MaybePromise } from \"../../helpers/types.ts\";\nimport type {\n  Context,\n  EventPayload,\n  JsonError,\n  SendEventBaseOutput,\n  StepOptions,\n} from \"../../types.ts\";\nimport type { Inngest } from \"../Inngest.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { createStepTools } from \"../InngestStepTools.ts\";\nimport type { OpenStringUnion } from \"./types.ts\";\n\n/**\n * Namespace containing middleware-related types and base class.\n */\nexport namespace Middleware {\n  /**\n   * Base interface for output transformers. Extend this and override `Out` to\n   * create custom transformers. This is necessary because TypeScript doesn't\n   * support higher-kinded types.\n   *\n   * @example\n   * ```ts\n   * interface BooleanToStringTransform extends Middleware.StaticTransform {\n   *   Out: this[\"In\"] extends boolean ? string : this[\"In\"];\n   * }\n   * ```\n   */\n  export type StaticTransform = {\n    In: unknown;\n    Out: unknown;\n  };\n\n  /**\n   * Default transform. Applies the same transform as `JSON.stringify`.\n   */\n  export interface DefaultStaticTransform extends StaticTransform {\n    Out: Jsonify<this[\"In\"]>;\n  }\n\n  /**\n   * The step tools available to middleware for extending step functionality.\n   * This is the same type as `step` in the function handler context.\n   */\n  export type StepTools = ReturnType<typeof createStepTools<Inngest.Any>>;\n\n  /**\n   * The argument passed to `transformSendEvent`.\n   */\n  export type TransformSendEventArgs = {\n    events: EventPayload<Record<string, unknown>>[];\n    readonly fn: DeepReadonly<InngestFunction.Any> | null;\n  };\n\n  /**\n   * The argument passed to `transformStepInput`.\n   */\n  export type TransformStepInputArgs = {\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    readonly stepInfo: Readonly<\n      Pick<StepInfo, \"hashedId\" | \"memoized\" | \"stepType\">\n    >;\n    stepOptions: StepOptions;\n    input: unknown[];\n  };\n\n  /** The argument passed to `wrapStepHandler`. */\n  export type WrapStepHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * A single memoized step entry received in `transformFunctionInput`.\n   */\n  type MemoizedStep =\n    | { type: \"data\"; data: unknown }\n    | { type: \"error\"; error: JsonError }\n    | { type: \"input\"; input: unknown };\n\n  /**\n   * Memoized step state keyed by hashed step ID.\n   */\n  type MemoizedSteps = Record<string, MemoizedStep>;\n\n  /**\n   * The argument passed to `transformFunctionInput`.\n   */\n  export type TransformFunctionInputArgs = {\n    ctx: Context.Any;\n    readonly fn: DeepReadonly<InngestFunction.Any>;\n    steps: MemoizedSteps;\n  };\n\n  /**\n   * The argument passed to the static `onRegister` hook.\n   */\n  export type OnRegisterArgs = Readonly<{\n    client: Inngest.Any;\n    fn: InngestFunction.Any | null;\n  }>;\n\n  /**\n   * Information about the incoming HTTP request that triggered this execution.\n   */\n  export type Request = {\n    body: () => Promise<unknown>;\n    headers: Readonly<Record<string, string>>;\n    method: string;\n    url: URL;\n  };\n\n  /** The argument passed to `wrapFunctionHandler`. */\n  export type WrapFunctionHandlerArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n  }>;\n\n  /** The argument passed to `wrapRequest`. */\n  export type WrapRequestArgs = DeepReadonly<{\n    fn: InngestFunction.Any | null;\n    next: () => Promise<Response>;\n    requestArgs: readonly unknown[];\n    requestInfo: Request;\n    runId: string;\n  }>;\n\n  /** The argument passed to `wrapSendEvent`. */\n  export type WrapSendEventArgs = DeepReadonly<{\n    events: EventPayload<Record<string, unknown>>[];\n    fn: InngestFunction.Any | null;\n    next: () => Promise<SendEventBaseOutput>;\n  }>;\n\n  /** The argument passed to `wrapStep`. */\n  export type WrapStepArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    next: () => Promise<unknown>;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The shape of the HTTP response returned by the middleware chain.\n   * This is what `next()` resolves with inside `wrapRequest`.\n   */\n  export type Response = {\n    body: string;\n    headers: Record<string, string>;\n    status: number;\n  };\n\n  /**\n   * The argument passed to `onMemoizationEnd`.\n   */\n  export type OnMemoizationEndArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onStepStart`.\n   */\n  export type OnStepStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepError`.\n   */\n  export type OnStepErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the step, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the step will be\n     * retried.\n     */\n    isFinalAttempt: boolean;\n\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onStepComplete`.\n   */\n  export type OnStepCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n    stepInfo: StepInfo;\n  }>;\n\n  /**\n   * The argument passed to `onRunStart`.\n   */\n  export type OnRunStartArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n  }>;\n\n  /**\n   * The argument passed to `onRunComplete`.\n   */\n  export type OnRunCompleteArgs = DeepReadonly<{\n    ctx: Context.Any;\n    fn: InngestFunction.Any;\n    output: unknown;\n  }>;\n\n  /**\n   * The argument passed to `onRunError`.\n   */\n  export type OnRunErrorArgs = DeepReadonly<{\n    ctx: Context.Any;\n    error: Error;\n    fn: InngestFunction.Any;\n\n    /**\n     * Whether this is the final attempt for the function, meaning retries are\n     * exhausted or the error is non-retriable. When `false`, the function will\n     * be retried.\n     */\n    isFinalAttempt: boolean;\n  }>;\n\n  /**\n   * The type of step. This union may be extended in the future, and will not be\n   * considered a breaking change.\n   */\n  export type StepType = OpenStringUnion<\n    | \"ai.infer\"\n    | \"ai.wrap\"\n    | \"fetch\"\n    | \"group.experiment\"\n    | \"invoke\"\n    | \"realtime.publish\"\n    | \"run\"\n    | \"sendEvent\"\n    | \"sleep\"\n    | \"waitForEvent\"\n    | \"waitForSignal\"\n  >;\n\n  export type StepInfo = {\n    /**\n     * Unique ID for the step. This is a hash of the user-defined step ID,\n     * including the implicit index if the user-defined ID is not unique.\n     */\n    hashedId: string;\n\n    /**\n     * The arguments passed to the step function, if any. For `step.run()`,\n     * these are the arguments after the id and handler function.\n     */\n    input?: unknown[];\n\n    /**\n     * Whether the step result is being retrieved from memoized state (true)\n     * or being executed fresh (false).\n     */\n    memoized: boolean;\n\n    /**\n     * Based on the first argument passed to the `step` method.\n     */\n    options: StepOptions;\n\n    stepType: StepType;\n  };\n\n  /**\n   * Base class for creating middleware. Extend this class to create custom\n   * middleware with hooks for step execution.\n   */\n  // @privateRemark\n  // Methods are nullish instead of noops as a performance optimization. This is\n  // primarily because of `wrapStep`. Each defined `wrapStep` method adds 1 more\n  // promise to the chain for each step. This chain runs every time the step\n  // completes/errors (even when memoized).\n  export abstract class BaseMiddleware {\n    readonly client: Inngest.Any;\n\n    /**\n     * Used to identify the middleware instance in logs. Uniqueness is not\n     * required, though using multiple middleware with the same ID in the same\n     * app may cause confusion when debugging.\n     */\n    abstract readonly id: string;\n\n    /**\n     * Declare this to statically specify how function return types are\n     * transformed. By default, the function return type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare functionOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare functionOutputTransform: DefaultStaticTransform;\n\n    /**\n     * Declare this to statically specify how step output types are transformed.\n     * By default, the step output type is Jsonified.\n     *\n     * Must match the same structure as `StaticTransform` to imitate\n     * higher-kinded types.\n     *\n     * @example\n     * ```ts\n     * interface PreserveDate extends Middleware.StaticTransform {\n     *   Out: this[\"In\"] extends Date ? Date : Jsonify<this[\"In\"]>;\n     * }\n     *\n     * class MyMiddleware extends Middleware.BaseMiddleware {\n     *   declare stepOutputTransform: PreserveDate;\n     * }\n     * ```\n     *\n     * @default Middleware.DefaultStaticTransform (e.g. Date -> string)\n     */\n    declare stepOutputTransform: DefaultStaticTransform;\n\n    constructor({ client }: { client: Inngest.Any }) {\n      this.client = client;\n    }\n\n    /**\n     * Called when the middleware class is added to an Inngest client or Inngest\n     * function. Use this for one-time setup that needs a reference to the\n     * client instance (e.g. registering processors, setting feature flags).\n     *\n     * Do not mutate arguments.\n     */\n    static onRegister?(args: Middleware.OnRegisterArgs): void;\n\n    /**\n     * Called 1 time per request, after memoization completes.\n     *\n     * If all memoized steps have been resolved/rejected, then this hook calls.\n     * This is at the top of the function handler when there are 0 memoized\n     * steps.\n     *\n     * If a new step is found before resolving/rejecting all memoized steps,\n     * then this calls.\n     *\n     * Do not mutate arguments.\n     */\n    onMemoizationEnd?(arg: Middleware.OnMemoizationEndArgs): MaybePromise<void>;\n\n    /**\n     * Called when the run completes successfully. Does NOT call when the run\n     * errors: `onRunError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onRunComplete?(arg: Middleware.OnRunCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called when the function throws an error.\n     *\n     * Do not mutate arguments.\n     */\n    onRunError?(arg: Middleware.OnRunErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per run on the very first request (0 memoized steps,\n     * attempt 0). Does NOT call on subsequent requests where steps are being\n     * replayed.\n     *\n     * Do not mutate arguments.\n     */\n    onRunStart?(arg: Middleware.OnRunStartArgs): MaybePromise<void>;\n\n    /**\n     * Called when a step successfully completes. Only called for `step.run`\n     * and `step.sendEvent`. Never called for memoized step outputs. Does NOT\n     * call when the step errors: `onStepError` calls instead.\n     *\n     * Do not mutate arguments.\n     */\n    onStepComplete?(arg: Middleware.OnStepCompleteArgs): MaybePromise<void>;\n\n    /**\n     * Called each time a step errors. Only called for `step.run` and\n     * `step.sendEvent`. Never called for memoized errors.\n     *\n     * Do not mutate arguments.\n     */\n    onStepError?(arg: Middleware.OnStepErrorArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per step before running its handler. Only called for\n     * `step.run` and `step.sendEvent`.\n     *\n     * Do not mutate arguments.\n     */\n    onStepStart?(arg: Middleware.OnStepStartArgs): MaybePromise<void>;\n\n    /**\n     * Called 1 time per request (likely multiple times per run). Return the\n     * (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Dependency injection.\n     * - Deserialize events before passing it to the function handler.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because `wrapFunctionHandler` can't be used for the\n    // transformation's static type inference. For example, if the user added\n    // `ctx.db` in `wrapFunctionHandler` then the static types wouldn't show\n    // `ctx.db` in the function handler.\n    transformFunctionInput?(\n      arg: Middleware.TransformFunctionInputArgs,\n    ): MaybePromise<Middleware.TransformFunctionInputArgs>;\n\n    /**\n     * Called when sending events. This is either `step.sendEvent` or\n     * `client.send`. Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Serialize event data before sending it to the Inngest Server.\n     *\n     * Do not mutate arguments.\n     */\n    transformSendEvent?(\n      arg: Middleware.TransformSendEventArgs,\n    ): MaybePromise<Middleware.TransformSendEventArgs>;\n\n    /**\n     * Called 1 time per step per request (likely multiple times per step).\n     * Return the (potentially modified) arg object.\n     *\n     * Use cases:\n     * - Modify step options (e.g. the step ID).\n     * - Modify step input args.\n     *\n     * Do not mutate arguments.\n     */\n    // @privateRemark\n    // Step input transformation could happen in `wrapStep`, but we chose not to\n    // for the following reasons:\n    // 1. `wrapStep` may have a negative performance impact under certain\n    //    workloads.\n    // 2. `wrapStep` is a little more complicated to use.\n    // 3. Since `transformFunctionInput` must exist, having this hook\n    //    establishes a consistent pattern for input transformation.\n    transformStepInput?(\n      arg: TransformStepInputArgs,\n    ): MaybePromise<TransformStepInputArgs>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - AsyncLocalStorage context.\n     * - Function-level output/error transformation.\n     * - Prepend/append steps around the function handler.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * **Important:** `next()` only resolves when the function completes. On\n     * requests where a fresh step is discovered, control flow is interrupted\n     * and `next()` never resolves.\n     */\n    wrapFunctionHandler?(args: WrapFunctionHandlerArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per request.\n     *\n     * Use cases:\n     * - Custom auth.\n     * - Expose request data to the Inngest function handler.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapRequest?(args: WrapRequestArgs): Promise<Response>;\n\n    /**\n     * Called each time events are sent (either `client.send` or\n     * `step.sendEvent`).\n     *\n     * Use cases:\n     * - Backup events (e.g. blob store) when they fail to send.\n     * - Metrics.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    wrapSendEvent?(args: WrapSendEventArgs): Promise<SendEventBaseOutput>;\n\n    /**\n     * Called 1 time per step per request. Called for all step kinds. Depending\n     * on your use case, you may want `wrapStepHandler` instead.\n     *\n     * Use cases:\n     * - Deserialize step output before returning it to the function handler.\n     * - Handle step failure errors (after exhausting retries).\n     * - Prepend/append steps around a step.\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     *\n     * NOTE: `next()` only resolves when the step completes/fails. On requests\n     * where a fresh step is discovered, control flow is interrupted and\n     * `next()` never resolves.\n     */\n    wrapStep?(args: WrapStepArgs): Promise<unknown>;\n\n    /**\n     * Called 1 time per step attempt. Wraps the step's handler. Only called for\n     * `step.run` and `step.sendEvent`. Use this to modify the handler's\n     * returned output or thrown error before it's sent to the Inngest Server.\n     *\n     * Use cases:\n     * - Serialize step output before sending it to the Inngest Server.\n     * - Handle step attempt errors (before exhausting retries).\n     *\n     * Must call `next()` to continue processing. Do not mutate arguments.\n     */\n    // @privateRemark\n    // This hook exists because of checkpointing. For serialization middleware\n    // to work with checkpointing, we need to both:\n    // 1. Serialize the step output before sending it to the Inngest Server.\n    // 2. Deserialize the step output before returning it to the function handler.\n    //\n    // We initially solved this by calling `wrapStep` twice per step per\n    // request. But this breaks the \"prepend with step\" logic since we'd\n    // encounter the prepended step twice; this caused us to run the prepended\n    // step twice.\n    //\n    // Now that we have `wrapStepHandler`, it can be responsible for\n    // serialization and `wrapStep` can be responsible for deserialization.\n    wrapStepHandler?(args: WrapStepHandlerArgs): Promise<unknown>;\n  }\n\n  /**\n   * A no-arg constructor for a BaseMiddleware subclass. Used in client and\n   * function options so that fresh instances are created per-request.\n   */\n  export type Class = (new (args: {\n    client: Inngest.Any;\n  }) => BaseMiddleware) & {\n    // Static methods aren't captured by `new () => ...`, so we repeat it here.\n    onRegister?(arg: OnRegisterArgs): void;\n  };\n}\n\ntype DeepReadonly<T> = T extends (infer U)[]\n  ? readonly DeepReadonly<U>[]\n  : // Do not make functions readonly, since that leads to weird stuff like not\n    // being able to call `.catch()` on the returned promise.\n    T extends Function\n    ? T\n    : // Do not recurse into these types. If that happens, then the resulting\n      // type will not be compatible with the original type\n      T extends Date | RegExp | Error | Map<unknown, unknown> | Set<unknown>\n      ? Readonly<T>\n      : T extends object\n        ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n        : T;\n"],"mappings":";;;CAiSS,MAAe,eAAe;EACnC,AAAS;EAqDT,YAAY,EAAE,UAAmC;AAC/C,QAAK,SAAS"}

package/components/middleware/utils.cjs

@@ -66,6 +66,7 @@ function stepTypeFromOpCode(op, opts, logger) {
 		if (opts?.type === "group.experiment") return "group.experiment";
 	} else if (op === require_types.StepOpCode.Sleep) return "sleep";
 	else if (op === require_types.StepOpCode.WaitForEvent) return "waitForEvent";
+	else if (op === require_types.StepOpCode.WaitForSignal) return "waitForSignal";
 	logger.warn({
 		op,
 		type: opts?.type