Add support for "use step" functions in class instance methods (#777)

Added support for `"use step"` directive in class instance methods, allowing instance methods to be used as workflow steps.

### What changed?

- Modified the SWC plugin to recognize and transform instance methods with the "use step" directive
- Added registration logic for instance method steps using `ClassName.prototype.methodName`
- Implemented proper serialization of class instances to preserve the `this` context across workflow/step boundaries
- Added comprehensive end-to-end tests for instance method steps
- Updated error handling to allow "use step" in instance methods while still preventing "use workflow" in instance methods

### How to test?

The PR includes a new end-to-end test `instanceMethodStepWorkflow` that demonstrates the functionality:

1. Run the e2e tests to verify the new instance method step functionality
2. The test creates a `Counter` class with instance methods marked as steps
3. It verifies that the instance methods can be called as steps with proper serialization of the `this` context
4. It also verifies that multiple instances of the same class can be used independently

### Why make this change?

This change enables a more natural object-oriented programming model when working with workflows. Previously, only static methods, standalone functions, and object methods could be marked as steps. Now, developers can create classes with instance methods that are steps, allowing for better encapsulation and more intuitive code organization. This is particularly useful for complex workflows that need to maintain state across multiple step invocations.

Author: TooTallNate

.changeset/legal-parts-happen.md

@@ -0,0 +1,5 @@
+---
+"@workflow/swc-plugin": patch
+---
+
+Add support for "use step" functions in class instance methods

packages/core/e2e/e2e.test.ts

@@ -1416,6 +1416,62 @@ describe('e2e', () => {
     }
   );
 
+  test(
+    'instanceMethodStepWorkflow - instance methods with "use step" directive',
+    { timeout: 60_000 },
+    async () => {
+      // This workflow tests instance methods marked with "use step".
+      // The Counter class has custom serialization so the `this` context
+      // (the Counter instance) can be serialized across the workflow/step boundary.
+      //
+      // instanceMethodStepWorkflow(5) should:
+      // 1. Create Counter(5)
+      // 2. counter.add(10) -> 5 + 10 = 15
+      // 3. counter.multiply(3) -> 5 * 3 = 15
+      // 4. counter.describe('test counter') -> { label: 'test counter', value: 5 }
+      // 5. Create Counter(100), call counter2.add(50) -> 100 + 50 = 150
+      const run = await triggerWorkflow('instanceMethodStepWorkflow', [5]);
+      const returnValue = await getWorkflowReturnValue(run.runId);
+
+      expect(returnValue).toEqual({
+        initialValue: 5,
+        added: 15, // 5 + 10
+        multiplied: 15, // 5 * 3
+        description: { label: 'test counter', value: 5 },
+        added2: 150, // 100 + 50
+      });
+
+      // Verify the run completed successfully
+      const { json: runData } = await cliInspectJson(
+        `runs ${run.runId} --withData`
+      );
+      expect(runData.status).toBe('completed');
+      expect(runData.output).toEqual({
+        initialValue: 5,
+        added: 15,
+        multiplied: 15,
+        description: { label: 'test counter', value: 5 },
+        added2: 150,
+      });
+
+      // Verify the steps were executed (should have 4 steps: add, multiply, describe, add)
+      const { json: steps } = await cliInspectJson(
+        `steps --runId ${run.runId}`
+      );
+      // Filter to only Counter instance method steps
+      const counterSteps = steps.filter(
+        (s: any) =>
+          s.stepName.includes('Counter#add') ||
+          s.stepName.includes('Counter#multiply') ||
+          s.stepName.includes('Counter#describe')
+      );
+      expect(counterSteps.length).toBe(4); // add, multiply, describe, add (from counter2)
+      expect(counterSteps.every((s: any) => s.status === 'completed')).toBe(
+        true
+      );
+    }
+  );
+
   test(
     'crossContextSerdeWorkflow - classes defined in step code are deserializable in workflow context',
     { timeout: 60_000 },

packages/swc-plugin-workflow/spec.md

@@ -42,6 +42,7 @@ Examples:
 - `step//src/jobs/order.ts//fetchData`
 - `step//src/jobs/order.ts//processOrder/innerStep` (nested step)
 - `step//src/jobs/order.ts//MyClass.staticMethod` (static method)
+- `step//src/jobs/order.ts//MyClass#instanceMethod` (instance method)
 - `class//src/models/Point.ts//Point` (serialization class)
 
 ---
@@ -171,6 +172,57 @@ function wrapper(multiplier) {
 registerStepFunction("step//input.js//wrapper/_anonymousStep0", wrapper$_anonymousStep0);
 ```
 
+### Instance Method Step
+
+Instance methods can use `"use step"` if the class provides custom serialization methods. The `this` context is serialized when calling the step and deserialized before execution.
+
+Input:
+```javascript
+import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@vercel/workflow';
+
+export class Counter {
+  static [WORKFLOW_SERIALIZE](instance) {
+    return { value: instance.value };
+  }
+  static [WORKFLOW_DESERIALIZE](data) {
+    return new Counter(data.value);
+  }
+  constructor(value) {
+    this.value = value;
+  }
+  async add(amount) {
+    'use step';
+    return this.value + amount;
+  }
+}
+```
+
+Output:
+```javascript
+import { registerStepFunction } from "workflow/internal/private";
+import { registerSerializationClass } from "workflow/internal/class-serialization";
+import { WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@vercel/workflow';
+/**__internal_workflows{"steps":{"input.js":{"Counter#add":{"stepId":"step//input.js//Counter#add"}}},"classes":{"input.js":{"Counter":{"classId":"class//input.js//Counter"}}}}*/;
+export class Counter {
+    static [WORKFLOW_SERIALIZE](instance) {
+        return { value: instance.value };
+    }
+    static [WORKFLOW_DESERIALIZE](data) {
+        return new Counter(data.value);
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    async add(amount) {
+        return this.value + amount;
+    }
+}
+registerStepFunction("step//input.js//Counter#add", Counter.prototype["add"]);
+registerSerializationClass("class//input.js//Counter", Counter);
+```
+
+Note: Instance methods use `#` in the step ID (e.g., `Counter#add`) and are registered via `ClassName.prototype["methodName"]`.
+
 ### Module-Level Directive
 
 Input:
@@ -591,7 +643,7 @@ The plugin emits errors for invalid usage:
 | Error | Description |
 |-------|-------------|
 | Non-async function | Functions with `"use step"` or `"use workflow"` must be async |
-| Instance methods | Only static methods can have directives (not instance methods) |
+| Instance methods with `"use workflow"` | Only static methods can have `"use workflow"` (not instance methods) |
 | Misplaced directive | Directive must be at top of file or start of function body |
 | Conflicting directives | Cannot have both `"use step"` and `"use workflow"` at module level |
 | Invalid exports | Module-level directive files can only export async functions |
@@ -610,6 +662,7 @@ The plugin supports various function declaration styles:
 - `const name = async function() { "use step"; }` - Function expression
 - `{ async method() { "use step"; } }` - Object method
 - `static async method() { "use step"; }` - Static class method
+- `async method() { "use step"; }` - Instance class method (requires custom serialization)
 
 ---