inngest 4.2.6 → 4.3.0

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

@@ -72,11 +72,13 @@ 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: {
             signal: string;
-            timeout: number | string | Date;
+            timeout: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
             onConflict: "replace" | "fail";
           }) => Promise<{
             signal: string;
@@ -91,7 +93,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 +151,10 @@ 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;
         };
-        events: AsTuple<Simplify<EventPayload>>;
-        runId: string;
         group: ReturnType<typeof createGroupTools>;
         attempt: number;
         maxAttempts?: number | undefined;
@@ -234,7 +234,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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

@@ -72,11 +72,13 @@ 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: {
             signal: string;
-            timeout: number | string | Date;
+            timeout: number | string | Date | DurationLike | InstantLike | ZonedDateTimeLike;
             onConflict: "replace" | "fail";
           }) => Promise<{
             signal: string;
@@ -91,7 +93,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 +151,10 @@ 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;
         };
-        events: AsTuple<Simplify<EventPayload>>;
-        runId: string;
         group: ReturnType<typeof createGroupTools>;
         attempt: number;
         maxAttempts?: number | undefined;
@@ -234,7 +234,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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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"}

package/components/middleware/utils.cjs

@@ -1,9 +1,10 @@
 const require_types = require('../../types.cjs');
 const require_types$1 = require('../../helpers/types.cjs');
+const require_temporal = require('../../helpers/temporal.cjs');
 
 //#region src/components/middleware/utils.ts
-function isTimeStrInput(value) {
-	return typeof value === "string" || typeof value === "number" || value instanceof Date;
+function isSleepInput(value) {
+	return typeof value === "string" || typeof value === "number" || value instanceof Date || require_temporal.isTemporalDuration(value);
 }
 /**
 * Build an onion-style middleware chain for `wrapSendEvent`.
@@ -109,7 +110,7 @@ var UnreachableError = class extends Error {
 exports.UnreachableError = UnreachableError;
 exports.buildWrapRequestChain = buildWrapRequestChain;
 exports.buildWrapSendEventChain = buildWrapSendEventChain;
-exports.isTimeStrInput = isTimeStrInput;
+exports.isSleepInput = isSleepInput;
 exports.optsFromStepInput = optsFromStepInput;
 exports.stepInputFromOpts = stepInputFromOpts;
 exports.stepTypeFromOpCode = stepTypeFromOpCode;

package/components/middleware/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["chain: () => Promise<SendEventBaseOutput>","chain: () => Promise<Middleware.Response>","StepOpCode","isRecord"],"sources":["../../../src/components/middleware/utils.ts"],"sourcesContent":["import { isRecord } from \"../../helpers/types\";\nimport type { Logger } from \"../../middleware/logger\";\nimport { type SendEventBaseOutput, StepOpCode } from \"../../types\";\nimport type { InngestFunction } from \"../InngestFunction\";\nimport type { Middleware } from \"./middleware\";\nimport type { ExtractLiteralStrings } from \"./types\";\n\nexport function isTimeStrInput(\n  value: unknown,\n): value is string | number | Date {\n  return (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    value instanceof Date\n  );\n}\n\n/**\n * Build an onion-style middleware chain for `wrapSendEvent`.\n *\n * Same pattern as `buildWrapRequestChain` but wraps the outgoing HTTP call\n * in `client.send()` instead of the incoming execution request.\n */\nexport function buildWrapSendEventChain(\n  middleware: Middleware.BaseMiddleware[],\n  handler: () => Promise<SendEventBaseOutput>,\n  payloads: Middleware.WrapSendEventArgs[\"events\"],\n  fn: InngestFunction.Any | null,\n): () => Promise<SendEventBaseOutput> {\n  let chain: () => Promise<SendEventBaseOutput> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapSendEvent) {\n      const next = chain;\n      chain = () => mw.wrapSendEvent!({ next, events: payloads, fn });\n    }\n  }\n  return chain;\n}\n\n/**\n * Build an onion-style middleware chain for `wrapRequest`.\n *\n * Iterates in reverse order (so first middleware is outermost)\n * and returns a zero-arg function that kicks off the chain.\n */\nexport function buildWrapRequestChain({\n  fn,\n  handler,\n  middleware,\n  requestArgs,\n  requestInfo,\n  runId,\n}: {\n  fn: InngestFunction.Any | null;\n  handler: () => Promise<Middleware.Response>;\n  middleware: Middleware.BaseMiddleware[];\n  requestArgs: readonly unknown[];\n  requestInfo: Middleware.Request;\n  runId: string;\n}): () => Promise<Middleware.Response> {\n  let chain: () => Promise<Middleware.Response> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapRequest) {\n      const next = chain;\n      chain = () =>\n        mw.wrapRequest!({ next, requestArgs, requestInfo, runId, fn });\n    }\n  }\n  return chain;\n}\n\n// Replace the \"and can be any string\" union member with \"unknown\". This\n// improves static type safety within `stepTypeFromOpCode`, since it ensures we\n// aren't returning any unknown StepType besides \"unknown\". We should never\n// actually return \"unknown\" at runtime, but we need a default\ntype StepTypeFromOpCodeReturn =\n  | ExtractLiteralStrings<Middleware.StepType>\n  | \"unknown\";\n\n/**\n * Convert an opcode (from the op) to a step type.\n */\nexport function stepTypeFromOpCode(\n  op: StepOpCode,\n  opts: Record<string, unknown> | undefined,\n  logger: Logger,\n): StepTypeFromOpCodeReturn {\n  if (op === StepOpCode.AiGateway) {\n    if (opts?.type === \"step.ai.infer\") {\n      return \"ai.infer\";\n    }\n    if (opts?.type === \"step.ai.wrap\") {\n      return \"ai.wrap\";\n    }\n  } else if (op === StepOpCode.Gateway) {\n    return \"fetch\";\n  } else if (op === StepOpCode.InvokeFunction) {\n    return \"invoke\";\n  } else if (op === StepOpCode.StepPlanned) {\n    if (opts?.type === undefined) {\n      return \"run\";\n    }\n    if (opts?.type === \"step.sendEvent\") {\n      return \"sendEvent\";\n    }\n    if (opts?.type === \"step.realtime.publish\") {\n      return \"realtime.publish\";\n    }\n    if (opts?.type === \"group.experiment\") {\n      return \"group.experiment\";\n    }\n  } else if (op === StepOpCode.Sleep) {\n    return \"sleep\";\n  } else if (op === StepOpCode.WaitForEvent) {\n    return \"waitForEvent\";\n  }\n\n  logger.warn({ op, type: opts?.type }, \"Unknown step type\");\n  return \"unknown\";\n}\n\n/**\n * Convert the opts object (from the op) to a step input array.\n *\n * Paired with `optsFromStepInput` which reverses this for step kinds that\n * wrap the entire opts as `[opts]`.\n */\nexport function stepInputFromOpts(\n  stepType: Middleware.StepType,\n  opts?: Record<string, unknown>,\n): unknown[] | undefined {\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    return [opts];\n  }\n  if (Array.isArray(opts?.input)) {\n    return opts.input;\n  }\n  return undefined;\n}\n\n/**\n * Reverse of `stepInputFromOpts`: given middleware-transformed input, derive\n * the opts to use in the outgoing op.\n *\n * Returns undefined when the step kind doesn't derive opts from input.\n */\nexport function optsFromStepInput(\n  stepType: Middleware.StepType,\n  input: unknown[] | undefined,\n): Record<string, unknown> | undefined {\n  if (input === undefined) {\n    return undefined;\n  }\n\n  // Step types where stepInputFromOpts wraps the entire opts as [opts]\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    const opts = input[0];\n    if (isRecord(opts)) {\n      return opts;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * An error that is thrown when a code path is unreachable. Should never be\n * thrown at runtime.\n */\nexport class UnreachableError extends Error {\n  constructor(...args: Parameters<typeof Error>) {\n    super(...args);\n    this.name = this.constructor.name;\n  }\n}\n"],"mappings":";;;;AAOA,SAAgB,eACd,OACiC;AACjC,QACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,iBAAiB;;;;;;;;AAUrB,SAAgB,wBACd,YACA,SACA,UACA,IACoC;CACpC,IAAIA,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,eAAe;GACrB,MAAM,OAAO;AACb,iBAAc,GAAG,cAAe;IAAE;IAAM,QAAQ;IAAU;IAAI,CAAC;;;AAGnE,QAAO;;;;;;;;AAST,SAAgB,sBAAsB,EACpC,IACA,SACA,YACA,aACA,aACA,SAQqC;CACrC,IAAIC,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,aAAa;GACnB,MAAM,OAAO;AACb,iBACE,GAAG,YAAa;IAAE;IAAM;IAAa;IAAa;IAAO;IAAI,CAAC;;;AAGpE,QAAO;;;;;AAcT,SAAgB,mBACd,IACA,MACA,QAC0B;AAC1B,KAAI,OAAOC,yBAAW,WAAW;AAC/B,MAAI,MAAM,SAAS,gBACjB,QAAO;AAET,MAAI,MAAM,SAAS,eACjB,QAAO;YAEA,OAAOA,yBAAW,QAC3B,QAAO;UACE,OAAOA,yBAAW,eAC3B,QAAO;UACE,OAAOA,yBAAW,aAAa;AACxC,MAAI,MAAM,SAAS,OACjB,QAAO;AAET,MAAI,MAAM,SAAS,iBACjB,QAAO;AAET,MAAI,MAAM,SAAS,wBACjB,QAAO;AAET,MAAI,MAAM,SAAS,mBACjB,QAAO;YAEA,OAAOA,yBAAW,MAC3B,QAAO;UACE,OAAOA,yBAAW,aAC3B,QAAO;AAGT,QAAO,KAAK;EAAE;EAAI,MAAM,MAAM;EAAM,EAAE,oBAAoB;AAC1D,QAAO;;;;;;;;AAST,SAAgB,kBACd,UACA,MACuB;AACvB,KAAI,aAAa,YAAY,aAAa,eACxC,QAAO,CAAC,KAAK;AAEf,KAAI,MAAM,QAAQ,MAAM,MAAM,CAC5B,QAAO,KAAK;;;;;;;;AAWhB,SAAgB,kBACd,UACA,OACqC;AACrC,KAAI,UAAU,OACZ;AAIF,KAAI,aAAa,YAAY,aAAa,gBAAgB;EACxD,MAAM,OAAO,MAAM;AACnB,MAAIC,yBAAS,KAAK,CAChB,QAAO;;;;;;;AAWb,IAAa,mBAAb,cAAsC,MAAM;CAC1C,YAAY,GAAG,MAAgC;AAC7C,QAAM,GAAG,KAAK;AACd,OAAK,OAAO,KAAK,YAAY"}
+{"version":3,"file":"utils.cjs","names":["isTemporalDuration","chain: () => Promise<SendEventBaseOutput>","chain: () => Promise<Middleware.Response>","StepOpCode","isRecord"],"sources":["../../../src/components/middleware/utils.ts"],"sourcesContent":["import { type DurationLike, isTemporalDuration } from \"../../helpers/temporal\";\nimport { isRecord } from \"../../helpers/types\";\nimport type { Logger } from \"../../middleware/logger\";\nimport { type SendEventBaseOutput, StepOpCode } from \"../../types\";\nimport type { InngestFunction } from \"../InngestFunction\";\nimport type { Middleware } from \"./middleware\";\nimport type { ExtractLiteralStrings } from \"./types\";\n\nexport function isSleepInput(\n  value: unknown,\n): value is string | number | Date | DurationLike {\n  return (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    value instanceof Date ||\n    isTemporalDuration(value)\n  );\n}\n\n/**\n * Build an onion-style middleware chain for `wrapSendEvent`.\n *\n * Same pattern as `buildWrapRequestChain` but wraps the outgoing HTTP call\n * in `client.send()` instead of the incoming execution request.\n */\nexport function buildWrapSendEventChain(\n  middleware: Middleware.BaseMiddleware[],\n  handler: () => Promise<SendEventBaseOutput>,\n  payloads: Middleware.WrapSendEventArgs[\"events\"],\n  fn: InngestFunction.Any | null,\n): () => Promise<SendEventBaseOutput> {\n  let chain: () => Promise<SendEventBaseOutput> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapSendEvent) {\n      const next = chain;\n      chain = () => mw.wrapSendEvent!({ next, events: payloads, fn });\n    }\n  }\n  return chain;\n}\n\n/**\n * Build an onion-style middleware chain for `wrapRequest`.\n *\n * Iterates in reverse order (so first middleware is outermost)\n * and returns a zero-arg function that kicks off the chain.\n */\nexport function buildWrapRequestChain({\n  fn,\n  handler,\n  middleware,\n  requestArgs,\n  requestInfo,\n  runId,\n}: {\n  fn: InngestFunction.Any | null;\n  handler: () => Promise<Middleware.Response>;\n  middleware: Middleware.BaseMiddleware[];\n  requestArgs: readonly unknown[];\n  requestInfo: Middleware.Request;\n  runId: string;\n}): () => Promise<Middleware.Response> {\n  let chain: () => Promise<Middleware.Response> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapRequest) {\n      const next = chain;\n      chain = () =>\n        mw.wrapRequest!({ next, requestArgs, requestInfo, runId, fn });\n    }\n  }\n  return chain;\n}\n\n// Replace the \"and can be any string\" union member with \"unknown\". This\n// improves static type safety within `stepTypeFromOpCode`, since it ensures we\n// aren't returning any unknown StepType besides \"unknown\". We should never\n// actually return \"unknown\" at runtime, but we need a default\ntype StepTypeFromOpCodeReturn =\n  | ExtractLiteralStrings<Middleware.StepType>\n  | \"unknown\";\n\n/**\n * Convert an opcode (from the op) to a step type.\n */\nexport function stepTypeFromOpCode(\n  op: StepOpCode,\n  opts: Record<string, unknown> | undefined,\n  logger: Logger,\n): StepTypeFromOpCodeReturn {\n  if (op === StepOpCode.AiGateway) {\n    if (opts?.type === \"step.ai.infer\") {\n      return \"ai.infer\";\n    }\n    if (opts?.type === \"step.ai.wrap\") {\n      return \"ai.wrap\";\n    }\n  } else if (op === StepOpCode.Gateway) {\n    return \"fetch\";\n  } else if (op === StepOpCode.InvokeFunction) {\n    return \"invoke\";\n  } else if (op === StepOpCode.StepPlanned) {\n    if (opts?.type === undefined) {\n      return \"run\";\n    }\n    if (opts?.type === \"step.sendEvent\") {\n      return \"sendEvent\";\n    }\n    if (opts?.type === \"step.realtime.publish\") {\n      return \"realtime.publish\";\n    }\n    if (opts?.type === \"group.experiment\") {\n      return \"group.experiment\";\n    }\n  } else if (op === StepOpCode.Sleep) {\n    return \"sleep\";\n  } else if (op === StepOpCode.WaitForEvent) {\n    return \"waitForEvent\";\n  }\n\n  logger.warn({ op, type: opts?.type }, \"Unknown step type\");\n  return \"unknown\";\n}\n\n/**\n * Convert the opts object (from the op) to a step input array.\n *\n * Paired with `optsFromStepInput` which reverses this for step kinds that\n * wrap the entire opts as `[opts]`.\n */\nexport function stepInputFromOpts(\n  stepType: Middleware.StepType,\n  opts?: Record<string, unknown>,\n): unknown[] | undefined {\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    return [opts];\n  }\n  if (Array.isArray(opts?.input)) {\n    return opts.input;\n  }\n  return undefined;\n}\n\n/**\n * Reverse of `stepInputFromOpts`: given middleware-transformed input, derive\n * the opts to use in the outgoing op.\n *\n * Returns undefined when the step kind doesn't derive opts from input.\n */\nexport function optsFromStepInput(\n  stepType: Middleware.StepType,\n  input: unknown[] | undefined,\n): Record<string, unknown> | undefined {\n  if (input === undefined) {\n    return undefined;\n  }\n\n  // Step types where stepInputFromOpts wraps the entire opts as [opts]\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    const opts = input[0];\n    if (isRecord(opts)) {\n      return opts;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * An error that is thrown when a code path is unreachable. Should never be\n * thrown at runtime.\n */\nexport class UnreachableError extends Error {\n  constructor(...args: Parameters<typeof Error>) {\n    super(...args);\n    this.name = this.constructor.name;\n  }\n}\n"],"mappings":";;;;;AAQA,SAAgB,aACd,OACgD;AAChD,QACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,iBAAiB,QACjBA,oCAAmB,MAAM;;;;;;;;AAU7B,SAAgB,wBACd,YACA,SACA,UACA,IACoC;CACpC,IAAIC,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,eAAe;GACrB,MAAM,OAAO;AACb,iBAAc,GAAG,cAAe;IAAE;IAAM,QAAQ;IAAU;IAAI,CAAC;;;AAGnE,QAAO;;;;;;;;AAST,SAAgB,sBAAsB,EACpC,IACA,SACA,YACA,aACA,aACA,SAQqC;CACrC,IAAIC,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,aAAa;GACnB,MAAM,OAAO;AACb,iBACE,GAAG,YAAa;IAAE;IAAM;IAAa;IAAa;IAAO;IAAI,CAAC;;;AAGpE,QAAO;;;;;AAcT,SAAgB,mBACd,IACA,MACA,QAC0B;AAC1B,KAAI,OAAOC,yBAAW,WAAW;AAC/B,MAAI,MAAM,SAAS,gBACjB,QAAO;AAET,MAAI,MAAM,SAAS,eACjB,QAAO;YAEA,OAAOA,yBAAW,QAC3B,QAAO;UACE,OAAOA,yBAAW,eAC3B,QAAO;UACE,OAAOA,yBAAW,aAAa;AACxC,MAAI,MAAM,SAAS,OACjB,QAAO;AAET,MAAI,MAAM,SAAS,iBACjB,QAAO;AAET,MAAI,MAAM,SAAS,wBACjB,QAAO;AAET,MAAI,MAAM,SAAS,mBACjB,QAAO;YAEA,OAAOA,yBAAW,MAC3B,QAAO;UACE,OAAOA,yBAAW,aAC3B,QAAO;AAGT,QAAO,KAAK;EAAE;EAAI,MAAM,MAAM;EAAM,EAAE,oBAAoB;AAC1D,QAAO;;;;;;;;AAST,SAAgB,kBACd,UACA,MACuB;AACvB,KAAI,aAAa,YAAY,aAAa,eACxC,QAAO,CAAC,KAAK;AAEf,KAAI,MAAM,QAAQ,MAAM,MAAM,CAC5B,QAAO,KAAK;;;;;;;;AAWhB,SAAgB,kBACd,UACA,OACqC;AACrC,KAAI,UAAU,OACZ;AAIF,KAAI,aAAa,YAAY,aAAa,gBAAgB;EACxD,MAAM,OAAO,MAAM;AACnB,MAAIC,yBAAS,KAAK,CAChB,QAAO;;;;;;;AAWb,IAAa,mBAAb,cAAsC,MAAM;CAC1C,YAAY,GAAG,MAAgC;AAC7C,QAAM,GAAG,KAAK;AACd,OAAK,OAAO,KAAK,YAAY"}

package/components/middleware/utils.js

@@ -1,9 +1,10 @@
 import { StepOpCode } from "../../types.js";
 import { isRecord } from "../../helpers/types.js";
+import { isTemporalDuration } from "../../helpers/temporal.js";
 
 //#region src/components/middleware/utils.ts
-function isTimeStrInput(value) {
-	return typeof value === "string" || typeof value === "number" || value instanceof Date;
+function isSleepInput(value) {
+	return typeof value === "string" || typeof value === "number" || value instanceof Date || isTemporalDuration(value);
 }
 /**
 * Build an onion-style middleware chain for `wrapSendEvent`.
@@ -106,5 +107,5 @@ var UnreachableError = class extends Error {
 };
 
 //#endregion
-export { UnreachableError, buildWrapRequestChain, buildWrapSendEventChain, isTimeStrInput, optsFromStepInput, stepInputFromOpts, stepTypeFromOpCode };
+export { UnreachableError, buildWrapRequestChain, buildWrapSendEventChain, isSleepInput, optsFromStepInput, stepInputFromOpts, stepTypeFromOpCode };
 //# sourceMappingURL=utils.js.map

package/components/middleware/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":["chain: () => Promise<SendEventBaseOutput>","chain: () => Promise<Middleware.Response>"],"sources":["../../../src/components/middleware/utils.ts"],"sourcesContent":["import { isRecord } from \"../../helpers/types\";\nimport type { Logger } from \"../../middleware/logger\";\nimport { type SendEventBaseOutput, StepOpCode } from \"../../types\";\nimport type { InngestFunction } from \"../InngestFunction\";\nimport type { Middleware } from \"./middleware\";\nimport type { ExtractLiteralStrings } from \"./types\";\n\nexport function isTimeStrInput(\n  value: unknown,\n): value is string | number | Date {\n  return (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    value instanceof Date\n  );\n}\n\n/**\n * Build an onion-style middleware chain for `wrapSendEvent`.\n *\n * Same pattern as `buildWrapRequestChain` but wraps the outgoing HTTP call\n * in `client.send()` instead of the incoming execution request.\n */\nexport function buildWrapSendEventChain(\n  middleware: Middleware.BaseMiddleware[],\n  handler: () => Promise<SendEventBaseOutput>,\n  payloads: Middleware.WrapSendEventArgs[\"events\"],\n  fn: InngestFunction.Any | null,\n): () => Promise<SendEventBaseOutput> {\n  let chain: () => Promise<SendEventBaseOutput> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapSendEvent) {\n      const next = chain;\n      chain = () => mw.wrapSendEvent!({ next, events: payloads, fn });\n    }\n  }\n  return chain;\n}\n\n/**\n * Build an onion-style middleware chain for `wrapRequest`.\n *\n * Iterates in reverse order (so first middleware is outermost)\n * and returns a zero-arg function that kicks off the chain.\n */\nexport function buildWrapRequestChain({\n  fn,\n  handler,\n  middleware,\n  requestArgs,\n  requestInfo,\n  runId,\n}: {\n  fn: InngestFunction.Any | null;\n  handler: () => Promise<Middleware.Response>;\n  middleware: Middleware.BaseMiddleware[];\n  requestArgs: readonly unknown[];\n  requestInfo: Middleware.Request;\n  runId: string;\n}): () => Promise<Middleware.Response> {\n  let chain: () => Promise<Middleware.Response> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapRequest) {\n      const next = chain;\n      chain = () =>\n        mw.wrapRequest!({ next, requestArgs, requestInfo, runId, fn });\n    }\n  }\n  return chain;\n}\n\n// Replace the \"and can be any string\" union member with \"unknown\". This\n// improves static type safety within `stepTypeFromOpCode`, since it ensures we\n// aren't returning any unknown StepType besides \"unknown\". We should never\n// actually return \"unknown\" at runtime, but we need a default\ntype StepTypeFromOpCodeReturn =\n  | ExtractLiteralStrings<Middleware.StepType>\n  | \"unknown\";\n\n/**\n * Convert an opcode (from the op) to a step type.\n */\nexport function stepTypeFromOpCode(\n  op: StepOpCode,\n  opts: Record<string, unknown> | undefined,\n  logger: Logger,\n): StepTypeFromOpCodeReturn {\n  if (op === StepOpCode.AiGateway) {\n    if (opts?.type === \"step.ai.infer\") {\n      return \"ai.infer\";\n    }\n    if (opts?.type === \"step.ai.wrap\") {\n      return \"ai.wrap\";\n    }\n  } else if (op === StepOpCode.Gateway) {\n    return \"fetch\";\n  } else if (op === StepOpCode.InvokeFunction) {\n    return \"invoke\";\n  } else if (op === StepOpCode.StepPlanned) {\n    if (opts?.type === undefined) {\n      return \"run\";\n    }\n    if (opts?.type === \"step.sendEvent\") {\n      return \"sendEvent\";\n    }\n    if (opts?.type === \"step.realtime.publish\") {\n      return \"realtime.publish\";\n    }\n    if (opts?.type === \"group.experiment\") {\n      return \"group.experiment\";\n    }\n  } else if (op === StepOpCode.Sleep) {\n    return \"sleep\";\n  } else if (op === StepOpCode.WaitForEvent) {\n    return \"waitForEvent\";\n  }\n\n  logger.warn({ op, type: opts?.type }, \"Unknown step type\");\n  return \"unknown\";\n}\n\n/**\n * Convert the opts object (from the op) to a step input array.\n *\n * Paired with `optsFromStepInput` which reverses this for step kinds that\n * wrap the entire opts as `[opts]`.\n */\nexport function stepInputFromOpts(\n  stepType: Middleware.StepType,\n  opts?: Record<string, unknown>,\n): unknown[] | undefined {\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    return [opts];\n  }\n  if (Array.isArray(opts?.input)) {\n    return opts.input;\n  }\n  return undefined;\n}\n\n/**\n * Reverse of `stepInputFromOpts`: given middleware-transformed input, derive\n * the opts to use in the outgoing op.\n *\n * Returns undefined when the step kind doesn't derive opts from input.\n */\nexport function optsFromStepInput(\n  stepType: Middleware.StepType,\n  input: unknown[] | undefined,\n): Record<string, unknown> | undefined {\n  if (input === undefined) {\n    return undefined;\n  }\n\n  // Step types where stepInputFromOpts wraps the entire opts as [opts]\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    const opts = input[0];\n    if (isRecord(opts)) {\n      return opts;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * An error that is thrown when a code path is unreachable. Should never be\n * thrown at runtime.\n */\nexport class UnreachableError extends Error {\n  constructor(...args: Parameters<typeof Error>) {\n    super(...args);\n    this.name = this.constructor.name;\n  }\n}\n"],"mappings":";;;;AAOA,SAAgB,eACd,OACiC;AACjC,QACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,iBAAiB;;;;;;;;AAUrB,SAAgB,wBACd,YACA,SACA,UACA,IACoC;CACpC,IAAIA,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,eAAe;GACrB,MAAM,OAAO;AACb,iBAAc,GAAG,cAAe;IAAE;IAAM,QAAQ;IAAU;IAAI,CAAC;;;AAGnE,QAAO;;;;;;;;AAST,SAAgB,sBAAsB,EACpC,IACA,SACA,YACA,aACA,aACA,SAQqC;CACrC,IAAIC,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,aAAa;GACnB,MAAM,OAAO;AACb,iBACE,GAAG,YAAa;IAAE;IAAM;IAAa;IAAa;IAAO;IAAI,CAAC;;;AAGpE,QAAO;;;;;AAcT,SAAgB,mBACd,IACA,MACA,QAC0B;AAC1B,KAAI,OAAO,WAAW,WAAW;AAC/B,MAAI,MAAM,SAAS,gBACjB,QAAO;AAET,MAAI,MAAM,SAAS,eACjB,QAAO;YAEA,OAAO,WAAW,QAC3B,QAAO;UACE,OAAO,WAAW,eAC3B,QAAO;UACE,OAAO,WAAW,aAAa;AACxC,MAAI,MAAM,SAAS,OACjB,QAAO;AAET,MAAI,MAAM,SAAS,iBACjB,QAAO;AAET,MAAI,MAAM,SAAS,wBACjB,QAAO;AAET,MAAI,MAAM,SAAS,mBACjB,QAAO;YAEA,OAAO,WAAW,MAC3B,QAAO;UACE,OAAO,WAAW,aAC3B,QAAO;AAGT,QAAO,KAAK;EAAE;EAAI,MAAM,MAAM;EAAM,EAAE,oBAAoB;AAC1D,QAAO;;;;;;;;AAST,SAAgB,kBACd,UACA,MACuB;AACvB,KAAI,aAAa,YAAY,aAAa,eACxC,QAAO,CAAC,KAAK;AAEf,KAAI,MAAM,QAAQ,MAAM,MAAM,CAC5B,QAAO,KAAK;;;;;;;;AAWhB,SAAgB,kBACd,UACA,OACqC;AACrC,KAAI,UAAU,OACZ;AAIF,KAAI,aAAa,YAAY,aAAa,gBAAgB;EACxD,MAAM,OAAO,MAAM;AACnB,MAAI,SAAS,KAAK,CAChB,QAAO;;;;;;;AAWb,IAAa,mBAAb,cAAsC,MAAM;CAC1C,YAAY,GAAG,MAAgC;AAC7C,QAAM,GAAG,KAAK;AACd,OAAK,OAAO,KAAK,YAAY"}
+{"version":3,"file":"utils.js","names":["chain: () => Promise<SendEventBaseOutput>","chain: () => Promise<Middleware.Response>"],"sources":["../../../src/components/middleware/utils.ts"],"sourcesContent":["import { type DurationLike, isTemporalDuration } from \"../../helpers/temporal\";\nimport { isRecord } from \"../../helpers/types\";\nimport type { Logger } from \"../../middleware/logger\";\nimport { type SendEventBaseOutput, StepOpCode } from \"../../types\";\nimport type { InngestFunction } from \"../InngestFunction\";\nimport type { Middleware } from \"./middleware\";\nimport type { ExtractLiteralStrings } from \"./types\";\n\nexport function isSleepInput(\n  value: unknown,\n): value is string | number | Date | DurationLike {\n  return (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    value instanceof Date ||\n    isTemporalDuration(value)\n  );\n}\n\n/**\n * Build an onion-style middleware chain for `wrapSendEvent`.\n *\n * Same pattern as `buildWrapRequestChain` but wraps the outgoing HTTP call\n * in `client.send()` instead of the incoming execution request.\n */\nexport function buildWrapSendEventChain(\n  middleware: Middleware.BaseMiddleware[],\n  handler: () => Promise<SendEventBaseOutput>,\n  payloads: Middleware.WrapSendEventArgs[\"events\"],\n  fn: InngestFunction.Any | null,\n): () => Promise<SendEventBaseOutput> {\n  let chain: () => Promise<SendEventBaseOutput> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapSendEvent) {\n      const next = chain;\n      chain = () => mw.wrapSendEvent!({ next, events: payloads, fn });\n    }\n  }\n  return chain;\n}\n\n/**\n * Build an onion-style middleware chain for `wrapRequest`.\n *\n * Iterates in reverse order (so first middleware is outermost)\n * and returns a zero-arg function that kicks off the chain.\n */\nexport function buildWrapRequestChain({\n  fn,\n  handler,\n  middleware,\n  requestArgs,\n  requestInfo,\n  runId,\n}: {\n  fn: InngestFunction.Any | null;\n  handler: () => Promise<Middleware.Response>;\n  middleware: Middleware.BaseMiddleware[];\n  requestArgs: readonly unknown[];\n  requestInfo: Middleware.Request;\n  runId: string;\n}): () => Promise<Middleware.Response> {\n  let chain: () => Promise<Middleware.Response> = handler;\n  for (let i = middleware.length - 1; i >= 0; i--) {\n    const mw = middleware[i];\n    if (mw?.wrapRequest) {\n      const next = chain;\n      chain = () =>\n        mw.wrapRequest!({ next, requestArgs, requestInfo, runId, fn });\n    }\n  }\n  return chain;\n}\n\n// Replace the \"and can be any string\" union member with \"unknown\". This\n// improves static type safety within `stepTypeFromOpCode`, since it ensures we\n// aren't returning any unknown StepType besides \"unknown\". We should never\n// actually return \"unknown\" at runtime, but we need a default\ntype StepTypeFromOpCodeReturn =\n  | ExtractLiteralStrings<Middleware.StepType>\n  | \"unknown\";\n\n/**\n * Convert an opcode (from the op) to a step type.\n */\nexport function stepTypeFromOpCode(\n  op: StepOpCode,\n  opts: Record<string, unknown> | undefined,\n  logger: Logger,\n): StepTypeFromOpCodeReturn {\n  if (op === StepOpCode.AiGateway) {\n    if (opts?.type === \"step.ai.infer\") {\n      return \"ai.infer\";\n    }\n    if (opts?.type === \"step.ai.wrap\") {\n      return \"ai.wrap\";\n    }\n  } else if (op === StepOpCode.Gateway) {\n    return \"fetch\";\n  } else if (op === StepOpCode.InvokeFunction) {\n    return \"invoke\";\n  } else if (op === StepOpCode.StepPlanned) {\n    if (opts?.type === undefined) {\n      return \"run\";\n    }\n    if (opts?.type === \"step.sendEvent\") {\n      return \"sendEvent\";\n    }\n    if (opts?.type === \"step.realtime.publish\") {\n      return \"realtime.publish\";\n    }\n    if (opts?.type === \"group.experiment\") {\n      return \"group.experiment\";\n    }\n  } else if (op === StepOpCode.Sleep) {\n    return \"sleep\";\n  } else if (op === StepOpCode.WaitForEvent) {\n    return \"waitForEvent\";\n  }\n\n  logger.warn({ op, type: opts?.type }, \"Unknown step type\");\n  return \"unknown\";\n}\n\n/**\n * Convert the opts object (from the op) to a step input array.\n *\n * Paired with `optsFromStepInput` which reverses this for step kinds that\n * wrap the entire opts as `[opts]`.\n */\nexport function stepInputFromOpts(\n  stepType: Middleware.StepType,\n  opts?: Record<string, unknown>,\n): unknown[] | undefined {\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    return [opts];\n  }\n  if (Array.isArray(opts?.input)) {\n    return opts.input;\n  }\n  return undefined;\n}\n\n/**\n * Reverse of `stepInputFromOpts`: given middleware-transformed input, derive\n * the opts to use in the outgoing op.\n *\n * Returns undefined when the step kind doesn't derive opts from input.\n */\nexport function optsFromStepInput(\n  stepType: Middleware.StepType,\n  input: unknown[] | undefined,\n): Record<string, unknown> | undefined {\n  if (input === undefined) {\n    return undefined;\n  }\n\n  // Step types where stepInputFromOpts wraps the entire opts as [opts]\n  if (stepType === \"invoke\" || stepType === \"waitForEvent\") {\n    const opts = input[0];\n    if (isRecord(opts)) {\n      return opts;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * An error that is thrown when a code path is unreachable. Should never be\n * thrown at runtime.\n */\nexport class UnreachableError extends Error {\n  constructor(...args: Parameters<typeof Error>) {\n    super(...args);\n    this.name = this.constructor.name;\n  }\n}\n"],"mappings":";;;;;AAQA,SAAgB,aACd,OACgD;AAChD,QACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,iBAAiB,QACjB,mBAAmB,MAAM;;;;;;;;AAU7B,SAAgB,wBACd,YACA,SACA,UACA,IACoC;CACpC,IAAIA,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,eAAe;GACrB,MAAM,OAAO;AACb,iBAAc,GAAG,cAAe;IAAE;IAAM,QAAQ;IAAU;IAAI,CAAC;;;AAGnE,QAAO;;;;;;;;AAST,SAAgB,sBAAsB,EACpC,IACA,SACA,YACA,aACA,aACA,SAQqC;CACrC,IAAIC,QAA4C;AAChD,MAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;EAC/C,MAAM,KAAK,WAAW;AACtB,MAAI,IAAI,aAAa;GACnB,MAAM,OAAO;AACb,iBACE,GAAG,YAAa;IAAE;IAAM;IAAa;IAAa;IAAO;IAAI,CAAC;;;AAGpE,QAAO;;;;;AAcT,SAAgB,mBACd,IACA,MACA,QAC0B;AAC1B,KAAI,OAAO,WAAW,WAAW;AAC/B,MAAI,MAAM,SAAS,gBACjB,QAAO;AAET,MAAI,MAAM,SAAS,eACjB,QAAO;YAEA,OAAO,WAAW,QAC3B,QAAO;UACE,OAAO,WAAW,eAC3B,QAAO;UACE,OAAO,WAAW,aAAa;AACxC,MAAI,MAAM,SAAS,OACjB,QAAO;AAET,MAAI,MAAM,SAAS,iBACjB,QAAO;AAET,MAAI,MAAM,SAAS,wBACjB,QAAO;AAET,MAAI,MAAM,SAAS,mBACjB,QAAO;YAEA,OAAO,WAAW,MAC3B,QAAO;UACE,OAAO,WAAW,aAC3B,QAAO;AAGT,QAAO,KAAK;EAAE;EAAI,MAAM,MAAM;EAAM,EAAE,oBAAoB;AAC1D,QAAO;;;;;;;;AAST,SAAgB,kBACd,UACA,MACuB;AACvB,KAAI,aAAa,YAAY,aAAa,eACxC,QAAO,CAAC,KAAK;AAEf,KAAI,MAAM,QAAQ,MAAM,MAAM,CAC5B,QAAO,KAAK;;;;;;;;AAWhB,SAAgB,kBACd,UACA,OACqC;AACrC,KAAI,UAAU,OACZ;AAIF,KAAI,aAAa,YAAY,aAAa,gBAAgB;EACxD,MAAM,OAAO,MAAM;AACnB,MAAI,SAAS,KAAK,CAChB,QAAO;;;;;;;AAWb,IAAa,mBAAb,cAAsC,MAAM;CAC1C,YAAY,GAAG,MAAgC;AAC7C,QAAM,GAAG,KAAK;AACd,OAAK,OAAO,KAAK,YAAY"}

package/components/realtime/types.d.cts

@@ -64,7 +64,7 @@ declare namespace Realtime {
     stream_id: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<["step", "run", "data", "ping", "pong", "closing", "event", "sub", "unsub", "datastream-start", "datastream-end", "chunk"]>;
   }, "strip", z.ZodTypeAny, {
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     data?: any;
     topic?: string | undefined;
@@ -74,7 +74,7 @@ declare namespace Realtime {
     env_id?: string | undefined;
     stream_id?: string | undefined;
   }, {
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     data?: any;
     topic?: string | undefined;
@@ -85,7 +85,7 @@ declare namespace Realtime {
     stream_id?: string | undefined;
   }>, {
     data: any;
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     topic?: string | undefined;
     run_id?: string | undefined;
@@ -94,7 +94,7 @@ declare namespace Realtime {
     env_id?: string | undefined;
     stream_id?: string | undefined;
   }, {
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     data?: any;
     topic?: string | undefined;

package/components/realtime/types.d.cts.map

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

package/components/realtime/types.d.ts

@@ -64,7 +64,7 @@ declare namespace Realtime {
     stream_id: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<["step", "run", "data", "ping", "pong", "closing", "event", "sub", "unsub", "datastream-start", "datastream-end", "chunk"]>;
   }, "strip", z.ZodTypeAny, {
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     data?: any;
     topic?: string | undefined;
@@ -74,7 +74,7 @@ declare namespace Realtime {
     env_id?: string | undefined;
     stream_id?: string | undefined;
   }, {
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     data?: any;
     topic?: string | undefined;
@@ -85,7 +85,7 @@ declare namespace Realtime {
     stream_id?: string | undefined;
   }>, {
     data: any;
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     topic?: string | undefined;
     run_id?: string | undefined;
@@ -94,7 +94,7 @@ declare namespace Realtime {
     env_id?: string | undefined;
     stream_id?: string | undefined;
   }, {
-    kind: "data" | "event" | "run" | "step" | "ping" | "pong" | "closing" | "sub" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
+    kind: "data" | "event" | "run" | "step" | "sub" | "ping" | "pong" | "closing" | "unsub" | "datastream-start" | "datastream-end" | "chunk";
     channel?: string | undefined;
     data?: any;
     topic?: string | undefined;