@workflow/core 5.0.0-beta.39 → 5.0.0-beta.40

package/dist/serialization/codec-devalue-vm.d.ts

@@ -0,0 +1,9 @@
+/**
+ * VM-compatible devalue codec.
+ *
+ * Same as codec-devalue.ts but uses VM-compatible reducers/revivers
+ * (no Node.js Buffer, no node:util). Safe to bundle into the QuickJS VM.
+ */
+import type { Codec } from './codec.js';
+export declare const devalueVmCodec: Codec;
+//# sourceMappingURL=codec-devalue-vm.d.ts.map

package/dist/serialization/codec-devalue-vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-devalue-vm.d.ts","sourceRoot":"","sources":["../../src/serialization/codec-devalue-vm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAqB,MAAM,YAAY,CAAC;AAyI3D,eAAO,MAAM,cAAc,EAAE,KAyB5B,CAAC"}

package/dist/serialization/codec-devalue-vm.js

@@ -0,0 +1,137 @@
+/**
+ * VM-compatible devalue codec.
+ *
+ * Same as codec-devalue.ts but uses VM-compatible reducers/revivers
+ * (no Node.js Buffer, no node:util). Safe to bundle into the QuickJS VM.
+ */
+import { parse, stringify, unflatten } from 'devalue';
+import { getClassReducers, getClassRevivers } from './reducers/class-vm.js';
+import { getCommonReducers, getCommonRevivers } from './reducers/common-vm.js';
+import { getStepFunctionReducer, getStepFunctionReviver, } from './reducers/step-function-vm.js';
+import { SerializationFormat } from './types.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+// ---- AbortController / AbortSignal (workflow VM context) ----
+// Mirrors the node:vm engine's workflow-context abort reducers/revivers in
+// serialization.ts: reduce by reading the stream/hook symbols stamped at
+// controller construction; revive to the bootstrap's WorkflowAbortSignal
+// class (looked up lazily on globalThis — the serde bundle is evaluated
+// before the bootstrap defines it).
+const ABORT_STREAM_NAME = Symbol.for('WORKFLOW_ABORT_STREAM_NAME');
+const ABORT_HOOK_TOKEN = Symbol.for('WORKFLOW_ABORT_HOOK_TOKEN');
+function reduceAbortBySymbol(signal, holder) {
+    const streamName = holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];
+    const hookToken = holder[ABORT_HOOK_TOKEN] ?? holder.signal?.[ABORT_HOOK_TOKEN];
+    if (!streamName) {
+        throw new Error('AbortController/AbortSignal stream name is not set');
+    }
+    return {
+        streamName,
+        hookToken,
+        aborted: signal.aborted,
+        reason: signal.aborted ? signal.reason : undefined,
+    };
+}
+function reviveAbortSignalVM(value) {
+    const Cls = globalThis.__WorkflowAbortSignal;
+    if (typeof Cls !== 'function') {
+        throw new Error('WorkflowAbortSignal is not registered in the VM (bootstrap not evaluated)');
+    }
+    const signal = new Cls(value.streamName, value.hookToken);
+    if (value.aborted)
+        signal._setAborted(value.reason);
+    return signal;
+}
+function getAbortReducersVM() {
+    return {
+        AbortController: (value) => {
+            if (!value || typeof value !== 'object' || !value.signal)
+                return false;
+            const hasAbortSymbol = value[ABORT_STREAM_NAME] ?? value.signal?.[ABORT_STREAM_NAME];
+            if (hasAbortSymbol === undefined)
+                return false;
+            return reduceAbortBySymbol(value.signal, value);
+        },
+        AbortSignal: (value) => {
+            if (!value || typeof value !== 'object')
+                return false;
+            if (value[ABORT_STREAM_NAME] === undefined)
+                return false;
+            return reduceAbortBySymbol(value, value);
+        },
+    };
+}
+function getAbortReviversVM() {
+    return {
+        AbortController: (value) => ({
+            [ABORT_STREAM_NAME]: value.streamName,
+            [ABORT_HOOK_TOKEN]: value.hookToken,
+            signal: reviveAbortSignalVM(value),
+            abort: () => { },
+        }),
+        AbortSignal: (value) => reviveAbortSignalVM(value),
+    };
+}
+function getReducersForMode(mode) {
+    switch (mode) {
+        case 'workflow':
+            return {
+                ...getAbortReducersVM(),
+                ...getClassReducers(),
+                ...getStepFunctionReducer(),
+                ...getCommonReducers(),
+            };
+        case 'step':
+            return {
+                ...getClassReducers(),
+                ...getCommonReducers(),
+            };
+        case 'client':
+            return {
+                ...getClassReducers(),
+                ...getCommonReducers(),
+            };
+    }
+}
+function getReviversForMode(mode) {
+    switch (mode) {
+        case 'workflow':
+            return {
+                ...getAbortReviversVM(),
+                ...getClassRevivers(),
+                ...getStepFunctionReviver(),
+                ...getCommonRevivers(),
+            };
+        case 'step':
+            return {
+                ...getClassRevivers(),
+                ...getCommonRevivers(),
+            };
+        case 'client':
+            return {
+                ...getClassRevivers(),
+                ...getCommonRevivers(),
+                StepFunction: () => {
+                    throw new Error('Step functions cannot be deserialized in client context.');
+                },
+            };
+    }
+}
+export const devalueVmCodec = {
+    formatPrefix: SerializationFormat.DEVALUE_V1,
+    serialize(value, mode) {
+        const reducers = getReducersForMode(mode);
+        const str = stringify(value, reducers);
+        return encoder.encode(str);
+    },
+    deserialize(data, mode) {
+        const revivers = getReviversForMode(mode);
+        const str = decoder.decode(data);
+        return parse(str, revivers);
+    },
+    deserializeLegacy(data, mode) {
+        const revivers = getReviversForMode(mode);
+        return unflatten(data, revivers);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codec-devalue-vm.js","sourceRoot":"","sources":["../../src/serialization/codec-devalue-vm.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VM-compatible devalue codec.\n *\n * Same as codec-devalue.ts but uses VM-compatible reducers/revivers\n * (no Node.js Buffer, no node:util). Safe to bundle into the QuickJS VM.\n */\n\nimport { parse, stringify, unflatten } from 'devalue';\nimport type { Codec, SerializationMode } from './codec.js';\nimport { getClassReducers, getClassRevivers } from './reducers/class-vm.js';\nimport { getCommonReducers, getCommonRevivers } from './reducers/common-vm.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './reducers/step-function-vm.js';\nimport { type Reducers, type Revivers, SerializationFormat } from './types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n// ---- AbortController / AbortSignal (workflow VM context) ----\n// Mirrors the node:vm engine's workflow-context abort reducers/revivers in\n// serialization.ts: reduce by reading the stream/hook symbols stamped at\n// controller construction; revive to the bootstrap's WorkflowAbortSignal\n// class (looked up lazily on globalThis — the serde bundle is evaluated\n// before the bootstrap defines it).\nconst ABORT_STREAM_NAME = Symbol.for('WORKFLOW_ABORT_STREAM_NAME');\nconst ABORT_HOOK_TOKEN = Symbol.for('WORKFLOW_ABORT_HOOK_TOKEN');\n\ntype AbortSerialized = {\n  streamName: string;\n  hookToken: string;\n  aborted: boolean;\n  reason?: unknown;\n};\n\nfunction reduceAbortBySymbol(\n  signal: { aborted: boolean; reason?: unknown },\n  holder: any\n): AbortSerialized {\n  const streamName =\n    holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];\n  const hookToken =\n    holder[ABORT_HOOK_TOKEN] ?? holder.signal?.[ABORT_HOOK_TOKEN];\n  if (!streamName) {\n    throw new Error('AbortController/AbortSignal stream name is not set');\n  }\n  return {\n    streamName,\n    hookToken,\n    aborted: signal.aborted,\n    reason: signal.aborted ? signal.reason : undefined,\n  };\n}\n\nfunction reviveAbortSignalVM(value: AbortSerialized) {\n  const Cls = (globalThis as any).__WorkflowAbortSignal;\n  if (typeof Cls !== 'function') {\n    throw new Error(\n      'WorkflowAbortSignal is not registered in the VM (bootstrap not evaluated)'\n    );\n  }\n  const signal = new Cls(value.streamName, value.hookToken);\n  if (value.aborted) signal._setAborted(value.reason);\n  return signal;\n}\n\nfunction getAbortReducersVM(): Partial<Reducers> {\n  return {\n    AbortController: (value) => {\n      if (!value || typeof value !== 'object' || !value.signal) return false;\n      const hasAbortSymbol =\n        value[ABORT_STREAM_NAME] ?? value.signal?.[ABORT_STREAM_NAME];\n      if (hasAbortSymbol === undefined) return false;\n      return reduceAbortBySymbol(value.signal, value);\n    },\n    AbortSignal: (value) => {\n      if (!value || typeof value !== 'object') return false;\n      if ((value as any)[ABORT_STREAM_NAME] === undefined) return false;\n      return reduceAbortBySymbol(value as any, value);\n    },\n  };\n}\n\nfunction getAbortReviversVM(): Partial<Revivers> {\n  return {\n    AbortController: (value: AbortSerialized) => ({\n      [ABORT_STREAM_NAME]: value.streamName,\n      [ABORT_HOOK_TOKEN]: value.hookToken,\n      signal: reviveAbortSignalVM(value),\n      abort: () => {},\n    }),\n    AbortSignal: (value: AbortSerialized) => reviveAbortSignalVM(value),\n  };\n}\n\nfunction getReducersForMode(mode: SerializationMode): Partial<Reducers> {\n  switch (mode) {\n    case 'workflow':\n      return {\n        ...getAbortReducersVM(),\n        ...getClassReducers(),\n        ...getStepFunctionReducer(),\n        ...getCommonReducers(),\n      };\n    case 'step':\n      return {\n        ...getClassReducers(),\n        ...getCommonReducers(),\n      };\n    case 'client':\n      return {\n        ...getClassReducers(),\n        ...getCommonReducers(),\n      };\n  }\n}\n\nfunction getReviversForMode(mode: SerializationMode): Partial<Revivers> {\n  switch (mode) {\n    case 'workflow':\n      return {\n        ...getAbortReviversVM(),\n        ...getClassRevivers(),\n        ...getStepFunctionReviver(),\n        ...getCommonRevivers(),\n      };\n    case 'step':\n      return {\n        ...getClassRevivers(),\n        ...getCommonRevivers(),\n      };\n    case 'client':\n      return {\n        ...getClassRevivers(),\n        ...getCommonRevivers(),\n        StepFunction: () => {\n          throw new Error(\n            'Step functions cannot be deserialized in client context.'\n          );\n        },\n      };\n  }\n}\n\nexport const devalueVmCodec: Codec = {\n  formatPrefix: SerializationFormat.DEVALUE_V1,\n\n  serialize(value: unknown, mode: SerializationMode): Uint8Array {\n    const reducers = getReducersForMode(mode);\n    const str = stringify(\n      value,\n      reducers as Record<string, (value: any) => any>\n    );\n    return encoder.encode(str);\n  },\n\n  deserialize(data: Uint8Array, mode: SerializationMode): unknown {\n    const revivers = getReviversForMode(mode);\n    const str = decoder.decode(data);\n    return parse(str, revivers as Record<string, (value: any) => any>);\n  },\n\n  deserializeLegacy(data: unknown, mode: SerializationMode): unknown {\n    const revivers = getReviversForMode(mode);\n    return unflatten(\n      data as any[],\n      revivers as Record<string, (value: any) => any>\n    );\n  },\n};\n"]}

package/dist/serialization/reducers/class-vm.d.ts

@@ -0,0 +1,20 @@
+/**
+ * VM-compatible copy: identical semantics to class.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.
+ */
+/**
+ * Reducers and revivers for custom class serialization.
+ *
+ * Handles:
+ * - Class: class constructors with a `classId` property
+ * - Instance: instances of classes with custom WORKFLOW_SERIALIZE/DESERIALIZE methods
+ */
+import type { Reducers, Revivers } from '../types.js';
+export declare function getClassReducers(): Partial<Reducers>;
+export declare function getClassRevivers(global?: Record<string, any>): Partial<Revivers>;
+//# sourceMappingURL=class-vm.d.ts.map

package/dist/serialization/reducers/class-vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-vm.d.ts","sourceRoot":"","sources":["../../../src/serialization/reducers/class-vm.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAItD,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,QAAQ,CAAC,CA8BpD;AAID,wBAAgB,gBAAgB,CAC9B,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAc,GACvC,OAAO,CAAC,QAAQ,CAAC,CAiCnB"}

package/dist/serialization/reducers/class-vm.js

@@ -0,0 +1,77 @@
+/**
+ * VM-compatible copy: identical semantics to class.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.
+ */
+/**
+ * Reducers and revivers for custom class serialization.
+ *
+ * Handles:
+ * - Class: class constructors with a `classId` property
+ * - Instance: instances of classes with custom WORKFLOW_SERIALIZE/DESERIALIZE methods
+ */
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
+import { getSerializationClass } from '../../class-serialization.js';
+// ---- Reducers ----
+export function getClassReducers() {
+    return {
+        // Class and Instance are intentionally placed before Error so that
+        // custom Error subclasses with WORKFLOW_SERIALIZE take precedence
+        // over the generic Error serialization (devalue uses first-match-wins).
+        Class: (value) => {
+            if (typeof value !== 'function')
+                return false;
+            const classId = value.classId;
+            if (typeof classId !== 'string')
+                return false;
+            return { classId };
+        },
+        Instance: (value) => {
+            if (value === null || typeof value !== 'object')
+                return false;
+            const cls = value.constructor;
+            if (!cls || typeof cls !== 'function')
+                return false;
+            const serialize = cls[WORKFLOW_SERIALIZE];
+            if (typeof serialize !== 'function')
+                return false;
+            const classId = cls.classId;
+            if (typeof classId !== 'string') {
+                throw new Error(`Class "${cls.name}" with ${String(WORKFLOW_SERIALIZE)} must have a static "classId" property.`);
+            }
+            const data = serialize.call(cls, value);
+            return { classId, data };
+        },
+    };
+}
+// ---- Revivers ----
+export function getClassRevivers(global = globalThis) {
+    return {
+        Class: (value) => {
+            const classId = value.classId;
+            const cls = getSerializationClass(classId, global);
+            if (!cls) {
+                throw new Error(`Class "${classId}" not found. Make sure the class is registered with registerSerializationClass.`);
+            }
+            return cls;
+        },
+        Instance: (value) => {
+            const classId = value.classId;
+            const data = value.data;
+            const cls = getSerializationClass(classId, global);
+            if (!cls) {
+                throw new Error(`Class "${classId}" not found. Make sure the class is registered with registerSerializationClass.`);
+            }
+            const deserialize = cls[WORKFLOW_DESERIALIZE];
+            if (typeof deserialize !== 'function') {
+                throw new Error(`Class "${classId}" does not have a static ${String(WORKFLOW_DESERIALIZE)} method.`);
+            }
+            return deserialize.call(cls, data);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/reducers/common-vm.d.ts

@@ -0,0 +1,15 @@
+/**
+ * VM-compatible common reducers and revivers.
+ *
+ * Identical to common.ts but without Node.js dependencies:
+ * - Uses native `btoa` / `atob` (provided by quickjs-wasi's base64
+ *   extension, see `quickjs-assets.generated.ts`) instead of Buffer
+ *   or pure-JS base64.
+ * - Uses `instanceof Error` instead of `types.isNativeError()`.
+ *
+ * This module is safe to bundle into the QuickJS WASM VM.
+ */
+import type { Reducers, Revivers } from '../types.js';
+export declare function getCommonReducers(): Partial<Reducers>;
+export declare function getCommonRevivers(): Partial<Revivers>;
+//# sourceMappingURL=common-vm.d.ts.map

package/dist/serialization/reducers/common-vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-vm.d.ts","sourceRoot":"","sources":["../../../src/serialization/reducers/common-vm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAuB,MAAM,aAAa,CAAC;AA6E3E,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,QAAQ,CAAC,CAqQrD;AAID,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,QAAQ,CAAC,CA+NrD"}