@workflow/core 5.0.0-beta.5 → 5.0.0-beta.50

package/dist/serialization/reducers/step-function-vm.d.ts

@@ -0,0 +1,44 @@
+/**
+ * VM-compatible copy: identical semantics to step-function.ts before the host-side
+ * hardening (#3257) made that module depend on `serialization/hardened.ts`
+ * (which imports `node:util` and captures host intrinsics, meaningless
+ * and unbundleable inside the QuickJS VM, where the codec already runs in
+ * the guest realm). The host/guest boundary hardening for the QuickJS
+ * engine lands with the host-side serde (#3263), which retires this
+ * bundle entirely. Wire format is identical to the hardened host version.
+ */
+/**
+ * Reducer and reviver for step function references.
+ *
+ * In workflow mode, step functions are replaced by the SWC plugin with
+ * proxies created by `globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId")`.
+ * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`
+ * for captured closure variables. They may additionally have `.__boundThis`
+ * (and rarely `.__boundArgs`) when the SWC plugin emitted
+ * `useStep(...).bind(this)` for a nested arrow step that lexically
+ * captured `this` (see `packages/swc-plugin-workflow/spec.md` → "Lexical
+ * `this` Capture in Nested Arrow Steps").
+ *
+ * The reducer serializes them as
+ *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.
+ * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when
+ * `boundThis` (or `boundArgs`) is present, re-binding the resulting
+ * proxy so the caller's captured `this` (and prefilled args) survive the
+ * round trip.
+ */
+import type { Reducers, Revivers } from '../types.js';
+export declare function getStepFunctionReducer(): Partial<Reducers>;
+/**
+ * Create the StepFunction reviver for workflow context.
+ *
+ * The reviver calls WORKFLOW_USE_STEP to create the step proxy,
+ * restoring the ability to call the step from workflow code. If the
+ * serialized payload includes `boundThis` (and optionally `boundArgs`),
+ * the reviver also re-binds the freshly-created proxy so a step proxy
+ * that was constructed with `.bind(this, …)` in the workflow bundle
+ * continues to carry that receiver and any prefilled arguments after
+ * being deserialized in another bundle (e.g. when passed as a step
+ * argument).
+ */
+export declare function getStepFunctionReviver(global?: Record<string, any>): Partial<Revivers>;
+//# sourceMappingURL=step-function-vm.d.ts.map

package/dist/serialization/reducers/step-function-vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-function-vm.d.ts","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function-vm.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAItD,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,QAAQ,CAAC,CAuC1D;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAc,GACvC,OAAO,CAAC,QAAQ,CAAC,CA8BnB"}

package/dist/serialization/reducers/step-function-vm.js

@@ -0,0 +1,97 @@
+/**
+ * VM-compatible copy: identical semantics to step-function.ts before the host-side
+ * hardening (#3257) made that module depend on `serialization/hardened.ts`
+ * (which imports `node:util` and captures host intrinsics, meaningless
+ * and unbundleable inside the QuickJS VM, where the codec already runs in
+ * the guest realm). The host/guest boundary hardening for the QuickJS
+ * engine lands with the host-side serde (#3263), which retires this
+ * bundle entirely. Wire format is identical to the hardened host version.
+ */
+/**
+ * Reducer and reviver for step function references.
+ *
+ * In workflow mode, step functions are replaced by the SWC plugin with
+ * proxies created by `globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId")`.
+ * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`
+ * for captured closure variables. They may additionally have `.__boundThis`
+ * (and rarely `.__boundArgs`) when the SWC plugin emitted
+ * `useStep(...).bind(this)` for a nested arrow step that lexically
+ * captured `this` (see `packages/swc-plugin-workflow/spec.md` → "Lexical
+ * `this` Capture in Nested Arrow Steps").
+ *
+ * The reducer serializes them as
+ *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.
+ * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when
+ * `boundThis` (or `boundArgs`) is present, re-binding the resulting
+ * proxy so the caller's captured `this` (and prefilled args) survive the
+ * round trip.
+ */
+// ---- Reducer ----
+export function getStepFunctionReducer() {
+    return {
+        StepFunction: (value) => {
+            if (typeof value !== 'function')
+                return false;
+            const stepId = value.stepId;
+            if (typeof stepId !== 'string')
+                return false;
+            const closureVarsFn = value.__closureVarsFn;
+            const closureVars = closureVarsFn && typeof closureVarsFn === 'function'
+                ? closureVarsFn()
+                : undefined;
+            // `__boundThis` / `__boundArgs` are marker properties added by the
+            // step proxy's overridden `.bind` (see step.ts) to record the
+            // bound receiver and any prefilled arguments. Use `in` for
+            // `__boundThis` so we round-trip even when the bound `this` is
+            // `undefined`/`null`. `__boundArgs` is only set when the user
+            // actually supplied prefilled args, so a missing property means
+            // "no prefilled args".
+            const hasBoundThis = '__boundThis' in value;
+            const boundThis = hasBoundThis ? value.__boundThis : undefined;
+            const boundArgs = value.__boundArgs;
+            const payload = { stepId };
+            if (closureVars !== undefined)
+                payload.closureVars = closureVars;
+            if (hasBoundThis)
+                payload.boundThis = boundThis;
+            if (Array.isArray(boundArgs) && boundArgs.length > 0) {
+                payload.boundArgs = boundArgs;
+            }
+            return payload;
+        },
+    };
+}
+// ---- Reviver ----
+/**
+ * Create the StepFunction reviver for workflow context.
+ *
+ * The reviver calls WORKFLOW_USE_STEP to create the step proxy,
+ * restoring the ability to call the step from workflow code. If the
+ * serialized payload includes `boundThis` (and optionally `boundArgs`),
+ * the reviver also re-binds the freshly-created proxy so a step proxy
+ * that was constructed with `.bind(this, …)` in the workflow bundle
+ * continues to carry that receiver and any prefilled arguments after
+ * being deserialized in another bundle (e.g. when passed as a step
+ * argument).
+ */
+export function getStepFunctionReviver(global = globalThis) {
+    const useStep = global[Symbol.for('WORKFLOW_USE_STEP')];
+    return {
+        StepFunction: (value) => {
+            const stepId = value.stepId;
+            const closureVars = value.closureVars;
+            if (!useStep) {
+                throw new Error('WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.');
+            }
+            const proxy = closureVars
+                ? useStep(stepId, () => closureVars)
+                : useStep(stepId);
+            if ('boundThis' in value) {
+                const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];
+                return proxy.bind(value.boundThis, ...boundArgs);
+            }
+            return proxy;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-function-vm.js","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function-vm.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AAIH,oBAAoB;AAEpB,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE;YACtB,IAAI,OAAO,KAAK,KAAK,UAAU;gBAAE,OAAO,KAAK,CAAC;YAC9C,MAAM,MAAM,GAAI,KAAa,CAAC,MAAM,CAAC;YACrC,IAAI,OAAO,MAAM,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAC;YAE7C,MAAM,aAAa,GAAI,KAAa,CAAC,eAAe,CAAC;YACrD,MAAM,WAAW,GACf,aAAa,IAAI,OAAO,aAAa,KAAK,UAAU;gBAClD,CAAC,CAAC,aAAa,EAAE;gBACjB,CAAC,CAAC,SAAS,CAAC;YAEhB,mEAAmE;YACnE,8DAA8D;YAC9D,2DAA2D;YAC3D,+DAA+D;YAC/D,8DAA8D;YAC9D,gEAAgE;YAChE,uBAAuB;YACvB,MAAM,YAAY,GAAG,aAAa,IAAK,KAAa,CAAC;YACrD,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAE,KAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;YACxE,MAAM,SAAS,GAAI,KAAa,CAAC,WAAoC,CAAC;YAEtE,MAAM,OAAO,GAKT,EAAE,MAAM,EAAE,CAAC;YACf,IAAI,WAAW,KAAK,SAAS;gBAAE,OAAO,CAAC,WAAW,GAAG,WAAW,CAAC;YACjE,IAAI,YAAY;gBAAE,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;YAChD,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrD,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;YAChC,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,oBAAoB;AAEpB;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,SAA8B,UAAU;IAExC,MAAM,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAKlD,CAAC;IAEd,OAAO;QACL,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE;YACtB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;YAC5B,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;YAEtC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CACb,+GAA+G,CAChH,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAG,WAAW;gBACvB,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC;gBACpC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAEpB,IAAI,WAAW,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;gBACxE,OAAQ,KAAa,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,CAAC;YAC5D,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * VM-compatible copy: identical semantics to step-function.ts before the host-side\n * hardening (#3257) made that module depend on `serialization/hardened.ts`\n * (which imports `node:util` and captures host intrinsics, meaningless\n * and unbundleable inside the QuickJS VM, where the codec already runs in\n * the guest realm). The host/guest boundary hardening for the QuickJS\n * engine lands with the host-side serde (#3263), which retires this\n * bundle entirely. Wire format is identical to the hardened host version.\n */\n/**\n * Reducer and reviver for step function references.\n *\n * In workflow mode, step functions are replaced by the SWC plugin with\n * proxies created by `globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"stepId\")`.\n * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`\n * for captured closure variables. They may additionally have `.__boundThis`\n * (and rarely `.__boundArgs`) when the SWC plugin emitted\n * `useStep(...).bind(this)` for a nested arrow step that lexically\n * captured `this` (see `packages/swc-plugin-workflow/spec.md` → \"Lexical\n * `this` Capture in Nested Arrow Steps\").\n *\n * The reducer serializes them as\n *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.\n * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when\n * `boundThis` (or `boundArgs`) is present, re-binding the resulting\n * proxy so the caller's captured `this` (and prefilled args) survive the\n * round trip.\n */\n\nimport type { Reducers, Revivers } from '../types.js';\n\n// ---- Reducer ----\n\nexport function getStepFunctionReducer(): Partial<Reducers> {\n  return {\n    StepFunction: (value) => {\n      if (typeof value !== 'function') return false;\n      const stepId = (value as any).stepId;\n      if (typeof stepId !== 'string') return false;\n\n      const closureVarsFn = (value as any).__closureVarsFn;\n      const closureVars =\n        closureVarsFn && typeof closureVarsFn === 'function'\n          ? closureVarsFn()\n          : undefined;\n\n      // `__boundThis` / `__boundArgs` are marker properties added by the\n      // step proxy's overridden `.bind` (see step.ts) to record the\n      // bound receiver and any prefilled arguments. Use `in` for\n      // `__boundThis` so we round-trip even when the bound `this` is\n      // `undefined`/`null`. `__boundArgs` is only set when the user\n      // actually supplied prefilled args, so a missing property means\n      // \"no prefilled args\".\n      const hasBoundThis = '__boundThis' in (value as any);\n      const boundThis = hasBoundThis ? (value as any).__boundThis : undefined;\n      const boundArgs = (value as any).__boundArgs as unknown[] | undefined;\n\n      const payload: {\n        stepId: string;\n        closureVars?: Record<string, any>;\n        boundThis?: unknown;\n        boundArgs?: unknown[];\n      } = { stepId };\n      if (closureVars !== undefined) payload.closureVars = closureVars;\n      if (hasBoundThis) payload.boundThis = boundThis;\n      if (Array.isArray(boundArgs) && boundArgs.length > 0) {\n        payload.boundArgs = boundArgs;\n      }\n\n      return payload;\n    },\n  };\n}\n\n// ---- Reviver ----\n\n/**\n * Create the StepFunction reviver for workflow context.\n *\n * The reviver calls WORKFLOW_USE_STEP to create the step proxy,\n * restoring the ability to call the step from workflow code. If the\n * serialized payload includes `boundThis` (and optionally `boundArgs`),\n * the reviver also re-binds the freshly-created proxy so a step proxy\n * that was constructed with `.bind(this, …)` in the workflow bundle\n * continues to carry that receiver and any prefilled arguments after\n * being deserialized in another bundle (e.g. when passed as a step\n * argument).\n */\nexport function getStepFunctionReviver(\n  global: Record<string, any> = globalThis\n): Partial<Revivers> {\n  const useStep = (global as any)[Symbol.for('WORKFLOW_USE_STEP')] as\n    | ((\n        stepId: string,\n        closureVarsFn?: () => Record<string, unknown>\n      ) => (...args: unknown[]) => Promise<unknown>)\n    | undefined;\n\n  return {\n    StepFunction: (value) => {\n      const stepId = value.stepId;\n      const closureVars = value.closureVars;\n\n      if (!useStep) {\n        throw new Error(\n          'WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.'\n        );\n      }\n\n      const proxy = closureVars\n        ? useStep(stepId, () => closureVars)\n        : useStep(stepId);\n\n      if ('boundThis' in value) {\n        const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];\n        return (proxy as any).bind(value.boundThis, ...boundArgs);\n      }\n      return proxy;\n    },\n  };\n}\n"]}

package/dist/serialization/reducers/step-function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-function.d.ts","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAItD,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,QAAQ,CAAC,CAuC1D;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAc,GACvC,OAAO,CAAC,QAAQ,CAAC,CA8BnB"}
+{"version":3,"file":"step-function.d.ts","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAItD,wBAAgB,sBAAsB,IAAI,OAAO,CAAC,QAAQ,CAAC,CAuD1D;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAc,GACvC,OAAO,CAAC,QAAQ,CAAC,CA8BnB"}

package/dist/serialization/reducers/step-function.js

@@ -17,19 +17,33 @@
  * proxy so the caller's captured `this` (and prefilled args) survive the
  * round trip.
  */
+import { hasProperty, isUseStepClosureFn, readProperty, recordGuestCode, } from '../hardened.js';
 // ---- Reducer ----
 export function getStepFunctionReducer() {
     return {
         StepFunction: (value) => {
             if (typeof value !== 'function')
                 return false;
-            const stepId = value.stepId;
+            const stepId = readProperty(value, 'stepId');
             if (typeof stepId !== 'string')
                 return false;
-            const closureVarsFn = value.__closureVarsFn;
-            const closureVars = closureVarsFn && typeof closureVarsFn === 'function'
-                ? closureVarsFn()
-                : undefined;
+            const closureVarsFn = readProperty(value, '__closureVarsFn');
+            // The reducer has to invoke this to read the step's captured closure
+            // variables. The compiler-generated function is a sequence of lexical
+            // reads and cannot perturb observable VM state, so reporting it would
+            // flag every step that captures a variable. But the property is
+            // reachable from workflow code, which can replace it with anything.
+            // `step.ts` marks the function that came through `useStep` when it
+            // builds the proxy, so this is checked rather than assumed; anything
+            // unrecognized is reported like other guest code. See
+            // `markUseStepClosureFn` for what the mark does and does not prove.
+            let closureVars;
+            if (typeof closureVarsFn === 'function') {
+                if (!isUseStepClosureFn(closureVarsFn)) {
+                    recordGuestCode('method', '__closureVarsFn');
+                }
+                closureVars = closureVarsFn();
+            }
             // `__boundThis` / `__boundArgs` are marker properties added by the
             // step proxy's overridden `.bind` (see step.ts) to record the
             // bound receiver and any prefilled arguments. Use `in` for
@@ -37,9 +51,11 @@ export function getStepFunctionReducer() {
             // `undefined`/`null`. `__boundArgs` is only set when the user
             // actually supplied prefilled args, so a missing property means
             // "no prefilled args".
-            const hasBoundThis = '__boundThis' in value;
-            const boundThis = hasBoundThis ? value.__boundThis : undefined;
-            const boundArgs = value.__boundArgs;
+            const hasBoundThis = hasProperty(value, '__boundThis');
+            const boundThis = hasBoundThis
+                ? readProperty(value, '__boundThis')
+                : undefined;
+            const boundArgs = readProperty(value, '__boundArgs');
             const payload = { stepId };
             if (closureVars !== undefined)
                 payload.closureVars = closureVars;
@@ -85,4 +101,4 @@ export function getStepFunctionReviver(global = globalThis) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-function.js","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,oBAAoB;AAEpB,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE;YACtB,IAAI,OAAO,KAAK,KAAK,UAAU;gBAAE,OAAO,KAAK,CAAC;YAC9C,MAAM,MAAM,GAAI,KAAa,CAAC,MAAM,CAAC;YACrC,IAAI,OAAO,MAAM,KAAK,QAAQ;gBAAE,OAAO,KAAK,CAAC;YAE7C,MAAM,aAAa,GAAI,KAAa,CAAC,eAAe,CAAC;YACrD,MAAM,WAAW,GACf,aAAa,IAAI,OAAO,aAAa,KAAK,UAAU;gBAClD,CAAC,CAAC,aAAa,EAAE;gBACjB,CAAC,CAAC,SAAS,CAAC;YAEhB,mEAAmE;YACnE,8DAA8D;YAC9D,2DAA2D;YAC3D,+DAA+D;YAC/D,8DAA8D;YAC9D,gEAAgE;YAChE,uBAAuB;YACvB,MAAM,YAAY,GAAG,aAAa,IAAK,KAAa,CAAC;YACrD,MAAM,SAAS,GAAG,YAAY,CAAC,CAAC,CAAE,KAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;YACxE,MAAM,SAAS,GAAI,KAAa,CAAC,WAAoC,CAAC;YAEtE,MAAM,OAAO,GAKT,EAAE,MAAM,EAAE,CAAC;YACf,IAAI,WAAW,KAAK,SAAS;gBAAE,OAAO,CAAC,WAAW,GAAG,WAAW,CAAC;YACjE,IAAI,YAAY;gBAAE,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;YAChD,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrD,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;YAChC,CAAC;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,oBAAoB;AAEpB;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,SAA8B,UAAU;IAExC,MAAM,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAKlD,CAAC;IAEd,OAAO;QACL,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE;YACtB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;YAC5B,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;YAEtC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CACb,+GAA+G,CAChH,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAG,WAAW;gBACvB,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC;gBACpC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAEpB,IAAI,WAAW,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;gBACxE,OAAQ,KAAa,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,CAAC;YAC5D,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Reducer and reviver for step function references.\n *\n * In workflow mode, step functions are replaced by the SWC plugin with\n * proxies created by `globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"stepId\")`.\n * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`\n * for captured closure variables. They may additionally have `.__boundThis`\n * (and rarely `.__boundArgs`) when the SWC plugin emitted\n * `useStep(...).bind(this)` for a nested arrow step that lexically\n * captured `this` (see `packages/swc-plugin-workflow/spec.md` → \"Lexical\n * `this` Capture in Nested Arrow Steps\").\n *\n * The reducer serializes them as\n *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.\n * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when\n * `boundThis` (or `boundArgs`) is present, re-binding the resulting\n * proxy so the caller's captured `this` (and prefilled args) survive the\n * round trip.\n */\n\nimport type { Reducers, Revivers } from '../types.js';\n\n// ---- Reducer ----\n\nexport function getStepFunctionReducer(): Partial<Reducers> {\n  return {\n    StepFunction: (value) => {\n      if (typeof value !== 'function') return false;\n      const stepId = (value as any).stepId;\n      if (typeof stepId !== 'string') return false;\n\n      const closureVarsFn = (value as any).__closureVarsFn;\n      const closureVars =\n        closureVarsFn && typeof closureVarsFn === 'function'\n          ? closureVarsFn()\n          : undefined;\n\n      // `__boundThis` / `__boundArgs` are marker properties added by the\n      // step proxy's overridden `.bind` (see step.ts) to record the\n      // bound receiver and any prefilled arguments. Use `in` for\n      // `__boundThis` so we round-trip even when the bound `this` is\n      // `undefined`/`null`. `__boundArgs` is only set when the user\n      // actually supplied prefilled args, so a missing property means\n      // \"no prefilled args\".\n      const hasBoundThis = '__boundThis' in (value as any);\n      const boundThis = hasBoundThis ? (value as any).__boundThis : undefined;\n      const boundArgs = (value as any).__boundArgs as unknown[] | undefined;\n\n      const payload: {\n        stepId: string;\n        closureVars?: Record<string, any>;\n        boundThis?: unknown;\n        boundArgs?: unknown[];\n      } = { stepId };\n      if (closureVars !== undefined) payload.closureVars = closureVars;\n      if (hasBoundThis) payload.boundThis = boundThis;\n      if (Array.isArray(boundArgs) && boundArgs.length > 0) {\n        payload.boundArgs = boundArgs;\n      }\n\n      return payload;\n    },\n  };\n}\n\n// ---- Reviver ----\n\n/**\n * Create the StepFunction reviver for workflow context.\n *\n * The reviver calls WORKFLOW_USE_STEP to create the step proxy,\n * restoring the ability to call the step from workflow code. If the\n * serialized payload includes `boundThis` (and optionally `boundArgs`),\n * the reviver also re-binds the freshly-created proxy so a step proxy\n * that was constructed with `.bind(this, …)` in the workflow bundle\n * continues to carry that receiver and any prefilled arguments after\n * being deserialized in another bundle (e.g. when passed as a step\n * argument).\n */\nexport function getStepFunctionReviver(\n  global: Record<string, any> = globalThis\n): Partial<Revivers> {\n  const useStep = (global as any)[Symbol.for('WORKFLOW_USE_STEP')] as\n    | ((\n        stepId: string,\n        closureVarsFn?: () => Record<string, unknown>\n      ) => (...args: unknown[]) => Promise<unknown>)\n    | undefined;\n\n  return {\n    StepFunction: (value) => {\n      const stepId = value.stepId;\n      const closureVars = value.closureVars;\n\n      if (!useStep) {\n        throw new Error(\n          'WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.'\n        );\n      }\n\n      const proxy = closureVars\n        ? useStep(stepId, () => closureVars)\n        : useStep(stepId);\n\n      if ('boundThis' in value) {\n        const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];\n        return (proxy as any).bind(value.boundThis, ...boundArgs);\n      }\n      return proxy;\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-function.js","sourceRoot":"","sources":["../../../src/serialization/reducers/step-function.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Reducer and reviver for step function references.\n *\n * In workflow mode, step functions are replaced by the SWC plugin with\n * proxies created by `globalThis[Symbol.for(\"WORKFLOW_USE_STEP\")](\"stepId\")`.\n * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`\n * for captured closure variables. They may additionally have `.__boundThis`\n * (and rarely `.__boundArgs`) when the SWC plugin emitted\n * `useStep(...).bind(this)` for a nested arrow step that lexically\n * captured `this` (see `packages/swc-plugin-workflow/spec.md` → \"Lexical\n * `this` Capture in Nested Arrow Steps\").\n *\n * The reducer serializes them as\n *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.\n * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when\n * `boundThis` (or `boundArgs`) is present, re-binding the resulting\n * proxy so the caller's captured `this` (and prefilled args) survive the\n * round trip.\n */\n\nimport {\n  hasProperty,\n  isUseStepClosureFn,\n  readProperty,\n  recordGuestCode,\n} from '../hardened.js';\nimport type { Reducers, Revivers } from '../types.js';\n\n// ---- Reducer ----\n\nexport function getStepFunctionReducer(): Partial<Reducers> {\n  return {\n    StepFunction: (value) => {\n      if (typeof value !== 'function') return false;\n      const stepId = readProperty(value, 'stepId');\n      if (typeof stepId !== 'string') return false;\n\n      const closureVarsFn = readProperty(value, '__closureVarsFn');\n      // The reducer has to invoke this to read the step's captured closure\n      // variables. The compiler-generated function is a sequence of lexical\n      // reads and cannot perturb observable VM state, so reporting it would\n      // flag every step that captures a variable. But the property is\n      // reachable from workflow code, which can replace it with anything.\n      // `step.ts` marks the function that came through `useStep` when it\n      // builds the proxy, so this is checked rather than assumed; anything\n      // unrecognized is reported like other guest code. See\n      // `markUseStepClosureFn` for what the mark does and does not prove.\n      let closureVars: Record<string, unknown> | undefined;\n      if (typeof closureVarsFn === 'function') {\n        if (!isUseStepClosureFn(closureVarsFn)) {\n          recordGuestCode('method', '__closureVarsFn');\n        }\n        closureVars = (closureVarsFn as () => Record<string, unknown>)();\n      }\n\n      // `__boundThis` / `__boundArgs` are marker properties added by the\n      // step proxy's overridden `.bind` (see step.ts) to record the\n      // bound receiver and any prefilled arguments. Use `in` for\n      // `__boundThis` so we round-trip even when the bound `this` is\n      // `undefined`/`null`. `__boundArgs` is only set when the user\n      // actually supplied prefilled args, so a missing property means\n      // \"no prefilled args\".\n      const hasBoundThis = hasProperty(value, '__boundThis');\n      const boundThis = hasBoundThis\n        ? readProperty(value, '__boundThis')\n        : undefined;\n      const boundArgs = readProperty(value, '__boundArgs') as\n        | unknown[]\n        | undefined;\n\n      const payload: {\n        stepId: string;\n        closureVars?: Record<string, any>;\n        boundThis?: unknown;\n        boundArgs?: unknown[];\n      } = { stepId };\n      if (closureVars !== undefined) payload.closureVars = closureVars;\n      if (hasBoundThis) payload.boundThis = boundThis;\n      if (Array.isArray(boundArgs) && boundArgs.length > 0) {\n        payload.boundArgs = boundArgs;\n      }\n\n      return payload;\n    },\n  };\n}\n\n// ---- Reviver ----\n\n/**\n * Create the StepFunction reviver for workflow context.\n *\n * The reviver calls WORKFLOW_USE_STEP to create the step proxy,\n * restoring the ability to call the step from workflow code. If the\n * serialized payload includes `boundThis` (and optionally `boundArgs`),\n * the reviver also re-binds the freshly-created proxy so a step proxy\n * that was constructed with `.bind(this, …)` in the workflow bundle\n * continues to carry that receiver and any prefilled arguments after\n * being deserialized in another bundle (e.g. when passed as a step\n * argument).\n */\nexport function getStepFunctionReviver(\n  global: Record<string, any> = globalThis\n): Partial<Revivers> {\n  const useStep = (global as any)[Symbol.for('WORKFLOW_USE_STEP')] as\n    | ((\n        stepId: string,\n        closureVarsFn?: () => Record<string, unknown>\n      ) => (...args: unknown[]) => Promise<unknown>)\n    | undefined;\n\n  return {\n    StepFunction: (value) => {\n      const stepId = value.stepId;\n      const closureVars = value.closureVars;\n\n      if (!useStep) {\n        throw new Error(\n          'WORKFLOW_USE_STEP not found on global object. Step functions cannot be deserialized outside workflow context.'\n        );\n      }\n\n      const proxy = closureVars\n        ? useStep(stepId, () => closureVars)\n        : useStep(stepId);\n\n      if ('boundThis' in value) {\n        const boundArgs = Array.isArray(value.boundArgs) ? value.boundArgs : [];\n        return (proxy as any).bind(value.boundThis, ...boundArgs);\n      }\n      return proxy;\n    },\n  };\n}\n"]}

package/dist/serialization/step.d.ts

@@ -1,17 +1,17 @@
 /**
  * Step mode serialization.
  *
- * Used by the step handler for serializing step return values and
+ * Used by the step executor for serializing step return values and
  * deserializing step arguments. Supports encryption as a composable layer.
  */
 import type { CodecOptions } from './codec.js';
-import { type CryptoKey } from './encryption.js';
+import { type PayloadKey } from './encryption.js';
 /**
  * Serialize a value from the step execution environment.
  */
-export declare function serialize(value: unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
+export declare function serialize(value: unknown, encryptionKey?: PayloadKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
 /**
  * Deserialize a value for the step execution environment.
  */
-export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<unknown>;
+export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: PayloadKey, options?: CodecOptions): Promise<unknown>;
 //# sourceMappingURL=step.d.ts.map

package/dist/serialization/step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/serialization/step.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAY/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAmBlB"}
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/serialization/step.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAmB/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,UAAU,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAsBlB"}

package/dist/serialization/step.js

@@ -1,13 +1,14 @@
 /**
  * Step mode serialization.
  *
- * Used by the step handler for serializing step return values and
+ * Used by the step executor for serializing step return values and
  * deserializing step arguments. Supports encryption as a composable layer.
  */
 import { SerializationError } from '@workflow/errors';
 import { devalueCodec } from './codec-devalue.js';
+import { compress, decompress } from './compression.js';
 import { decrypt as decryptData, encrypt as encryptData, } from './encryption.js';
-import { formatSerializationError } from './errors.js';
+import { formatSerializationError, rethrowIfRuntimeError } from './errors.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix } from './format.js';
 import { SerializationFormat } from './types.js';
 /**
@@ -17,9 +18,12 @@ export async function serialize(value, encryptionKey, options) {
     try {
         const payload = devalueCodec.serialize(value, 'step', options);
         const prefixed = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-        return encryptData(prefixed, encryptionKey);
+        // Compress before encrypting, since encrypted bytes don't compress.
+        const compressed = await compress(prefixed, options?.compression === true, options?.compressionStats);
+        return encryptData(compressed, encryptionKey);
     }
     catch (error) {
+        rethrowIfRuntimeError(error);
         const { message, hint } = formatSerializationError('step value', error);
         throw new SerializationError(message, { hint, cause: error });
     }
@@ -28,7 +32,7 @@ export async function serialize(value, encryptionKey, options) {
  * Deserialize a value for the step execution environment.
  */
 export async function deserialize(data, encryptionKey, options) {
-    const decrypted = await decryptData(data, encryptionKey);
+    const decrypted = await decompress(await decryptData(data, encryptionKey), options?.compressionStats);
     if (!(decrypted instanceof Uint8Array)) {
         if (devalueCodec.deserializeLegacy) {
             return devalueCodec.deserializeLegacy(decrypted, 'step', options);
@@ -41,4 +45,4 @@ export async function deserialize(data, encryptionKey, options) {
     }
     throw new Error(`Unsupported serialization format: ${format}`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/types.d.ts

@@ -1,10 +1,11 @@
 /**
  * Shared types for the serialization system.
  */
+import type { RuntimeDecryptionErrorContext } from '@workflow/errors';
 /**
  * A format prefix is exactly 4 lowercase alphanumeric characters [a-z0-9].
  *
- * This is a branded string type — use `isFormatPrefix()` to validate
+ * This is a branded string type: use `isFormatPrefix()` to validate
  * at runtime. The `SerializationFormat` object provides well-known
  * constants, but codecs may define additional prefixes.
  */
@@ -25,7 +26,32 @@ export declare const SerializationFormat: {
     readonly DEVALUE_V1: FormatPrefix;
     /** Encrypted payload (inner payload has its own format prefix) */
     readonly ENCRYPTED: FormatPrefix;
+    /**
+     * Sealed payload: asymmetrically encrypted to a run's X25519 public key
+     * (inner payload has its own format prefix).
+     *
+     * Used for *cross-run* writes (hook payloads, forwarded stream frames),
+     * where the writer holds only the recipient run's public key and therefore
+     * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.
+     * See `sealed-box.ts` for the construction.
+     */
+    readonly SEALED: FormatPrefix;
+    /** Gzip-compressed payload (inner payload has its own format prefix) */
+    readonly GZIP: FormatPrefix;
+    /** Zstandard-compressed payload (inner payload has its own format prefix) */
+    readonly ZSTD: FormatPrefix;
 };
+/**
+ * Wire-framing format identifier carried in the serialized
+ * `ReadableStream` ref's `framing` field.
+ *
+ * - absent / `'raw'`: chunks are written to the transport verbatim
+ *   (legacy format, no auto-reconnect support).
+ * - `'framed-v1'`: each chunk is wrapped in a 4-byte big-endian length
+ *   prefix, allowing the reader to identify chunk boundaries and
+ *   transparently reconnect on transient stream errors.
+ */
+export type ByteStreamFraming = 'raw' | 'framed-v1';
 /**
  * Types that need specialized handling when serialized/deserialized.
  * If a type is added here, it MUST also be added to the `Serializable`
@@ -62,6 +88,13 @@ export interface SerializableSpecial {
         cause?: unknown;
     };
     Headers: [string, string][];
+    HookConflictError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        token: string;
+        conflictingRunId?: string;
+    };
     Int8Array: string;
     Int16Array: string;
     Int32Array: string;
@@ -75,6 +108,16 @@ export interface SerializableSpecial {
         name: string;
         type?: 'bytes';
         startIndex?: number;
+        /**
+         * Wire-framing format for byte streams. See {@link ByteStreamFraming}
+         * and `getByteFramingStream` / `getByteUnframingStream`.
+         *
+         * Only meaningful when `type === 'bytes'`. Absent on object streams
+         * (which always use length-prefixed devalue framing) and on legacy
+         * byte streams written by SDKs that predate framing support; those
+         * are interpreted as `'raw'` by the consumer.
+         */
+        framing?: ByteStreamFraming;
     } | {
         bodyInit: any;
     };
@@ -98,6 +141,19 @@ export interface SerializableSpecial {
         cause?: unknown;
         retryAfter: number;
     };
+    RuntimeDecryptionError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        context?: RuntimeDecryptionErrorContext;
+    };
+    StreamError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        status?: number;
+        url?: string;
+    };
     Request: {
         method: string;
         url: string;
@@ -178,6 +234,29 @@ export interface SerializableSpecial {
     };
     WritableStream: {
         name: string;
+        /**
+         * The runId of the workflow run that owns the underlying server
+         * stream. Present only when the writable was forwarded across a
+         * `start()` boundary (parent → child). When omitted, the writable
+         * belongs to the receiving run (the normal in-run case).
+         */
+        runId?: string;
+        /**
+         * The deployment that owns the server stream. Carried with `runId`
+         * so a child running on a newer deployment can encrypt chunks with
+         * the parent's key without fetching the parent run first.
+         */
+        deploymentId?: string;
+        /**
+         * The owning run's X25519 public key (base64), when it has one.
+         *
+         * Lets the receiving run seal frames to the stream's owner with no
+         * lookup at all: neither a run fetch nor a key-API round trip. The
+         * owner derives this locally when it creates the stream, so including
+         * it here is free. Absent for runs created by older SDKs, in which
+         * case the receiver falls back to resolving the owner's symmetric key.
+         */
+        encryptionPublicKey?: string;
     };
     AbortController: {
         streamName: string;

package/dist/serialization/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/serialization/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/serialization/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AAItE;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;CAAE,CAAC;AAEzE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAEnE;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC9B,2DAA2D;yBACrC,YAAY;IAClC,kEAAkE;wBAC7C,YAAY;IACjC;;;;;;;;OAQG;qBACe,YAAY;IAC9B,wEAAwE;mBACxD,YAAY;IAC5B,6EAA6E;mBAC7D,YAAY;CACpB,CAAC;AAIX;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,WAAW,CAAC;AAEpD;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC1E,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAChE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC5B,iBAAiB,EAAE;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QAEd,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IAClB,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACjE,cAAc,EACV;QACE,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB;;;;;;;;WAQG;QACH,OAAO,CAAC,EAAE,iBAAiB,CAAC;KAC7B,GACD;QAAE,QAAQ,EAAE,GAAG,CAAA;KAAE,CAAC;IACtB,cAAc,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACrE,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C;;;;OAIG;IACH,cAAc,EAAE;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,sBAAsB,EAAE;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,6BAA6B,CAAC;KACzC,CAAC;IACF,WAAW,EAAE;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;IACF,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QACtB,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1B,gBAAgB,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC5C,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,CAAC;IACF,QAAQ,EAAE;QACR,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;QACvB,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;QACvB,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;IACF,KAAK,EAAE;QACL,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,OAAO,CAAC;KACf,CAAC;IACF,GAAG,EAAE,GAAG,EAAE,CAAC;IACX,WAAW,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAClE,YAAY,EAAE;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC;;;;;;WAMG;QACH,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB;;;;;;;;WAQG;QACH,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC;KACvB,CAAC;IACF,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAChE,QAAQ,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC/D,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,EAAE;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,EAAE,CAAC;KACnB,CAAC;IACF,cAAc,EAAE;QACd,IAAI,EAAE,MAAM,CAAC;QACb;;;;;WAKG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;QACf;;;;WAIG;QACH,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB;;;;;;;;WAQG;QACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B,CAAC;IACF,eAAe,EAAE;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,EAAE;QACX,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;CACH;AAED,MAAM,MAAM,QAAQ,GAAG;KACpB,CAAC,IAAI,MAAM,mBAAmB,GAAG,CAChC,KAAK,EAAE,GAAG,KACP,mBAAmB,CAAC,CAAC,CAAC,GAAG,KAAK;CACpC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;KACpB,CAAC,IAAI,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,GAAG;CACzE,CAAC"}

package/dist/serialization/types.js

@@ -17,5 +17,19 @@ export const SerializationFormat = {
     DEVALUE_V1: 'devl',
     /** Encrypted payload (inner payload has its own format prefix) */
     ENCRYPTED: 'encr',
+    /**
+     * Sealed payload: asymmetrically encrypted to a run's X25519 public key
+     * (inner payload has its own format prefix).
+     *
+     * Used for *cross-run* writes (hook payloads, forwarded stream frames),
+     * where the writer holds only the recipient run's public key and therefore
+     * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.
+     * See `sealed-box.ts` for the construction.
+     */
+    SEALED: 'encp',
+    /** Gzip-compressed payload (inner payload has its own format prefix) */
+    GZIP: 'gzip',
+    /** Zstandard-compressed payload (inner payload has its own format prefix) */
+    ZSTD: 'zstd',
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/serialization/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAeH;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,2DAA2D;IAC3D,UAAU,EAAE,MAAsB;IAClC,kEAAkE;IAClE,SAAS,EAAE,MAAsB;IACjC;;;;;;;;OAQG;IACH,MAAM,EAAE,MAAsB;IAC9B,wEAAwE;IACxE,IAAI,EAAE,MAAsB;IAC5B,6EAA6E;IAC7E,IAAI,EAAE,MAAsB;CACpB,CAAC","sourcesContent":["/**\n * Shared types for the serialization system.\n */\n\nimport type { RuntimeDecryptionErrorContext } from '@workflow/errors';\n\n// ---- Format Prefix ----\n\n/**\n * A format prefix is exactly 4 lowercase alphanumeric characters [a-z0-9].\n *\n * This is a branded string type: use `isFormatPrefix()` to validate\n * at runtime. The `SerializationFormat` object provides well-known\n * constants, but codecs may define additional prefixes.\n */\nexport type FormatPrefix = string & { readonly __brand: 'FormatPrefix' };\n\n/**\n * Runtime type guard for format prefix strings.\n *\n * Validates that a string is exactly 4 characters of [a-z0-9].\n */\nexport function isFormatPrefix(value: string): value is FormatPrefix {\n  return value.length === 4 && /^[a-z0-9]{4}$/.test(value);\n}\n\n/**\n * Well-known format prefix constants. Codecs may define additional ones.\n */\nexport const SerializationFormat = {\n  /** devalue stringify/parse with TextEncoder/TextDecoder */\n  DEVALUE_V1: 'devl' as FormatPrefix,\n  /** Encrypted payload (inner payload has its own format prefix) */\n  ENCRYPTED: 'encr' as FormatPrefix,\n  /**\n   * Sealed payload: asymmetrically encrypted to a run's X25519 public key\n   * (inner payload has its own format prefix).\n   *\n   * Used for *cross-run* writes (hook payloads, forwarded stream frames),\n   * where the writer holds only the recipient run's public key and therefore\n   * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.\n   * See `sealed-box.ts` for the construction.\n   */\n  SEALED: 'encp' as FormatPrefix,\n  /** Gzip-compressed payload (inner payload has its own format prefix) */\n  GZIP: 'gzip' as FormatPrefix,\n  /** Zstandard-compressed payload (inner payload has its own format prefix) */\n  ZSTD: 'zstd' as FormatPrefix,\n} as const;\n\n// ---- Serializable Types ----\n\n/**\n * Wire-framing format identifier carried in the serialized\n * `ReadableStream` ref's `framing` field.\n *\n * - absent / `'raw'`: chunks are written to the transport verbatim\n *   (legacy format, no auto-reconnect support).\n * - `'framed-v1'`: each chunk is wrapped in a 4-byte big-endian length\n *   prefix, allowing the reader to identify chunk boundaries and\n *   transparently reconnect on transient stream errors.\n */\nexport type ByteStreamFraming = 'raw' | 'framed-v1';\n\n/**\n * Types that need specialized handling when serialized/deserialized.\n * If a type is added here, it MUST also be added to the `Serializable`\n * type in `schemas.ts`.\n */\nexport interface SerializableSpecial {\n  ArrayBuffer: string; // base64 string\n  BigInt: string; // string representation of bigint\n  BigInt64Array: string; // base64 string\n  BigUint64Array: string; // base64 string\n  Date: string; // ISO string\n  DOMException: {\n    message: string;\n    name: string;\n    stack?: string;\n    cause?: unknown;\n  };\n  FatalError: { message: string; stack?: string; cause?: unknown };\n  Float32Array: string; // base64 string\n  Float64Array: string; // base64 string\n  Error: { name: string; message: string; stack?: string; cause?: unknown };\n  EvalError: { message: string; stack?: string; cause?: unknown };\n  Headers: [string, string][];\n  HookConflictError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    token: string;\n    // TODO: Make this required when HookConflictError.conflictingRunId is required.\n    conflictingRunId?: string;\n  };\n  Int8Array: string; // base64 string\n  Int16Array: string; // base64 string\n  Int32Array: string; // base64 string\n  Map: [any, any][];\n  RangeError: { message: string; stack?: string; cause?: unknown };\n  ReadableStream:\n    | {\n        name: string;\n        type?: 'bytes';\n        startIndex?: number;\n        /**\n         * Wire-framing format for byte streams. See {@link ByteStreamFraming}\n         * and `getByteFramingStream` / `getByteUnframingStream`.\n         *\n         * Only meaningful when `type === 'bytes'`. Absent on object streams\n         * (which always use length-prefixed devalue framing) and on legacy\n         * byte streams written by SDKs that predate framing support; those\n         * are interpreted as `'raw'` by the consumer.\n         */\n        framing?: ByteStreamFraming;\n      }\n    | { bodyInit: any };\n  ReferenceError: { message: string; stack?: string; cause?: unknown };\n  RegExp: { source: string; flags: string };\n  /**\n   * `retryAfter` is serialized as a numeric epoch timestamp rather than a\n   * `Date` to be realm-safe. The Date reducer uses `instanceof global.Date`,\n   * which fails for Dates from a different VM realm.\n   */\n  RetryableError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    retryAfter: number;\n  };\n  RuntimeDecryptionError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    context?: RuntimeDecryptionErrorContext;\n  };\n  StreamError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    status?: number;\n    url?: string;\n  };\n  Request: {\n    method: string;\n    url: string;\n    headers: Headers;\n    body: Request['body'];\n    duplex: Request['duplex'];\n    responseWritable?: WritableStream<Response>;\n    signal?: AbortSignal;\n  };\n  Response: {\n    type: Response['type'];\n    url: string;\n    status: number;\n    statusText: string;\n    headers: Headers;\n    body: Response['body'];\n    redirected: boolean;\n  };\n  Class: {\n    classId: string;\n  };\n  Instance: {\n    classId: string;\n    data: unknown;\n  };\n  Set: any[];\n  SyntaxError: { message: string; stack?: string; cause?: unknown };\n  StepFunction: {\n    stepId: string;\n    closureVars?: Record<string, any>;\n    /**\n     * Captured lexical `this` for step proxies that were created via\n     * `useStep(...).bind(thisArg)` (the SWC plugin emits this for nested\n     * arrow steps that close over their enclosing function's `this`).\n     * The reviver re-binds the freshly-created proxy to this value so the\n     * binding survives serialization round-trips.\n     */\n    boundThis?: unknown;\n    /**\n     * Prefilled arguments captured when the user (rather than the SWC\n     * plugin) called `useStep(...).bind(thisArg, x, y)`. The reviver\n     * re-applies these alongside `boundThis` so partial application\n     * survives serialization. The SWC plugin only ever emits\n     * `.bind(this)` with no extra args today; this slot exists so a\n     * hand-written `.bind(thisArg, x)` doesn't silently lose `x` after\n     * round-tripping through the reducer/reviver.\n     */\n    boundArgs?: unknown[];\n  };\n  TypeError: { message: string; stack?: string; cause?: unknown };\n  URIError: { message: string; stack?: string; cause?: unknown };\n  URL: string;\n  WorkflowFunction: {\n    workflowId: string;\n  };\n  URLSearchParams: string;\n  Uint8Array: string; // base64 string\n  Uint8ClampedArray: string; // base64 string\n  Uint16Array: string; // base64 string\n  Uint32Array: string; // base64 string\n  AggregateError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    errors: unknown[];\n  };\n  WritableStream: {\n    name: string;\n    /**\n     * The runId of the workflow run that owns the underlying server\n     * stream. Present only when the writable was forwarded across a\n     * `start()` boundary (parent → child). When omitted, the writable\n     * belongs to the receiving run (the normal in-run case).\n     */\n    runId?: string;\n    /**\n     * The deployment that owns the server stream. Carried with `runId`\n     * so a child running on a newer deployment can encrypt chunks with\n     * the parent's key without fetching the parent run first.\n     */\n    deploymentId?: string;\n    /**\n     * The owning run's X25519 public key (base64), when it has one.\n     *\n     * Lets the receiving run seal frames to the stream's owner with no\n     * lookup at all: neither a run fetch nor a key-API round trip. The\n     * owner derives this locally when it creates the stream, so including\n     * it here is free. Absent for runs created by older SDKs, in which\n     * case the receiver falls back to resolving the owner's symmetric key.\n     */\n    encryptionPublicKey?: string;\n  };\n  AbortController: {\n    streamName: string;\n    hookToken: string;\n    aborted: boolean;\n    reason?: unknown;\n  };\n  AbortSignal: {\n    streamName: string;\n    hookToken: string;\n    aborted: boolean;\n    reason?: unknown;\n  };\n}\n\nexport type Reducers = {\n  [K in keyof SerializableSpecial]: (\n    value: any\n  ) => SerializableSpecial[K] | false;\n};\n\nexport type Revivers = {\n  [K in keyof SerializableSpecial]: (value: SerializableSpecial[K]) => any;\n};\n"]}

package/dist/serialization/workflow-vm.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Host-side reference implementation of the QuickJS engine's workflow-mode
+ * wire codec.
+ *
+ * The QuickJS engine serializes through handles on the host
+ * (runtime/quickjs-serde.ts); this module is the value-space equivalent of
+ * that codec and is used by tests to build wire fixtures and assert
+ * byte-level parity. It has NO Node.js dependencies (no Buffer, no
+ * node:util), which is also what made it bundleable into the VM before the
+ * serde moved host-side.
+ *
+ * Produces and consumes the same wire format as the Node.js workflow.ts:
+ * format-prefixed devalue data ("devl" + devalue.stringify output).
+ */
+/**
+ * Serialize a value to format-prefixed bytes.
+ *
+ * @param value - The value to serialize
+ * @returns Uint8Array with "devl" prefix + devalue payload
+ */
+export declare function serialize(value: unknown): Uint8Array;
+/**
+ * Deserialize format-prefixed bytes back to a value.
+ *
+ * @param data - Uint8Array with format prefix, or legacy non-binary data
+ * @returns The deserialized value
+ */
+export declare function deserialize(data: Uint8Array | unknown): unknown;
+//# sourceMappingURL=workflow-vm.d.ts.map

package/dist/serialization/workflow-vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-vm.d.ts","sourceRoot":"","sources":["../../src/serialization/workflow-vm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAsBH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAOpD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CA0B/D"}