inngest 4.2.6 → 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";
@@ -76,7 +76,7 @@ declare const extendedTracesMiddleware: ({
           sendEvent: (idOrOptions: StepOptionsOrId, payload: SendEventPayload) => Promise<SendEventOutput<ClientOptions>>;
           waitForSignal: <TData>(idOrOptions: StepOptionsOrId, opts: {
             signal: string;
-            timeout: number | string | Date;
+            timeout: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
             onConflict: "replace" | "fail";
           }) => Promise<{
             signal: string;
@@ -91,7 +91,7 @@ declare const extendedTracesMiddleware: ({
           }) => Promise<InngestApi.SendSignalResponse>;
           waitForEvent: <TOpts extends {
             event: string | EventType<string, any>;
-            timeout: number | string | Date;
+            timeout: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
           } & ExclusiveKeys<{
             match?: string;
             if?: string;
@@ -149,12 +149,15 @@ declare const extendedTracesMiddleware: ({
           invoke: <TFunction extends InvokeTargetFunctionDefinition>(idOrOptions: StepOptionsOrId, opts: {
             function: TFunction;
           } & Omit<TriggerEventFromFunction<TFunction>, "id"> & {
-            timeout?: number | string | Date;
+            timeout?: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
           }) => 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;
@@ -234,7 +237,13 @@ declare const extendedTracesMiddleware: ({
             };
             readonly if?: string | undefined;
             readonly match?: string | undefined;
-            readonly timeout?: string | number | Readonly<Date> | undefined;
+            readonly timeout?: string | number | Readonly<Date> | {
+              readonly [Symbol.toStringTag]: "Temporal.Duration";
+            } | {
+              readonly [Symbol.toStringTag]: "Temporal.Instant";
+            } | {
+              readonly [Symbol.toStringTag]: "Temporal.ZonedDateTime";
+            } | undefined;
           }[] | undefined;
           readonly retries?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | undefined;
           readonly onFailure?: any;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAWI,CAAA,GAAA,SAAA;UAAe,SAAA,SAAA,CAAA,EAAA;YAAA,SAAA,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UApCb,SAAA,mBAAA,CAAA,EAAA,OAAA,GAAA,SAAA;UAAc,SAAA,yBAAA,CAAA,EAAA,OAAA,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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";
@@ -76,7 +76,7 @@ declare const extendedTracesMiddleware: ({
           sendEvent: (idOrOptions: StepOptionsOrId, payload: SendEventPayload) => Promise<SendEventOutput<ClientOptions>>;
           waitForSignal: <TData>(idOrOptions: StepOptionsOrId, opts: {
             signal: string;
-            timeout: number | string | Date;
+            timeout: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
             onConflict: "replace" | "fail";
           }) => Promise<{
             signal: string;
@@ -91,7 +91,7 @@ declare const extendedTracesMiddleware: ({
           }) => Promise<InngestApi.SendSignalResponse>;
           waitForEvent: <TOpts extends {
             event: string | EventType<string, any>;
-            timeout: number | string | Date;
+            timeout: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
           } & ExclusiveKeys<{
             match?: string;
             if?: string;
@@ -149,12 +149,15 @@ declare const extendedTracesMiddleware: ({
           invoke: <TFunction extends InvokeTargetFunctionDefinition>(idOrOptions: StepOptionsOrId, opts: {
             function: TFunction;
           } & Omit<TriggerEventFromFunction<TFunction>, "id"> & {
-            timeout?: number | string | Date;
+            timeout?: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
           }) => 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;
@@ -234,7 +237,13 @@ declare const extendedTracesMiddleware: ({
             };
             readonly if?: string | undefined;
             readonly match?: string | undefined;
-            readonly timeout?: string | number | Readonly<Date> | undefined;
+            readonly timeout?: string | number | Readonly<Date> | {
+              readonly [Symbol.toStringTag]: "Temporal.Duration";
+            } | {
+              readonly [Symbol.toStringTag]: "Temporal.Instant";
+            } | {
+              readonly [Symbol.toStringTag]: "Temporal.ZonedDateTime";
+            } | undefined;
           }[] | undefined;
           readonly retries?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | undefined;
           readonly onFailure?: any;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAWI,CAAA,GAAA,SAAA;UAAe,SAAA,SAAA,CAAA,EAAA;YAAA,SAAA,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UApCb,SAAA,mBAAA,CAAA,EAAA,OAAA,GAAA,SAAA;UAAc,SAAA,yBAAA,CAAA,EAAA,OAAA,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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/manager.cjs

@@ -64,7 +64,7 @@ var MiddlewareManager = class {
 		}
 		let opName;
 		if (stepType === "sleep" && stepInfo.input !== void 0) {
-			if (!require_utils.isTimeStrInput(stepInfo.input[0])) throw new Error("Sleep time must be a string, number, or Date");
+			if (!require_utils.isSleepInput(stepInfo.input[0])) throw new Error("Sleep time must be a string, number, Date, or Temporal.Duration");
 			opName = require_strings.timeStr(stepInfo.input[0]);
 		}
 		const opOpts = require_utils.optsFromStepInput(stepType, stepInfo.input);

package/components/middleware/manager.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"manager.cjs","names":["stepTypeFromOpCode","stepInputFromOpts","opName: string | undefined","isTimeStrInput","timeStr","optsFromStepInput","actualHandler: (() => Promise<unknown>) | undefined","result: Middleware.TransformFunctionInputArgs[\"steps\"]","result: Middleware.TransformFunctionInputArgs","chain: () => Promise<unknown>","result: Middleware.TransformStepInputArgs","UnreachableError"],"sources":["../../../src/components/middleware/manager.ts"],"sourcesContent":["import { timeStr } from \"../../helpers/strings.ts\";\nimport type { Logger } from \"../../middleware/logger.ts\";\nimport type { Context, StepOpCode } from \"../../types.ts\";\nimport type { MemoizedOp } from \"../execution/InngestExecution.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { Middleware } from \"./middleware.ts\";\nimport {\n  isTimeStrInput,\n  optsFromStepInput,\n  stepInputFromOpts,\n  stepTypeFromOpCode,\n  UnreachableError,\n} from \"./utils.ts\";\n\nexport interface StepInfoOptions {\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n  stepType: Middleware.StepType;\n  input?: unknown[];\n}\n\nexport interface ApplyToStepInput {\n  op: StepOpCode;\n  opts?: Record<string, unknown>;\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n}\n\nexport interface PreparedStep {\n  entryPoint: () => Promise<unknown>;\n\n  /**\n   * Only used for sleep steps. The sleep's wake-up time must be in the op name,\n   * and that may be changed by the `transformStepInput` hook. The user-facing\n   * name is actually the op's `displayName` field (yes, that's confusing).\n   */\n  opName?: string;\n\n  /**\n   * For step kinds where middleware input maps to the outgoing op's opts\n   * (e.g. invoke, waitForEvent). Derived by reversing `stepInputFromOpts`.\n   */\n  opOpts?: Record<string, unknown>;\n\n  setActualHandler: (handler: () => Promise<unknown>) => void;\n  stepInfo: Middleware.StepInfo;\n}\n\n/**\n * Manages middleware. Hides middleware complexity from elsewhere in the\n * codebase. Not for for public use.\n */\nexport class MiddlewareManager {\n  private readonly fnArg: Context.Any;\n  private readonly getStepState: () => Record<string, MemoizedOp>;\n\n  /**\n   * Whether any middleware defines `transformStepInput`. Used for perf\n   * optimization.\n   */\n  private readonly hasTransformStepInput: boolean;\n\n  /**\n   * Whether memoization has ended. Used for idempotency, since memoization must\n   * only call once per request.\n   */\n  private memoizationEnded = false;\n\n  private readonly fn: InngestFunction.Any;\n  private readonly middleware: Middleware.BaseMiddleware[];\n  private readonly internalLogger: Logger;\n\n  /**\n   * Infinite recursion guard for `wrapStep`. Prevents a middleware from\n   * wrapping steps it creates inside its own `wrapStep` via `ctx.step.run`.\n   */\n  private readonly activeWrapStep = new Set<Middleware.BaseMiddleware>();\n\n  constructor(\n    fnArg: Context.Any,\n    getStepState: () => Record<string, MemoizedOp>,\n    middleware: Middleware.BaseMiddleware[] = [],\n    fn: InngestFunction.Any,\n    logger: Logger,\n  ) {\n    this.fnArg = fnArg;\n    this.getStepState = getStepState;\n    this.middleware = middleware;\n    this.fn = fn;\n    this.internalLogger = logger;\n\n    this.hasTransformStepInput = middleware.some((mw) =>\n      Boolean(mw?.transformStepInput),\n    );\n  }\n\n  hasMiddleware(): boolean {\n    return this.middleware.length > 0;\n  }\n\n  /**\n   * Derives step-kind, extracts input, runs `transformStepInput` middleware,\n   * and creates a deferred handler entry point. Does NOT build the wrapStep\n   * chain — the caller should do that after any post-processing (e.g. ID\n   * collision resolution) so middleware sees final values.\n   */\n  async applyToStep(input: ApplyToStepInput): Promise<PreparedStep> {\n    const stepType = stepTypeFromOpCode(\n      input.op,\n      input.opts,\n      this.internalLogger,\n    );\n    const stepInput = stepInputFromOpts(stepType, input.opts);\n\n    const stepInfo = this.buildStepInfo({\n      hashedId: input.hashedId,\n      userlandId: input.userlandId,\n      displayName: input.displayName,\n      memoized: input.memoized,\n      stepType,\n      input: stepInput,\n    });\n\n    // Only run transformStepInput if at least one middleware defines it.  This\n    // avoids some allocations that are unnecessary when no middleware will read\n    // or mutate them.\n    if (this.hasTransformStepInput) {\n      const originalInput = stepInfo.input;\n      const transformed = await this.transformStepInput(stepInfo);\n      stepInfo.options = transformed.stepOptions;\n\n      // Preserve undefined if input wasn't changed from the initial empty array\n      if (originalInput === undefined && transformed.input.length === 0) {\n        stepInfo.input = undefined;\n      } else {\n        stepInfo.input = transformed.input;\n      }\n    }\n\n    // For sleep steps, if middleware transformed the input, re-derive the op\n    // name (which encodes the wake-up time). If there's no input, the matchOp\n    // already set the name directly.\n    let opName: string | undefined;\n    if (stepType === \"sleep\" && stepInfo.input !== undefined) {\n      if (!isTimeStrInput(stepInfo.input[0])) {\n        throw new Error(\"Sleep time must be a string, number, or Date\");\n      }\n      opName = timeStr(stepInfo.input[0]);\n    }\n\n    // Reverse the input→opts mapping for step kinds where the whole opts\n    // object was wrapped as input (e.g. invoke, waitForEvent).\n    const opOpts = optsFromStepInput(stepType, stepInfo.input);\n\n    // Deferred handler pattern — actual handler set later based on memoization\n    let actualHandler: (() => Promise<unknown>) | undefined;\n    const entryPoint = async () => {\n      if (!actualHandler) {\n        throw new Error(\"Handler not initialized\");\n      }\n      return actualHandler();\n    };\n    const setActualHandler = (handler: () => Promise<unknown>) => {\n      actualHandler = handler;\n    };\n\n    return {\n      entryPoint,\n      opName,\n      opOpts,\n      setActualHandler,\n      stepInfo,\n    };\n  }\n\n  private buildStepInfo(opts: StepInfoOptions): Middleware.StepInfo {\n    return {\n      hashedId: opts.hashedId,\n      input: opts.input,\n      memoized: opts.memoized,\n      options: {\n        id: opts.userlandId,\n        ...(opts.displayName !== undefined && { name: opts.displayName }),\n      },\n      stepType: opts.stepType,\n    };\n  }\n\n  private buildSteps(): Middleware.TransformFunctionInputArgs[\"steps\"] {\n    const result: Middleware.TransformFunctionInputArgs[\"steps\"] = {};\n    const stepState = this.getStepState();\n\n    for (const [id, op] of Object.entries(stepState)) {\n      if (op.error !== undefined) {\n        result[id] = {\n          type: \"error\" as const,\n          error: op.error,\n        };\n      } else if (op.input !== undefined) {\n        result[id] = {\n          type: \"input\" as const,\n          input: op.input,\n        };\n      } else {\n        result[id] = {\n          type: \"data\" as const,\n          data: op.data,\n        };\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Apply transformFunctionInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  async transformFunctionInput(): Promise<Middleware.TransformFunctionInputArgs> {\n    let result: Middleware.TransformFunctionInputArgs = {\n      ctx: this.fnArg,\n      fn: this.fn,\n      steps: this.buildSteps(),\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformFunctionInput) {\n        result = await mw.transformFunctionInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a run handler with wrapFunctionHandler middlewares (reverse order for\n   * onion layering, same pattern as wrapStepHandler).\n   */\n  wrapRunHandler(handler: () => Promise<unknown>): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapFunctionHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapFunctionHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n          });\n      }\n    }\n    return chain;\n  }\n\n  /**\n   * Apply transformStepInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  private async transformStepInput(\n    stepInfo: Middleware.StepInfo,\n  ): Promise<Middleware.TransformStepInputArgs> {\n    let result: Middleware.TransformStepInputArgs = {\n      fn: this.fn,\n      stepInfo: {\n        hashedId: stepInfo.hashedId,\n        memoized: stepInfo.memoized,\n        stepType: stepInfo.stepType,\n      },\n      stepOptions: { ...stepInfo.options },\n      input: [...(stepInfo.input ?? [])],\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformStepInput) {\n        result = await mw.transformStepInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a step handler with wrapStep middlewares (reverse order for\n   * onion layering). Returns the wrapped handler.\n   */\n  buildWrapStepChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStep) {\n        const next = chain;\n        chain = () => {\n          if (!mw.wrapStep) {\n            throw new UnreachableError(\"wrapStep is undefined\");\n          }\n\n          // Infinite recursion guard: skip if this middleware is already\n          // executing\n          if (this.activeWrapStep.has(mw)) {\n            return next();\n          }\n\n          this.activeWrapStep.add(mw);\n\n          // Remove from active while inside next() so only the middleware\n          // that directly calls ctx.step.run() is guarded.\n          const guardedNext = () => {\n            this.activeWrapStep.delete(mw);\n            return next().finally(() => {\n              this.activeWrapStep.add(mw);\n            });\n          };\n\n          return mw.wrapStep!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next: guardedNext,\n            stepInfo,\n          }).finally(() => {\n            this.activeWrapStep.delete(mw);\n          });\n        };\n      }\n    }\n    return chain;\n  }\n\n  async onStepStart(stepInfo: Middleware.StepInfo): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepStart) {\n        try {\n          await mw.onStepStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onStepComplete(\n    stepInfo: Middleware.StepInfo,\n    output: unknown,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepComplete) {\n        try {\n          await mw.onStepComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Build a wrapStepHandler chain around the actual step handler.\n   * Called once per `step.run` attempt (not for memoized steps).\n   * Simpler than buildWrapStepChain — no recursion guard needed.\n   */\n  buildWrapStepHandlerChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStepHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapStepHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n            stepInfo,\n          });\n      }\n    }\n    return chain;\n  }\n\n  async onStepError(\n    stepInfo: Middleware.StepInfo,\n    error: Error,\n    isFinalAttempt: boolean,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepError) {\n        try {\n          await mw.onStepError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Idempotent: safe to call from every code path that might end memoization.\n   */\n  async onMemoizationEnd(): Promise<void> {\n    if (this.memoizationEnded) {\n      return;\n    }\n    this.memoizationEnded = true;\n\n    for (const mw of this.middleware) {\n      if (mw?.onMemoizationEnd) {\n        try {\n          await mw.onMemoizationEnd({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onMemoizationEnd\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunStart(): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunStart) {\n        try {\n          await mw.onRunStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunComplete(output: unknown): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunComplete) {\n        try {\n          await mw.onRunComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunError(error: Error, isFinalAttempt: boolean): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunError) {\n        try {\n          await mw.onRunError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"manager.cjs","names":["stepTypeFromOpCode","stepInputFromOpts","opName: string | undefined","isSleepInput","timeStr","optsFromStepInput","actualHandler: (() => Promise<unknown>) | undefined","result: Middleware.TransformFunctionInputArgs[\"steps\"]","result: Middleware.TransformFunctionInputArgs","chain: () => Promise<unknown>","result: Middleware.TransformStepInputArgs","UnreachableError"],"sources":["../../../src/components/middleware/manager.ts"],"sourcesContent":["import { timeStr } from \"../../helpers/strings.ts\";\nimport type { Logger } from \"../../middleware/logger.ts\";\nimport type { Context, StepOpCode } from \"../../types.ts\";\nimport type { MemoizedOp } from \"../execution/InngestExecution.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { Middleware } from \"./middleware.ts\";\nimport {\n  isSleepInput,\n  optsFromStepInput,\n  stepInputFromOpts,\n  stepTypeFromOpCode,\n  UnreachableError,\n} from \"./utils.ts\";\n\nexport interface StepInfoOptions {\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n  stepType: Middleware.StepType;\n  input?: unknown[];\n}\n\nexport interface ApplyToStepInput {\n  op: StepOpCode;\n  opts?: Record<string, unknown>;\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n}\n\nexport interface PreparedStep {\n  entryPoint: () => Promise<unknown>;\n\n  /**\n   * Only used for sleep steps. The sleep's wake-up time must be in the op name,\n   * and that may be changed by the `transformStepInput` hook. The user-facing\n   * name is actually the op's `displayName` field (yes, that's confusing).\n   */\n  opName?: string;\n\n  /**\n   * For step kinds where middleware input maps to the outgoing op's opts\n   * (e.g. invoke, waitForEvent). Derived by reversing `stepInputFromOpts`.\n   */\n  opOpts?: Record<string, unknown>;\n\n  setActualHandler: (handler: () => Promise<unknown>) => void;\n  stepInfo: Middleware.StepInfo;\n}\n\n/**\n * Manages middleware. Hides middleware complexity from elsewhere in the\n * codebase. Not for for public use.\n */\nexport class MiddlewareManager {\n  private readonly fnArg: Context.Any;\n  private readonly getStepState: () => Record<string, MemoizedOp>;\n\n  /**\n   * Whether any middleware defines `transformStepInput`. Used for perf\n   * optimization.\n   */\n  private readonly hasTransformStepInput: boolean;\n\n  /**\n   * Whether memoization has ended. Used for idempotency, since memoization must\n   * only call once per request.\n   */\n  private memoizationEnded = false;\n\n  private readonly fn: InngestFunction.Any;\n  private readonly middleware: Middleware.BaseMiddleware[];\n  private readonly internalLogger: Logger;\n\n  /**\n   * Infinite recursion guard for `wrapStep`. Prevents a middleware from\n   * wrapping steps it creates inside its own `wrapStep` via `ctx.step.run`.\n   */\n  private readonly activeWrapStep = new Set<Middleware.BaseMiddleware>();\n\n  constructor(\n    fnArg: Context.Any,\n    getStepState: () => Record<string, MemoizedOp>,\n    middleware: Middleware.BaseMiddleware[] = [],\n    fn: InngestFunction.Any,\n    logger: Logger,\n  ) {\n    this.fnArg = fnArg;\n    this.getStepState = getStepState;\n    this.middleware = middleware;\n    this.fn = fn;\n    this.internalLogger = logger;\n\n    this.hasTransformStepInput = middleware.some((mw) =>\n      Boolean(mw?.transformStepInput),\n    );\n  }\n\n  hasMiddleware(): boolean {\n    return this.middleware.length > 0;\n  }\n\n  /**\n   * Derives step-kind, extracts input, runs `transformStepInput` middleware,\n   * and creates a deferred handler entry point. Does NOT build the wrapStep\n   * chain — the caller should do that after any post-processing (e.g. ID\n   * collision resolution) so middleware sees final values.\n   */\n  async applyToStep(input: ApplyToStepInput): Promise<PreparedStep> {\n    const stepType = stepTypeFromOpCode(\n      input.op,\n      input.opts,\n      this.internalLogger,\n    );\n    const stepInput = stepInputFromOpts(stepType, input.opts);\n\n    const stepInfo = this.buildStepInfo({\n      hashedId: input.hashedId,\n      userlandId: input.userlandId,\n      displayName: input.displayName,\n      memoized: input.memoized,\n      stepType,\n      input: stepInput,\n    });\n\n    // Only run transformStepInput if at least one middleware defines it.  This\n    // avoids some allocations that are unnecessary when no middleware will read\n    // or mutate them.\n    if (this.hasTransformStepInput) {\n      const originalInput = stepInfo.input;\n      const transformed = await this.transformStepInput(stepInfo);\n      stepInfo.options = transformed.stepOptions;\n\n      // Preserve undefined if input wasn't changed from the initial empty array\n      if (originalInput === undefined && transformed.input.length === 0) {\n        stepInfo.input = undefined;\n      } else {\n        stepInfo.input = transformed.input;\n      }\n    }\n\n    // For sleep steps, if middleware transformed the input, re-derive the op\n    // name (which encodes the wake-up time). If there's no input, the matchOp\n    // already set the name directly.\n    let opName: string | undefined;\n    if (stepType === \"sleep\" && stepInfo.input !== undefined) {\n      if (!isSleepInput(stepInfo.input[0])) {\n        throw new Error(\n          \"Sleep time must be a string, number, Date, or Temporal.Duration\",\n        );\n      }\n      opName = timeStr(stepInfo.input[0]);\n    }\n\n    // Reverse the input→opts mapping for step kinds where the whole opts\n    // object was wrapped as input (e.g. invoke, waitForEvent).\n    const opOpts = optsFromStepInput(stepType, stepInfo.input);\n\n    // Deferred handler pattern — actual handler set later based on memoization\n    let actualHandler: (() => Promise<unknown>) | undefined;\n    const entryPoint = async () => {\n      if (!actualHandler) {\n        throw new Error(\"Handler not initialized\");\n      }\n      return actualHandler();\n    };\n    const setActualHandler = (handler: () => Promise<unknown>) => {\n      actualHandler = handler;\n    };\n\n    return {\n      entryPoint,\n      opName,\n      opOpts,\n      setActualHandler,\n      stepInfo,\n    };\n  }\n\n  private buildStepInfo(opts: StepInfoOptions): Middleware.StepInfo {\n    return {\n      hashedId: opts.hashedId,\n      input: opts.input,\n      memoized: opts.memoized,\n      options: {\n        id: opts.userlandId,\n        ...(opts.displayName !== undefined && { name: opts.displayName }),\n      },\n      stepType: opts.stepType,\n    };\n  }\n\n  private buildSteps(): Middleware.TransformFunctionInputArgs[\"steps\"] {\n    const result: Middleware.TransformFunctionInputArgs[\"steps\"] = {};\n    const stepState = this.getStepState();\n\n    for (const [id, op] of Object.entries(stepState)) {\n      if (op.error !== undefined) {\n        result[id] = {\n          type: \"error\" as const,\n          error: op.error,\n        };\n      } else if (op.input !== undefined) {\n        result[id] = {\n          type: \"input\" as const,\n          input: op.input,\n        };\n      } else {\n        result[id] = {\n          type: \"data\" as const,\n          data: op.data,\n        };\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Apply transformFunctionInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  async transformFunctionInput(): Promise<Middleware.TransformFunctionInputArgs> {\n    let result: Middleware.TransformFunctionInputArgs = {\n      ctx: this.fnArg,\n      fn: this.fn,\n      steps: this.buildSteps(),\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformFunctionInput) {\n        result = await mw.transformFunctionInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a run handler with wrapFunctionHandler middlewares (reverse order for\n   * onion layering, same pattern as wrapStepHandler).\n   */\n  wrapRunHandler(handler: () => Promise<unknown>): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapFunctionHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapFunctionHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n          });\n      }\n    }\n    return chain;\n  }\n\n  /**\n   * Apply transformStepInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  private async transformStepInput(\n    stepInfo: Middleware.StepInfo,\n  ): Promise<Middleware.TransformStepInputArgs> {\n    let result: Middleware.TransformStepInputArgs = {\n      fn: this.fn,\n      stepInfo: {\n        hashedId: stepInfo.hashedId,\n        memoized: stepInfo.memoized,\n        stepType: stepInfo.stepType,\n      },\n      stepOptions: { ...stepInfo.options },\n      input: [...(stepInfo.input ?? [])],\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformStepInput) {\n        result = await mw.transformStepInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a step handler with wrapStep middlewares (reverse order for\n   * onion layering). Returns the wrapped handler.\n   */\n  buildWrapStepChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStep) {\n        const next = chain;\n        chain = () => {\n          if (!mw.wrapStep) {\n            throw new UnreachableError(\"wrapStep is undefined\");\n          }\n\n          // Infinite recursion guard: skip if this middleware is already\n          // executing\n          if (this.activeWrapStep.has(mw)) {\n            return next();\n          }\n\n          this.activeWrapStep.add(mw);\n\n          // Remove from active while inside next() so only the middleware\n          // that directly calls ctx.step.run() is guarded.\n          const guardedNext = () => {\n            this.activeWrapStep.delete(mw);\n            return next().finally(() => {\n              this.activeWrapStep.add(mw);\n            });\n          };\n\n          return mw.wrapStep!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next: guardedNext,\n            stepInfo,\n          }).finally(() => {\n            this.activeWrapStep.delete(mw);\n          });\n        };\n      }\n    }\n    return chain;\n  }\n\n  async onStepStart(stepInfo: Middleware.StepInfo): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepStart) {\n        try {\n          await mw.onStepStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onStepComplete(\n    stepInfo: Middleware.StepInfo,\n    output: unknown,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepComplete) {\n        try {\n          await mw.onStepComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Build a wrapStepHandler chain around the actual step handler.\n   * Called once per `step.run` attempt (not for memoized steps).\n   * Simpler than buildWrapStepChain — no recursion guard needed.\n   */\n  buildWrapStepHandlerChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStepHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapStepHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n            stepInfo,\n          });\n      }\n    }\n    return chain;\n  }\n\n  async onStepError(\n    stepInfo: Middleware.StepInfo,\n    error: Error,\n    isFinalAttempt: boolean,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepError) {\n        try {\n          await mw.onStepError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Idempotent: safe to call from every code path that might end memoization.\n   */\n  async onMemoizationEnd(): Promise<void> {\n    if (this.memoizationEnded) {\n      return;\n    }\n    this.memoizationEnded = true;\n\n    for (const mw of this.middleware) {\n      if (mw?.onMemoizationEnd) {\n        try {\n          await mw.onMemoizationEnd({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onMemoizationEnd\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunStart(): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunStart) {\n        try {\n          await mw.onRunStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunComplete(output: unknown): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunComplete) {\n        try {\n          await mw.onRunComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunError(error: Error, isFinalAttempt: boolean): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunError) {\n        try {\n          await mw.onRunError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/components/middleware/manager.js

@@ -1,5 +1,5 @@
 import { timeStr } from "../../helpers/strings.js";
-import { UnreachableError, isTimeStrInput, optsFromStepInput, stepInputFromOpts, stepTypeFromOpCode } from "./utils.js";
+import { UnreachableError, isSleepInput, optsFromStepInput, stepInputFromOpts, stepTypeFromOpCode } from "./utils.js";
 
 //#region src/components/middleware/manager.ts
 /**
@@ -64,7 +64,7 @@ var MiddlewareManager = class {
 		}
 		let opName;
 		if (stepType === "sleep" && stepInfo.input !== void 0) {
-			if (!isTimeStrInput(stepInfo.input[0])) throw new Error("Sleep time must be a string, number, or Date");
+			if (!isSleepInput(stepInfo.input[0])) throw new Error("Sleep time must be a string, number, Date, or Temporal.Duration");
 			opName = timeStr(stepInfo.input[0]);
 		}
 		const opOpts = optsFromStepInput(stepType, stepInfo.input);

package/components/middleware/manager.js.map

@@ -1 +1 @@
-{"version":3,"file":"manager.js","names":["opName: string | undefined","actualHandler: (() => Promise<unknown>) | undefined","result: Middleware.TransformFunctionInputArgs[\"steps\"]","result: Middleware.TransformFunctionInputArgs","chain: () => Promise<unknown>","result: Middleware.TransformStepInputArgs"],"sources":["../../../src/components/middleware/manager.ts"],"sourcesContent":["import { timeStr } from \"../../helpers/strings.ts\";\nimport type { Logger } from \"../../middleware/logger.ts\";\nimport type { Context, StepOpCode } from \"../../types.ts\";\nimport type { MemoizedOp } from \"../execution/InngestExecution.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { Middleware } from \"./middleware.ts\";\nimport {\n  isTimeStrInput,\n  optsFromStepInput,\n  stepInputFromOpts,\n  stepTypeFromOpCode,\n  UnreachableError,\n} from \"./utils.ts\";\n\nexport interface StepInfoOptions {\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n  stepType: Middleware.StepType;\n  input?: unknown[];\n}\n\nexport interface ApplyToStepInput {\n  op: StepOpCode;\n  opts?: Record<string, unknown>;\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n}\n\nexport interface PreparedStep {\n  entryPoint: () => Promise<unknown>;\n\n  /**\n   * Only used for sleep steps. The sleep's wake-up time must be in the op name,\n   * and that may be changed by the `transformStepInput` hook. The user-facing\n   * name is actually the op's `displayName` field (yes, that's confusing).\n   */\n  opName?: string;\n\n  /**\n   * For step kinds where middleware input maps to the outgoing op's opts\n   * (e.g. invoke, waitForEvent). Derived by reversing `stepInputFromOpts`.\n   */\n  opOpts?: Record<string, unknown>;\n\n  setActualHandler: (handler: () => Promise<unknown>) => void;\n  stepInfo: Middleware.StepInfo;\n}\n\n/**\n * Manages middleware. Hides middleware complexity from elsewhere in the\n * codebase. Not for for public use.\n */\nexport class MiddlewareManager {\n  private readonly fnArg: Context.Any;\n  private readonly getStepState: () => Record<string, MemoizedOp>;\n\n  /**\n   * Whether any middleware defines `transformStepInput`. Used for perf\n   * optimization.\n   */\n  private readonly hasTransformStepInput: boolean;\n\n  /**\n   * Whether memoization has ended. Used for idempotency, since memoization must\n   * only call once per request.\n   */\n  private memoizationEnded = false;\n\n  private readonly fn: InngestFunction.Any;\n  private readonly middleware: Middleware.BaseMiddleware[];\n  private readonly internalLogger: Logger;\n\n  /**\n   * Infinite recursion guard for `wrapStep`. Prevents a middleware from\n   * wrapping steps it creates inside its own `wrapStep` via `ctx.step.run`.\n   */\n  private readonly activeWrapStep = new Set<Middleware.BaseMiddleware>();\n\n  constructor(\n    fnArg: Context.Any,\n    getStepState: () => Record<string, MemoizedOp>,\n    middleware: Middleware.BaseMiddleware[] = [],\n    fn: InngestFunction.Any,\n    logger: Logger,\n  ) {\n    this.fnArg = fnArg;\n    this.getStepState = getStepState;\n    this.middleware = middleware;\n    this.fn = fn;\n    this.internalLogger = logger;\n\n    this.hasTransformStepInput = middleware.some((mw) =>\n      Boolean(mw?.transformStepInput),\n    );\n  }\n\n  hasMiddleware(): boolean {\n    return this.middleware.length > 0;\n  }\n\n  /**\n   * Derives step-kind, extracts input, runs `transformStepInput` middleware,\n   * and creates a deferred handler entry point. Does NOT build the wrapStep\n   * chain — the caller should do that after any post-processing (e.g. ID\n   * collision resolution) so middleware sees final values.\n   */\n  async applyToStep(input: ApplyToStepInput): Promise<PreparedStep> {\n    const stepType = stepTypeFromOpCode(\n      input.op,\n      input.opts,\n      this.internalLogger,\n    );\n    const stepInput = stepInputFromOpts(stepType, input.opts);\n\n    const stepInfo = this.buildStepInfo({\n      hashedId: input.hashedId,\n      userlandId: input.userlandId,\n      displayName: input.displayName,\n      memoized: input.memoized,\n      stepType,\n      input: stepInput,\n    });\n\n    // Only run transformStepInput if at least one middleware defines it.  This\n    // avoids some allocations that are unnecessary when no middleware will read\n    // or mutate them.\n    if (this.hasTransformStepInput) {\n      const originalInput = stepInfo.input;\n      const transformed = await this.transformStepInput(stepInfo);\n      stepInfo.options = transformed.stepOptions;\n\n      // Preserve undefined if input wasn't changed from the initial empty array\n      if (originalInput === undefined && transformed.input.length === 0) {\n        stepInfo.input = undefined;\n      } else {\n        stepInfo.input = transformed.input;\n      }\n    }\n\n    // For sleep steps, if middleware transformed the input, re-derive the op\n    // name (which encodes the wake-up time). If there's no input, the matchOp\n    // already set the name directly.\n    let opName: string | undefined;\n    if (stepType === \"sleep\" && stepInfo.input !== undefined) {\n      if (!isTimeStrInput(stepInfo.input[0])) {\n        throw new Error(\"Sleep time must be a string, number, or Date\");\n      }\n      opName = timeStr(stepInfo.input[0]);\n    }\n\n    // Reverse the input→opts mapping for step kinds where the whole opts\n    // object was wrapped as input (e.g. invoke, waitForEvent).\n    const opOpts = optsFromStepInput(stepType, stepInfo.input);\n\n    // Deferred handler pattern — actual handler set later based on memoization\n    let actualHandler: (() => Promise<unknown>) | undefined;\n    const entryPoint = async () => {\n      if (!actualHandler) {\n        throw new Error(\"Handler not initialized\");\n      }\n      return actualHandler();\n    };\n    const setActualHandler = (handler: () => Promise<unknown>) => {\n      actualHandler = handler;\n    };\n\n    return {\n      entryPoint,\n      opName,\n      opOpts,\n      setActualHandler,\n      stepInfo,\n    };\n  }\n\n  private buildStepInfo(opts: StepInfoOptions): Middleware.StepInfo {\n    return {\n      hashedId: opts.hashedId,\n      input: opts.input,\n      memoized: opts.memoized,\n      options: {\n        id: opts.userlandId,\n        ...(opts.displayName !== undefined && { name: opts.displayName }),\n      },\n      stepType: opts.stepType,\n    };\n  }\n\n  private buildSteps(): Middleware.TransformFunctionInputArgs[\"steps\"] {\n    const result: Middleware.TransformFunctionInputArgs[\"steps\"] = {};\n    const stepState = this.getStepState();\n\n    for (const [id, op] of Object.entries(stepState)) {\n      if (op.error !== undefined) {\n        result[id] = {\n          type: \"error\" as const,\n          error: op.error,\n        };\n      } else if (op.input !== undefined) {\n        result[id] = {\n          type: \"input\" as const,\n          input: op.input,\n        };\n      } else {\n        result[id] = {\n          type: \"data\" as const,\n          data: op.data,\n        };\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Apply transformFunctionInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  async transformFunctionInput(): Promise<Middleware.TransformFunctionInputArgs> {\n    let result: Middleware.TransformFunctionInputArgs = {\n      ctx: this.fnArg,\n      fn: this.fn,\n      steps: this.buildSteps(),\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformFunctionInput) {\n        result = await mw.transformFunctionInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a run handler with wrapFunctionHandler middlewares (reverse order for\n   * onion layering, same pattern as wrapStepHandler).\n   */\n  wrapRunHandler(handler: () => Promise<unknown>): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapFunctionHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapFunctionHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n          });\n      }\n    }\n    return chain;\n  }\n\n  /**\n   * Apply transformStepInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  private async transformStepInput(\n    stepInfo: Middleware.StepInfo,\n  ): Promise<Middleware.TransformStepInputArgs> {\n    let result: Middleware.TransformStepInputArgs = {\n      fn: this.fn,\n      stepInfo: {\n        hashedId: stepInfo.hashedId,\n        memoized: stepInfo.memoized,\n        stepType: stepInfo.stepType,\n      },\n      stepOptions: { ...stepInfo.options },\n      input: [...(stepInfo.input ?? [])],\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformStepInput) {\n        result = await mw.transformStepInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a step handler with wrapStep middlewares (reverse order for\n   * onion layering). Returns the wrapped handler.\n   */\n  buildWrapStepChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStep) {\n        const next = chain;\n        chain = () => {\n          if (!mw.wrapStep) {\n            throw new UnreachableError(\"wrapStep is undefined\");\n          }\n\n          // Infinite recursion guard: skip if this middleware is already\n          // executing\n          if (this.activeWrapStep.has(mw)) {\n            return next();\n          }\n\n          this.activeWrapStep.add(mw);\n\n          // Remove from active while inside next() so only the middleware\n          // that directly calls ctx.step.run() is guarded.\n          const guardedNext = () => {\n            this.activeWrapStep.delete(mw);\n            return next().finally(() => {\n              this.activeWrapStep.add(mw);\n            });\n          };\n\n          return mw.wrapStep!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next: guardedNext,\n            stepInfo,\n          }).finally(() => {\n            this.activeWrapStep.delete(mw);\n          });\n        };\n      }\n    }\n    return chain;\n  }\n\n  async onStepStart(stepInfo: Middleware.StepInfo): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepStart) {\n        try {\n          await mw.onStepStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onStepComplete(\n    stepInfo: Middleware.StepInfo,\n    output: unknown,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepComplete) {\n        try {\n          await mw.onStepComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Build a wrapStepHandler chain around the actual step handler.\n   * Called once per `step.run` attempt (not for memoized steps).\n   * Simpler than buildWrapStepChain — no recursion guard needed.\n   */\n  buildWrapStepHandlerChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStepHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapStepHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n            stepInfo,\n          });\n      }\n    }\n    return chain;\n  }\n\n  async onStepError(\n    stepInfo: Middleware.StepInfo,\n    error: Error,\n    isFinalAttempt: boolean,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepError) {\n        try {\n          await mw.onStepError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Idempotent: safe to call from every code path that might end memoization.\n   */\n  async onMemoizationEnd(): Promise<void> {\n    if (this.memoizationEnded) {\n      return;\n    }\n    this.memoizationEnded = true;\n\n    for (const mw of this.middleware) {\n      if (mw?.onMemoizationEnd) {\n        try {\n          await mw.onMemoizationEnd({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onMemoizationEnd\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunStart(): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunStart) {\n        try {\n          await mw.onRunStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunComplete(output: unknown): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunComplete) {\n        try {\n          await mw.onRunComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunError(error: Error, isFinalAttempt: boolean): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunError) {\n        try {\n          await mw.onRunError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"manager.js","names":["opName: string | undefined","actualHandler: (() => Promise<unknown>) | undefined","result: Middleware.TransformFunctionInputArgs[\"steps\"]","result: Middleware.TransformFunctionInputArgs","chain: () => Promise<unknown>","result: Middleware.TransformStepInputArgs"],"sources":["../../../src/components/middleware/manager.ts"],"sourcesContent":["import { timeStr } from \"../../helpers/strings.ts\";\nimport type { Logger } from \"../../middleware/logger.ts\";\nimport type { Context, StepOpCode } from \"../../types.ts\";\nimport type { MemoizedOp } from \"../execution/InngestExecution.ts\";\nimport type { InngestFunction } from \"../InngestFunction.ts\";\nimport type { Middleware } from \"./middleware.ts\";\nimport {\n  isSleepInput,\n  optsFromStepInput,\n  stepInputFromOpts,\n  stepTypeFromOpCode,\n  UnreachableError,\n} from \"./utils.ts\";\n\nexport interface StepInfoOptions {\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n  stepType: Middleware.StepType;\n  input?: unknown[];\n}\n\nexport interface ApplyToStepInput {\n  op: StepOpCode;\n  opts?: Record<string, unknown>;\n  hashedId: string;\n  userlandId: string;\n  displayName?: string;\n  memoized: boolean;\n}\n\nexport interface PreparedStep {\n  entryPoint: () => Promise<unknown>;\n\n  /**\n   * Only used for sleep steps. The sleep's wake-up time must be in the op name,\n   * and that may be changed by the `transformStepInput` hook. The user-facing\n   * name is actually the op's `displayName` field (yes, that's confusing).\n   */\n  opName?: string;\n\n  /**\n   * For step kinds where middleware input maps to the outgoing op's opts\n   * (e.g. invoke, waitForEvent). Derived by reversing `stepInputFromOpts`.\n   */\n  opOpts?: Record<string, unknown>;\n\n  setActualHandler: (handler: () => Promise<unknown>) => void;\n  stepInfo: Middleware.StepInfo;\n}\n\n/**\n * Manages middleware. Hides middleware complexity from elsewhere in the\n * codebase. Not for for public use.\n */\nexport class MiddlewareManager {\n  private readonly fnArg: Context.Any;\n  private readonly getStepState: () => Record<string, MemoizedOp>;\n\n  /**\n   * Whether any middleware defines `transformStepInput`. Used for perf\n   * optimization.\n   */\n  private readonly hasTransformStepInput: boolean;\n\n  /**\n   * Whether memoization has ended. Used for idempotency, since memoization must\n   * only call once per request.\n   */\n  private memoizationEnded = false;\n\n  private readonly fn: InngestFunction.Any;\n  private readonly middleware: Middleware.BaseMiddleware[];\n  private readonly internalLogger: Logger;\n\n  /**\n   * Infinite recursion guard for `wrapStep`. Prevents a middleware from\n   * wrapping steps it creates inside its own `wrapStep` via `ctx.step.run`.\n   */\n  private readonly activeWrapStep = new Set<Middleware.BaseMiddleware>();\n\n  constructor(\n    fnArg: Context.Any,\n    getStepState: () => Record<string, MemoizedOp>,\n    middleware: Middleware.BaseMiddleware[] = [],\n    fn: InngestFunction.Any,\n    logger: Logger,\n  ) {\n    this.fnArg = fnArg;\n    this.getStepState = getStepState;\n    this.middleware = middleware;\n    this.fn = fn;\n    this.internalLogger = logger;\n\n    this.hasTransformStepInput = middleware.some((mw) =>\n      Boolean(mw?.transformStepInput),\n    );\n  }\n\n  hasMiddleware(): boolean {\n    return this.middleware.length > 0;\n  }\n\n  /**\n   * Derives step-kind, extracts input, runs `transformStepInput` middleware,\n   * and creates a deferred handler entry point. Does NOT build the wrapStep\n   * chain — the caller should do that after any post-processing (e.g. ID\n   * collision resolution) so middleware sees final values.\n   */\n  async applyToStep(input: ApplyToStepInput): Promise<PreparedStep> {\n    const stepType = stepTypeFromOpCode(\n      input.op,\n      input.opts,\n      this.internalLogger,\n    );\n    const stepInput = stepInputFromOpts(stepType, input.opts);\n\n    const stepInfo = this.buildStepInfo({\n      hashedId: input.hashedId,\n      userlandId: input.userlandId,\n      displayName: input.displayName,\n      memoized: input.memoized,\n      stepType,\n      input: stepInput,\n    });\n\n    // Only run transformStepInput if at least one middleware defines it.  This\n    // avoids some allocations that are unnecessary when no middleware will read\n    // or mutate them.\n    if (this.hasTransformStepInput) {\n      const originalInput = stepInfo.input;\n      const transformed = await this.transformStepInput(stepInfo);\n      stepInfo.options = transformed.stepOptions;\n\n      // Preserve undefined if input wasn't changed from the initial empty array\n      if (originalInput === undefined && transformed.input.length === 0) {\n        stepInfo.input = undefined;\n      } else {\n        stepInfo.input = transformed.input;\n      }\n    }\n\n    // For sleep steps, if middleware transformed the input, re-derive the op\n    // name (which encodes the wake-up time). If there's no input, the matchOp\n    // already set the name directly.\n    let opName: string | undefined;\n    if (stepType === \"sleep\" && stepInfo.input !== undefined) {\n      if (!isSleepInput(stepInfo.input[0])) {\n        throw new Error(\n          \"Sleep time must be a string, number, Date, or Temporal.Duration\",\n        );\n      }\n      opName = timeStr(stepInfo.input[0]);\n    }\n\n    // Reverse the input→opts mapping for step kinds where the whole opts\n    // object was wrapped as input (e.g. invoke, waitForEvent).\n    const opOpts = optsFromStepInput(stepType, stepInfo.input);\n\n    // Deferred handler pattern — actual handler set later based on memoization\n    let actualHandler: (() => Promise<unknown>) | undefined;\n    const entryPoint = async () => {\n      if (!actualHandler) {\n        throw new Error(\"Handler not initialized\");\n      }\n      return actualHandler();\n    };\n    const setActualHandler = (handler: () => Promise<unknown>) => {\n      actualHandler = handler;\n    };\n\n    return {\n      entryPoint,\n      opName,\n      opOpts,\n      setActualHandler,\n      stepInfo,\n    };\n  }\n\n  private buildStepInfo(opts: StepInfoOptions): Middleware.StepInfo {\n    return {\n      hashedId: opts.hashedId,\n      input: opts.input,\n      memoized: opts.memoized,\n      options: {\n        id: opts.userlandId,\n        ...(opts.displayName !== undefined && { name: opts.displayName }),\n      },\n      stepType: opts.stepType,\n    };\n  }\n\n  private buildSteps(): Middleware.TransformFunctionInputArgs[\"steps\"] {\n    const result: Middleware.TransformFunctionInputArgs[\"steps\"] = {};\n    const stepState = this.getStepState();\n\n    for (const [id, op] of Object.entries(stepState)) {\n      if (op.error !== undefined) {\n        result[id] = {\n          type: \"error\" as const,\n          error: op.error,\n        };\n      } else if (op.input !== undefined) {\n        result[id] = {\n          type: \"input\" as const,\n          input: op.input,\n        };\n      } else {\n        result[id] = {\n          type: \"data\" as const,\n          data: op.data,\n        };\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Apply transformFunctionInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  async transformFunctionInput(): Promise<Middleware.TransformFunctionInputArgs> {\n    let result: Middleware.TransformFunctionInputArgs = {\n      ctx: this.fnArg,\n      fn: this.fn,\n      steps: this.buildSteps(),\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformFunctionInput) {\n        result = await mw.transformFunctionInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a run handler with wrapFunctionHandler middlewares (reverse order for\n   * onion layering, same pattern as wrapStepHandler).\n   */\n  wrapRunHandler(handler: () => Promise<unknown>): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapFunctionHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapFunctionHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n          });\n      }\n    }\n    return chain;\n  }\n\n  /**\n   * Apply transformStepInput middleware in forward order.\n   * Each middleware builds on the previous result.\n   */\n  private async transformStepInput(\n    stepInfo: Middleware.StepInfo,\n  ): Promise<Middleware.TransformStepInputArgs> {\n    let result: Middleware.TransformStepInputArgs = {\n      fn: this.fn,\n      stepInfo: {\n        hashedId: stepInfo.hashedId,\n        memoized: stepInfo.memoized,\n        stepType: stepInfo.stepType,\n      },\n      stepOptions: { ...stepInfo.options },\n      input: [...(stepInfo.input ?? [])],\n    };\n\n    for (const mw of this.middleware) {\n      if (mw?.transformStepInput) {\n        result = await mw.transformStepInput(result);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Wrap a step handler with wrapStep middlewares (reverse order for\n   * onion layering). Returns the wrapped handler.\n   */\n  buildWrapStepChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStep) {\n        const next = chain;\n        chain = () => {\n          if (!mw.wrapStep) {\n            throw new UnreachableError(\"wrapStep is undefined\");\n          }\n\n          // Infinite recursion guard: skip if this middleware is already\n          // executing\n          if (this.activeWrapStep.has(mw)) {\n            return next();\n          }\n\n          this.activeWrapStep.add(mw);\n\n          // Remove from active while inside next() so only the middleware\n          // that directly calls ctx.step.run() is guarded.\n          const guardedNext = () => {\n            this.activeWrapStep.delete(mw);\n            return next().finally(() => {\n              this.activeWrapStep.add(mw);\n            });\n          };\n\n          return mw.wrapStep!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next: guardedNext,\n            stepInfo,\n          }).finally(() => {\n            this.activeWrapStep.delete(mw);\n          });\n        };\n      }\n    }\n    return chain;\n  }\n\n  async onStepStart(stepInfo: Middleware.StepInfo): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepStart) {\n        try {\n          await mw.onStepStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onStepComplete(\n    stepInfo: Middleware.StepInfo,\n    output: unknown,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepComplete) {\n        try {\n          await mw.onStepComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Build a wrapStepHandler chain around the actual step handler.\n   * Called once per `step.run` attempt (not for memoized steps).\n   * Simpler than buildWrapStepChain — no recursion guard needed.\n   */\n  buildWrapStepHandlerChain(\n    handler: () => Promise<unknown>,\n    stepInfo: Middleware.StepInfo,\n  ): () => Promise<unknown> {\n    let chain: () => Promise<unknown> = handler;\n    for (let i = this.middleware.length - 1; i >= 0; i--) {\n      const mw = this.middleware[i];\n      if (mw?.wrapStepHandler) {\n        const next = chain;\n        chain = () =>\n          mw.wrapStepHandler!({\n            ctx: this.fnArg,\n            fn: this.fn,\n            next,\n            stepInfo,\n          });\n      }\n    }\n    return chain;\n  }\n\n  async onStepError(\n    stepInfo: Middleware.StepInfo,\n    error: Error,\n    isFinalAttempt: boolean,\n  ): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onStepError) {\n        try {\n          await mw.onStepError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n            stepInfo,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onStepError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * Idempotent: safe to call from every code path that might end memoization.\n   */\n  async onMemoizationEnd(): Promise<void> {\n    if (this.memoizationEnded) {\n      return;\n    }\n    this.memoizationEnded = true;\n\n    for (const mw of this.middleware) {\n      if (mw?.onMemoizationEnd) {\n        try {\n          await mw.onMemoizationEnd({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onMemoizationEnd\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunStart(): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunStart) {\n        try {\n          await mw.onRunStart({\n            ctx: this.fnArg,\n            fn: this.fn,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunStart\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunComplete(output: unknown): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunComplete) {\n        try {\n          await mw.onRunComplete({\n            ctx: this.fnArg,\n            fn: this.fn,\n            output,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunComplete\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n\n  async onRunError(error: Error, isFinalAttempt: boolean): Promise<void> {\n    for (const mw of this.middleware) {\n      if (mw?.onRunError) {\n        try {\n          await mw.onRunError({\n            ctx: this.fnArg,\n            error,\n            fn: this.fn,\n            isFinalAttempt,\n          });\n        } catch (err) {\n          this.internalLogger.error(\n            {\n              err,\n              hook: \"onRunError\",\n              mw: mw.id,\n            },\n            \"middleware error\",\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}