allow specifying deps for inline run step

Author: ianmacartney

src/client/step.ts

@@ -48,7 +48,7 @@ export type StepRequest<DM extends GenericDataModel = GenericDataModel> = {
     | {
         kind: "inline";
         handler: (ctx: GenericMutationCtx<DM>) => Promise<unknown>;
-        args: Record<string, never>;
+        args: Record<string, unknown>;
       };
   retry: RetryBehavior | boolean | undefined;
   inline: boolean;

src/client/stepContext.test.ts

@@ -645,4 +645,68 @@ describe("StepExecutor + WorkflowCtx integration", () => {
       /Cannot call step methods inside a step\.run\(\) handler/,
     );
   });
+
+  it("ctx.run() journals deps and replays when they match", async () => {
+    const channel = new BaseChannel<StepRequest>(0);
+    const ctx = createWorkflowCtx("wf-20" as any, channel);
+
+    const entry = journalEntry({
+      name: "run",
+      functionType: "mutation",
+      handle: "inline",
+      args: { userId: "u1", count: 3 },
+      runResult: { kind: "success", returnValue: "done" },
+    });
+
+    const [result] = await Promise.all([
+      ctx.run(async () => "done", {
+        deps: { userId: "u1", count: 3 },
+      }),
+      replayFromJournal(channel, [entry]),
+    ]);
+
+    expect(result).toBe("done");
+  });
+
+  it("ctx.run() sends deps through the channel as args", async () => {
+    const channel = new BaseChannel<StepRequest>(0);
+    const ctx = createWorkflowCtx("wf-21" as any, channel);
+
+    const deps = { userId: "u1", count: 3 };
+
+    // Read the message from the channel and verify the args match deps.
+    const inspectMessage = async () => {
+      const message = await channel.get();
+      expect(message.target.args).toEqual(deps);
+      expect(message.target.kind).toBe("inline");
+      message.resolve({ kind: "success", returnValue: "ok" });
+    };
+
+    const [result] = await Promise.all([
+      ctx.run(async () => "ok", { deps }),
+      inspectMessage(),
+    ]);
+
+    expect(result).toBe("ok");
+  });
+
+  it("ctx.run() without deps still journals empty args", async () => {
+    const channel = new BaseChannel<StepRequest>(0);
+    const ctx = createWorkflowCtx("wf-22" as any, channel);
+
+    const entry = journalEntry({
+      name: "run",
+      functionType: "mutation",
+      handle: "inline",
+      args: {},
+      runResult: { kind: "success", returnValue: 42 },
+    });
+
+    const [result] = await Promise.all([
+      ctx.run(async () => 42),
+      replayFromJournal(channel, [entry]),
+    ]);
+
+    expect(result).toBe(42);
+  });
 });

src/client/workflowContext.ts

@@ -131,11 +131,21 @@ export type WorkflowCtx<DataModel extends GenericDataModel = GenericDataModel> =
      * ```
      *
      * @param handler - A function receiving the mutation context to run inline.
-     * @param opts - Options for naming the step.
+     * @param opts - Options for naming the step and declaring dependencies.
      */
     run<T>(
       handler: (ctx: GenericMutationCtx<DataModel>) => T | Promise<T>,
-      opts?: { name?: string },
+      opts?: {
+        name?: string;
+        /**
+         * Dependencies that are validated and journaled as part of this step.
+         * On replay, the saved deps are compared against the current deps —
+         * if they differ, the workflow detects a mismatch and re-executes.
+         * Use this to capture values from the enclosing scope that the handler
+         * depends on.
+         */
+        deps?: Record<string, unknown>;
+      },
     ): Promise<T>;
 
     /**
@@ -223,7 +233,7 @@ export function createWorkflowCtx<
               inlineDepth--;
             }
           },
-          args: {} as Record<string, never>,
+          args: opts?.deps ?? {},
         },
         retry: undefined,
         inline: true,