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

package/README.md

@@ -1,3 +1,8 @@
 # @workflow/core
 
 Core runtime package for [Workflow SDK](https://workflow-sdk.dev).
+
+Queued step messages carry immutable run identity in `runContext`, so step
+execution skips the initial `runs.get` and fetches the run row only when
+continuing into workflow replay. Messages from older producers without
+`runContext` retain the initial fetch.

package/dist/attribute-changes.d.ts

@@ -0,0 +1,5 @@
+import { type AttributeChange } from '@workflow/world/attributes-validation';
+export declare function normalizeAttributeChanges(attrs: Record<string, string | undefined>, options?: {
+    allowReservedAttributes?: boolean;
+}): AttributeChange[];
+//# sourceMappingURL=attribute-changes.d.ts.map

package/dist/attribute-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-changes.d.ts","sourceRoot":"","sources":["../src/attribute-changes.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,uCAAuC,CAAC;AAE/C,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE;IAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAAO,GAClD,eAAe,EAAE,CA4BnB"}

package/dist/attribute-changes.js

@@ -0,0 +1,25 @@
+import { FatalError } from '@workflow/errors';
+import { AttributeValidationError, validateAttributeChanges, } from '@workflow/world/attributes-validation';
+export function normalizeAttributeChanges(attrs, options = {}) {
+    if (attrs === null || typeof attrs !== 'object' || Array.isArray(attrs)) {
+        throw new FatalError(`setAttributes requires a plain object, got ${attrs === null ? 'null' : Array.isArray(attrs) ? 'array' : typeof attrs}`);
+    }
+    const changes = Object.entries(attrs).map(([key, value]) => ({
+        key,
+        value: value === undefined ? null : value,
+    }));
+    if (changes.length === 0)
+        return changes;
+    const allowReservedAttributes = options.allowReservedAttributes === true;
+    try {
+        validateAttributeChanges(changes, { allowReservedAttributes });
+    }
+    catch (err) {
+        if (err instanceof AttributeValidationError) {
+            throw new FatalError(err.message);
+        }
+        throw err;
+    }
+    return changes;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/capabilities.d.ts

@@ -15,11 +15,34 @@
  *    `@workflow/core` version that supports it
  * 3. The `getRunCapabilities()` function will automatically include it
  *
+ * ## Adding a new non-format capability
+ *
+ * Some capabilities aren't serialization format prefixes: e.g.
+ * byte-stream wire framing is an envelope around chunks rather than
+ * a content format. For those, add a boolean field to `RunCapabilities`
+ * and an entry in `CAPABILITY_VERSION_TABLE` below.
+ *
  * ## History
  *
  * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`
  *   Commit: 7618ac36 "Wire AES-GCM encryption into serialization layer (#1251)"
  *   https://github.com/vercel/workflow/commit/7618ac36
+ * - `framedByteStreams` (wire-level chunk framing for byte streams): added in `5.0.0-beta.15`
+ * - `gzip` (gzip payload compression): added in `5.0.0-beta.18`
+ * - `zstd` (zstd payload compression, preferred codec): added in `5.0.0-beta.18`
+ *   alongside gzip; they co-ship, so any run that can read one can read both.
+ * - `encp` (X25519 sealed-box encryption for cross-run writes): added in
+ *   `5.0.0-beta.37`. Note that producers do **not** gate `encp` on this table:
+ *   they gate on the presence of `encryptionPublicKey` on the target run,
+ *   which a run only carries if the deployment that created it could also
+ *   open `encp`. The entry exists so the capability set stays a complete,
+ *   auditable description of a run's decoding ability.
+ * - Hook-resume consumer protocol ("consumer re-ensures `hook_received` from
+ *   `hookInput`"): deliberately NOT tracked here. Rather than predict a
+ *   release cutoff, the run's creating deployment stamps an explicit
+ *   `hookResumeInputVersion` execution-context marker (mirrored onto the
+ *   hook's resumeContext by the server); older producers gate their lazy path
+ *   on that marker.
  */
 import { type SerializationFormatType } from './serialization.js';
 /**
@@ -32,14 +55,24 @@ export interface RunCapabilities {
      * if encryption is supported, etc.
      */
     supportedFormats: ReadonlySet<SerializationFormatType>;
+    /**
+     * Whether the target run can decode wire-framed byte streams. When true,
+     * byte streams (`type: 'bytes'` ReadableStreams passed across boundaries)
+     * are wrapped in a length-prefixed frame envelope on the wire so the
+     * reader can identify chunk boundaries, which enables auto-reconnect
+     * on transient stream errors. When false, byte streams are written as
+     * raw bytes (the legacy format) for compatibility with older runs.
+     */
+    framedByteStreams: boolean;
 }
 /**
  * Look up what serialization capabilities a workflow run supports based on
  * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).
  *
  * When the version is `undefined`, not a string, or not a valid semver string
- * (e.g. very old runs that predate the field, or corrupted metadata),
- * we assume the most conservative capabilities (baseline formats only).
+ * (e.g. older runs that predate the field, or corrupted metadata),
+ * we assume the most conservative capabilities (baseline formats only,
+ * non-format capabilities all `false`).
  */
 export declare function getRunCapabilities(workflowCoreVersion: string | undefined): RunCapabilities;
 //# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,gBAAgB,EAAE,WAAW,CAAC,uBAAuB,CAAC,CAAC;CACxD;AA0BD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CAcjB"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,gBAAgB,EAAE,WAAW,CAAC,uBAAuB,CAAC,CAAC;IAEvD;;;;;;;OAOG;IACH,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AA+DD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CA4BjB"}

package/dist/capabilities.js

@@ -15,11 +15,34 @@
  *    `@workflow/core` version that supports it
  * 3. The `getRunCapabilities()` function will automatically include it
  *
+ * ## Adding a new non-format capability
+ *
+ * Some capabilities aren't serialization format prefixes: e.g.
+ * byte-stream wire framing is an envelope around chunks rather than
+ * a content format. For those, add a boolean field to `RunCapabilities`
+ * and an entry in `CAPABILITY_VERSION_TABLE` below.
+ *
  * ## History
  *
  * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`
  *   Commit: 7618ac36 "Wire AES-GCM encryption into serialization layer (#1251)"
  *   https://github.com/vercel/workflow/commit/7618ac36
+ * - `framedByteStreams` (wire-level chunk framing for byte streams): added in `5.0.0-beta.15`
+ * - `gzip` (gzip payload compression): added in `5.0.0-beta.18`
+ * - `zstd` (zstd payload compression, preferred codec): added in `5.0.0-beta.18`
+ *   alongside gzip; they co-ship, so any run that can read one can read both.
+ * - `encp` (X25519 sealed-box encryption for cross-run writes): added in
+ *   `5.0.0-beta.37`. Note that producers do **not** gate `encp` on this table:
+ *   they gate on the presence of `encryptionPublicKey` on the target run,
+ *   which a run only carries if the deployment that created it could also
+ *   open `encp`. The entry exists so the capability set stays a complete,
+ *   auditable description of a run's decoding ability.
+ * - Hook-resume consumer protocol ("consumer re-ensures `hook_received` from
+ *   `hookInput`"): deliberately NOT tracked here. Rather than predict a
+ *   release cutoff, the run's creating deployment stamps an explicit
+ *   `hookResumeInputVersion` execution-context marker (mirrored onto the
+ *   hook's resumeContext by the server); older producers gate their lazy path
+ *   on that marker.
  */
 import semver from 'semver';
 import { SerializationFormat, } from './serialization.js';
@@ -30,10 +53,43 @@ import { SerializationFormat, } from './serialization.js';
  */
 const FORMAT_VERSION_TABLE = [
     { format: SerializationFormat.ENCRYPTED, minVersion: '4.2.0-beta.64' },
+    // TODO(release): verify this matches the actual version that ships payload
+    // compression. If a "Version Packages (beta)" PR merges before this change,
+    // bump to the next beta. A too-low cutoff makes new producers write
+    // compressed payloads to consumers that cannot decompress them; too-high
+    // merely delays the optimization (safe). gzip and zstd ship together, so
+    // they share a min version: a run that can read one can read both.
+    { format: SerializationFormat.GZIP, minVersion: '5.0.0-beta.18' },
+    { format: SerializationFormat.ZSTD, minVersion: '5.0.0-beta.18' },
+    // TODO(release): verify this matches the actual version that ships sealed-box
+    // encryption. If a "Version Packages (beta)" PR merges before this change,
+    // bump to the next beta. Unlike the entries above, a wrong cutoff here is
+    // not a correctness hazard: producers gate `encp` on the target run carrying
+    // an `encryptionPublicKey`, not on this table (see History above).
+    { format: SerializationFormat.SEALED, minVersion: '5.0.0-beta.37' },
     // Future entries:
     // { format: SerializationFormat.CBOR, minVersion: '5.x.y' },
     // { format: SerializationFormat.ENCRYPTED_V2, minVersion: '5.x.y' },
 ];
+/**
+ * Maps non-format capability flags (booleans on `RunCapabilities`) to the
+ * minimum `@workflow/core` version that introduced support for them.
+ */
+const CAPABILITY_VERSION_TABLE = [
+    // TODO(release): verify this matches the actual version that ships byte-stream
+    // framing. If a "Version Packages (beta)" PR merges before this change, bump
+    // to the next beta. A too-low cutoff makes new producers write framed bytes to
+    // consumers that cannot unframe them (silent corruption); too-high merely
+    // delays the optimization (safe).
+    { capability: 'framedByteStreams', minVersion: '5.0.0-beta.15' },
+    // NOTE: the hook-resume consumer protocol ("does the consumer re-ensure
+    // `hook_received` from the queue message's `hookInput`?") is intentionally
+    // NOT gated here. A version-compare against a predicted release cutoff is a
+    // guess; instead the run's creating deployment stamps an explicit
+    // `hookResumeInputVersion` marker into its execution context, which the
+    // server mirrors onto the hook's resumeContext. Older producers gate their
+    // lazy path on that marker.
+];
 /**
  * The set of formats supported by all specVersion 2 runs, regardless of
  * `@workflow/core` version. These are the baseline formats that were present
@@ -47,12 +103,16 @@ const BASELINE_FORMATS = new Set([
  * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).
  *
  * When the version is `undefined`, not a string, or not a valid semver string
- * (e.g. very old runs that predate the field, or corrupted metadata),
- * we assume the most conservative capabilities (baseline formats only).
+ * (e.g. older runs that predate the field, or corrupted metadata),
+ * we assume the most conservative capabilities (baseline formats only,
+ * non-format capabilities all `false`).
  */
 export function getRunCapabilities(workflowCoreVersion) {
     if (!workflowCoreVersion || !semver.valid(workflowCoreVersion)) {
-        return { supportedFormats: BASELINE_FORMATS };
+        return {
+            supportedFormats: BASELINE_FORMATS,
+            framedByteStreams: false,
+        };
     }
     const formats = new Set(BASELINE_FORMATS);
     for (const { format, minVersion } of FORMAT_VERSION_TABLE) {
@@ -60,6 +120,15 @@ export function getRunCapabilities(workflowCoreVersion) {
             formats.add(format);
         }
     }
-    return { supportedFormats: formats };
+    const result = {
+        supportedFormats: formats,
+        framedByteStreams: false,
+    };
+    for (const { capability, minVersion } of CAPABILITY_VERSION_TABLE) {
+        if (semver.gte(workflowCoreVersion, minVersion)) {
+            result[capability] = true;
+        }
+    }
+    return result;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwYWJpbGl0aWVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NhcGFiaWxpdGllcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUVILE9BQU8sTUFBTSxNQUFNLFFBQVEsQ0FBQztBQUM1QixPQUFPLEVBQ0wsbUJBQW1CLEdBRXBCLE1BQU0sb0JBQW9CLENBQUM7QUFjNUI7Ozs7R0FJRztBQUNILE1BQU0sb0JBQW9CLEdBR3JCO0lBQ0gsRUFBRSxNQUFNLEVBQUUsbUJBQW1CLENBQUMsU0FBUyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUU7SUFDdEUsa0JBQWtCO0lBQ2xCLDZEQUE2RDtJQUM3RCxxRUFBcUU7Q0FDdEUsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCxNQUFNLGdCQUFnQixHQUF5QyxJQUFJLEdBQUcsQ0FBQztJQUNyRSxtQkFBbUIsQ0FBQyxVQUFVO0NBQy9CLENBQUMsQ0FBQztBQUVIOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsa0JBQWtCLENBQ2hDLG1CQUF1QztJQUV2QyxJQUFJLENBQUMsbUJBQW1CLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLG1CQUFtQixDQUFDLEVBQUUsQ0FBQztRQUMvRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQUUsQ0FBQztJQUNoRCxDQUFDO0lBRUQsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLENBQTBCLGdCQUFnQixDQUFDLENBQUM7SUFFbkUsS0FBSyxNQUFNLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxJQUFJLG9CQUFvQixFQUFFLENBQUM7UUFDMUQsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLG1CQUFtQixFQUFFLFVBQVUsQ0FBQyxFQUFFLENBQUM7WUFDaEQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN0QixDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDYXBhYmlsaXRpZXMgdGFibGUgZm9yIHdvcmtmbG93IHJ1bnMgYmFzZWQgb24gdGhlaXIgYEB3b3JrZmxvdy9jb3JlYCB2ZXJzaW9uLlxuICpcbiAqIFdoZW4gcmVzdW1pbmcgYSBob29rIG9yIHdlYmhvb2ssIHRoZSBwYXlsb2FkIG11c3QgYmUgZW5jb2RlZCBpbiBhIGZvcm1hdFxuICogdGhhdCB0aGUgKnRhcmdldCogd29ya2Zsb3cgcnVuJ3MgZGVwbG95bWVudCBjYW4gZGVjb2RlLiBUaGlzIG1vZHVsZSBwcm92aWRlc1xuICogYSB3YXkgdG8gbG9vayB1cCB3aGF0IHNlcmlhbGl6YXRpb24gZm9ybWF0cyBhIGdpdmVuIGBAd29ya2Zsb3cvY29yZWAgdmVyc2lvblxuICogc3VwcG9ydHMsIHNvIHRoYXQgbmV3ZXIgZGVwbG95bWVudHMgY2FuIGF2b2lkIGVuY29kaW5nIHBheWxvYWRzIGluIGZvcm1hdHNcbiAqIHRoYXQgb2xkZXIgZGVwbG95bWVudHMgZG9uJ3QgdW5kZXJzdGFuZCAoZS5nLiwgdGhlIGBlbmNyYCBlbmNyeXB0aW9uIGZvcm1hdCkuXG4gKlxuICogIyMgQWRkaW5nIGEgbmV3IGZvcm1hdFxuICpcbiAqIFdoZW4gYSBuZXcgc2VyaWFsaXphdGlvbiBmb3JtYXQgaXMgaW50cm9kdWNlZDpcbiAqIDEuIEFkZCB0aGUgZm9ybWF0IGNvbnN0YW50IHRvIGBTZXJpYWxpemF0aW9uRm9ybWF0YCBpbiBgc2VyaWFsaXphdGlvbi50c2BcbiAqIDIuIEFkZCBhbiBlbnRyeSB0byBgRk9STUFUX1ZFUlNJT05fVEFCTEVgIGJlbG93IHdpdGggdGhlIG1pbmltdW1cbiAqICAgIGBAd29ya2Zsb3cvY29yZWAgdmVyc2lvbiB0aGF0IHN1cHBvcnRzIGl0XG4gKiAzLiBUaGUgYGdldFJ1bkNhcGFiaWxpdGllcygpYCBmdW5jdGlvbiB3aWxsIGF1dG9tYXRpY2FsbHkgaW5jbHVkZSBpdFxuICpcbiAqICMjIEhpc3RvcnlcbiAqXG4gKiAtIGBlbmNyYCAoQUVTLTI1Ni1HQ00gZW5jcnlwdGlvbik6IGFkZGVkIGluIGA0LjIuMC1iZXRhLjY0YFxuICogICBDb21taXQ6IDc2MThhYzM2IFwiV2lyZSBBRVMtR0NNIGVuY3J5cHRpb24gaW50byBzZXJpYWxpemF0aW9uIGxheWVyICgjMTI1MSlcIlxuICogICBodHRwczovL2dpdGh1Yi5jb20vdmVyY2VsL3dvcmtmbG93L2NvbW1pdC83NjE4YWMzNlxuICovXG5cbmltcG9ydCBzZW12ZXIgZnJvbSAnc2VtdmVyJztcbmltcG9ydCB7XG4gIFNlcmlhbGl6YXRpb25Gb3JtYXQsXG4gIHR5cGUgU2VyaWFsaXphdGlvbkZvcm1hdFR5cGUsXG59IGZyb20gJy4vc2VyaWFsaXphdGlvbi5qcyc7XG5cbi8qKlxuICogQ2FwYWJpbGl0aWVzIG9mIGEgd29ya2Zsb3cgcnVuIGJhc2VkIG9uIGl0cyBgQHdvcmtmbG93L2NvcmVgIHZlcnNpb24uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUnVuQ2FwYWJpbGl0aWVzIHtcbiAgLyoqXG4gICAqIFRoZSBzZXQgb2Ygc2VyaWFsaXphdGlvbiBmb3JtYXQgcHJlZml4ZXMgdGhhdCB0aGUgdGFyZ2V0IHJ1biBjYW4gZGVjb2RlLlxuICAgKiBVc2UgYHN1cHBvcnRlZEZvcm1hdHMuaGFzKFNlcmlhbGl6YXRpb25Gb3JtYXQuRU5DUllQVEVEKWAgdG8gY2hlY2tcbiAgICogaWYgZW5jcnlwdGlvbiBpcyBzdXBwb3J0ZWQsIGV0Yy5cbiAgICovXG4gIHN1cHBvcnRlZEZvcm1hdHM6IFJlYWRvbmx5U2V0PFNlcmlhbGl6YXRpb25Gb3JtYXRUeXBlPjtcbn1cblxuLyoqXG4gKiBNYXBzIHNlcmlhbGl6YXRpb24gZm9ybWF0IGlkZW50aWZpZXJzIHRvIHRoZSBtaW5pbXVtIGBAd29ya2Zsb3cvY29yZWBcbiAqIHZlcnNpb24gdGhhdCBpbnRyb2R1Y2VkIHN1cHBvcnQgZm9yIHRoZW0uIEZvcm1hdHMgbm90IGxpc3RlZCBoZXJlIGFyZVxuICogYXNzdW1lZCB0byBiZSBzdXBwb3J0ZWQgYnkgYWxsIHNwZWNWZXJzaW9uIDIgcnVucyAoZS5nLiwgYGRldmxgKS5cbiAqL1xuY29uc3QgRk9STUFUX1ZFUlNJT05fVEFCTEU6IFJlYWRvbmx5QXJyYXk8e1xuICBmb3JtYXQ6IFNlcmlhbGl6YXRpb25Gb3JtYXRUeXBlO1xuICBtaW5WZXJzaW9uOiBzdHJpbmc7XG59PiA9IFtcbiAgeyBmb3JtYXQ6IFNlcmlhbGl6YXRpb25Gb3JtYXQuRU5DUllQVEVELCBtaW5WZXJzaW9uOiAnNC4yLjAtYmV0YS42NCcgfSxcbiAgLy8gRnV0dXJlIGVudHJpZXM6XG4gIC8vIHsgZm9ybWF0OiBTZXJpYWxpemF0aW9uRm9ybWF0LkNCT1IsIG1pblZlcnNpb246ICc1LngueScgfSxcbiAgLy8geyBmb3JtYXQ6IFNlcmlhbGl6YXRpb25Gb3JtYXQuRU5DUllQVEVEX1YyLCBtaW5WZXJzaW9uOiAnNS54LnknIH0sXG5dO1xuXG4vKipcbiAqIFRoZSBzZXQgb2YgZm9ybWF0cyBzdXBwb3J0ZWQgYnkgYWxsIHNwZWNWZXJzaW9uIDIgcnVucywgcmVnYXJkbGVzcyBvZlxuICogYEB3b3JrZmxvdy9jb3JlYCB2ZXJzaW9uLiBUaGVzZSBhcmUgdGhlIGJhc2VsaW5lIGZvcm1hdHMgdGhhdCB3ZXJlIHByZXNlbnRcbiAqIGZyb20gdGhlIHN0YXJ0IG9mIHRoZSBzcGVjVmVyc2lvbiAyIHByb3RvY29sLlxuICovXG5jb25zdCBCQVNFTElORV9GT1JNQVRTOiBSZWFkb25seVNldDxTZXJpYWxpemF0aW9uRm9ybWF0VHlwZT4gPSBuZXcgU2V0KFtcbiAgU2VyaWFsaXphdGlvbkZvcm1hdC5ERVZBTFVFX1YxLFxuXSk7XG5cbi8qKlxuICogTG9vayB1cCB3aGF0IHNlcmlhbGl6YXRpb24gY2FwYWJpbGl0aWVzIGEgd29ya2Zsb3cgcnVuIHN1cHBvcnRzIGJhc2VkIG9uXG4gKiBpdHMgYEB3b3JrZmxvdy9jb3JlYCB2ZXJzaW9uIHN0cmluZyAoZnJvbSBgZXhlY3V0aW9uQ29udGV4dC53b3JrZmxvd0NvcmVWZXJzaW9uYCkuXG4gKlxuICogV2hlbiB0aGUgdmVyc2lvbiBpcyBgdW5kZWZpbmVkYCwgbm90IGEgc3RyaW5nLCBvciBub3QgYSB2YWxpZCBzZW12ZXIgc3RyaW5nXG4gKiAoZS5nLiB2ZXJ5IG9sZCBydW5zIHRoYXQgcHJlZGF0ZSB0aGUgZmllbGQsIG9yIGNvcnJ1cHRlZCBtZXRhZGF0YSksXG4gKiB3ZSBhc3N1bWUgdGhlIG1vc3QgY29uc2VydmF0aXZlIGNhcGFiaWxpdGllcyAoYmFzZWxpbmUgZm9ybWF0cyBvbmx5KS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFJ1bkNhcGFiaWxpdGllcyhcbiAgd29ya2Zsb3dDb3JlVmVyc2lvbjogc3RyaW5nIHwgdW5kZWZpbmVkXG4pOiBSdW5DYXBhYmlsaXRpZXMge1xuICBpZiAoIXdvcmtmbG93Q29yZVZlcnNpb24gfHwgIXNlbXZlci52YWxpZCh3b3JrZmxvd0NvcmVWZXJzaW9uKSkge1xuICAgIHJldHVybiB7IHN1cHBvcnRlZEZvcm1hdHM6IEJBU0VMSU5FX0ZPUk1BVFMgfTtcbiAgfVxuXG4gIGNvbnN0IGZvcm1hdHMgPSBuZXcgU2V0PFNlcmlhbGl6YXRpb25Gb3JtYXRUeXBlPihCQVNFTElORV9GT1JNQVRTKTtcblxuICBmb3IgKGNvbnN0IHsgZm9ybWF0LCBtaW5WZXJzaW9uIH0gb2YgRk9STUFUX1ZFUlNJT05fVEFCTEUpIHtcbiAgICBpZiAoc2VtdmVyLmd0ZSh3b3JrZmxvd0NvcmVWZXJzaW9uLCBtaW5WZXJzaW9uKSkge1xuICAgICAgZm9ybWF0cy5hZGQoZm9ybWF0KTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4geyBzdXBwb3J0ZWRGb3JtYXRzOiBmb3JtYXRzIH07XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EACL,mBAAmB,GAEpB,MAAM,oBAAoB,CAAC;AAwB5B;;;;GAIG;AACH,MAAM,oBAAoB,GAGrB;IACH,EAAE,MAAM,EAAE,mBAAmB,CAAC,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE;IACtE,2EAA2E;IAC3E,4EAA4E;IAC5E,oEAAoE;IACpE,yEAAyE;IACzE,yEAAyE;IACzE,mEAAmE;IACnE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,8EAA8E;IAC9E,2EAA2E;IAC3E,0EAA0E;IAC1E,6EAA6E;IAC7E,mEAAmE;IACnE,EAAE,MAAM,EAAE,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE;IACnE,kBAAkB;IAClB,6DAA6D;IAC7D,qEAAqE;CACtE,CAAC;AAEF;;;GAGG;AACH,MAAM,wBAAwB,GAGzB;IACH,+EAA+E;IAC/E,6EAA6E;IAC7E,+EAA+E;IAC/E,0EAA0E;IAC1E,kCAAkC;IAClC,EAAE,UAAU,EAAE,mBAAmB,EAAE,UAAU,EAAE,eAAe,EAAE;IAChE,wEAAwE;IACxE,2EAA2E;IAC3E,4EAA4E;IAC5E,kEAAkE;IAClE,wEAAwE;IACxE,2EAA2E;IAC3E,4BAA4B;CAC7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,gBAAgB,GAAyC,IAAI,GAAG,CAAC;IACrE,mBAAmB,CAAC,UAAU;CAC/B,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,mBAAuC;IAEvC,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC/D,OAAO;YACL,gBAAgB,EAAE,gBAAgB;YAClC,iBAAiB,EAAE,KAAK;SACzB,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAA0B,gBAAgB,CAAC,CAAC;IAEnE,KAAK,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,oBAAoB,EAAE,CAAC;QAC1D,IAAI,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAAE,CAAC;YAChD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAoB;QAC9B,gBAAgB,EAAE,OAAO;QACzB,iBAAiB,EAAE,KAAK;KACzB,CAAC;IAEF,KAAK,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,wBAAwB,EAAE,CAAC;QAClE,IAAI,MAAM,CAAC,GAAG,CAAC,mBAAmB,EAAE,UAAU,CAAC,EAAE,CAAC;YAChD,MAAM,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * Capabilities table for workflow runs based on their `@workflow/core` version.\n *\n * When resuming a hook or webhook, the payload must be encoded in a format\n * that the *target* workflow run's deployment can decode. This module provides\n * a way to look up what serialization formats a given `@workflow/core` version\n * supports, so that newer deployments can avoid encoding payloads in formats\n * that older deployments don't understand (e.g., the `encr` encryption format).\n *\n * ## Adding a new format\n *\n * When a new serialization format is introduced:\n * 1. Add the format constant to `SerializationFormat` in `serialization.ts`\n * 2. Add an entry to `FORMAT_VERSION_TABLE` below with the minimum\n *    `@workflow/core` version that supports it\n * 3. The `getRunCapabilities()` function will automatically include it\n *\n * ## Adding a new non-format capability\n *\n * Some capabilities aren't serialization format prefixes: e.g.\n * byte-stream wire framing is an envelope around chunks rather than\n * a content format. For those, add a boolean field to `RunCapabilities`\n * and an entry in `CAPABILITY_VERSION_TABLE` below.\n *\n * ## History\n *\n * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`\n *   Commit: 7618ac36 \"Wire AES-GCM encryption into serialization layer (#1251)\"\n *   https://github.com/vercel/workflow/commit/7618ac36\n * - `framedByteStreams` (wire-level chunk framing for byte streams): added in `5.0.0-beta.15`\n * - `gzip` (gzip payload compression): added in `5.0.0-beta.18`\n * - `zstd` (zstd payload compression, preferred codec): added in `5.0.0-beta.18`\n *   alongside gzip; they co-ship, so any run that can read one can read both.\n * - `encp` (X25519 sealed-box encryption for cross-run writes): added in\n *   `5.0.0-beta.37`. Note that producers do **not** gate `encp` on this table:\n *   they gate on the presence of `encryptionPublicKey` on the target run,\n *   which a run only carries if the deployment that created it could also\n *   open `encp`. The entry exists so the capability set stays a complete,\n *   auditable description of a run's decoding ability.\n * - Hook-resume consumer protocol (\"consumer re-ensures `hook_received` from\n *   `hookInput`\"): deliberately NOT tracked here. Rather than predict a\n *   release cutoff, the run's creating deployment stamps an explicit\n *   `hookResumeInputVersion` execution-context marker (mirrored onto the\n *   hook's resumeContext by the server); older producers gate their lazy path\n *   on that marker.\n */\n\nimport semver from 'semver';\nimport {\n  SerializationFormat,\n  type SerializationFormatType,\n} from './serialization.js';\n\n/**\n * Capabilities of a workflow run based on its `@workflow/core` version.\n */\nexport interface RunCapabilities {\n  /**\n   * The set of serialization format prefixes that the target run can decode.\n   * Use `supportedFormats.has(SerializationFormat.ENCRYPTED)` to check\n   * if encryption is supported, etc.\n   */\n  supportedFormats: ReadonlySet<SerializationFormatType>;\n\n  /**\n   * Whether the target run can decode wire-framed byte streams. When true,\n   * byte streams (`type: 'bytes'` ReadableStreams passed across boundaries)\n   * are wrapped in a length-prefixed frame envelope on the wire so the\n   * reader can identify chunk boundaries, which enables auto-reconnect\n   * on transient stream errors. When false, byte streams are written as\n   * raw bytes (the legacy format) for compatibility with older runs.\n   */\n  framedByteStreams: boolean;\n}\n\n/**\n * Maps serialization format identifiers to the minimum `@workflow/core`\n * version that introduced support for them. Formats not listed here are\n * assumed to be supported by all specVersion 2 runs (e.g., `devl`).\n */\nconst FORMAT_VERSION_TABLE: ReadonlyArray<{\n  format: SerializationFormatType;\n  minVersion: string;\n}> = [\n  { format: SerializationFormat.ENCRYPTED, minVersion: '4.2.0-beta.64' },\n  // TODO(release): verify this matches the actual version that ships payload\n  // compression. If a \"Version Packages (beta)\" PR merges before this change,\n  // bump to the next beta. A too-low cutoff makes new producers write\n  // compressed payloads to consumers that cannot decompress them; too-high\n  // merely delays the optimization (safe). gzip and zstd ship together, so\n  // they share a min version: a run that can read one can read both.\n  { format: SerializationFormat.GZIP, minVersion: '5.0.0-beta.18' },\n  { format: SerializationFormat.ZSTD, minVersion: '5.0.0-beta.18' },\n  // TODO(release): verify this matches the actual version that ships sealed-box\n  // encryption. If a \"Version Packages (beta)\" PR merges before this change,\n  // bump to the next beta. Unlike the entries above, a wrong cutoff here is\n  // not a correctness hazard: producers gate `encp` on the target run carrying\n  // an `encryptionPublicKey`, not on this table (see History above).\n  { format: SerializationFormat.SEALED, minVersion: '5.0.0-beta.37' },\n  // Future entries:\n  // { format: SerializationFormat.CBOR, minVersion: '5.x.y' },\n  // { format: SerializationFormat.ENCRYPTED_V2, minVersion: '5.x.y' },\n];\n\n/**\n * Maps non-format capability flags (booleans on `RunCapabilities`) to the\n * minimum `@workflow/core` version that introduced support for them.\n */\nconst CAPABILITY_VERSION_TABLE: ReadonlyArray<{\n  capability: keyof Omit<RunCapabilities, 'supportedFormats'>;\n  minVersion: string;\n}> = [\n  // TODO(release): verify this matches the actual version that ships byte-stream\n  // framing. If a \"Version Packages (beta)\" PR merges before this change, bump\n  // to the next beta. A too-low cutoff makes new producers write framed bytes to\n  // consumers that cannot unframe them (silent corruption); too-high merely\n  // delays the optimization (safe).\n  { capability: 'framedByteStreams', minVersion: '5.0.0-beta.15' },\n  // NOTE: the hook-resume consumer protocol (\"does the consumer re-ensure\n  // `hook_received` from the queue message's `hookInput`?\") is intentionally\n  // NOT gated here. A version-compare against a predicted release cutoff is a\n  // guess; instead the run's creating deployment stamps an explicit\n  // `hookResumeInputVersion` marker into its execution context, which the\n  // server mirrors onto the hook's resumeContext. Older producers gate their\n  // lazy path on that marker.\n];\n\n/**\n * The set of formats supported by all specVersion 2 runs, regardless of\n * `@workflow/core` version. These are the baseline formats that were present\n * from the start of the specVersion 2 protocol.\n */\nconst BASELINE_FORMATS: ReadonlySet<SerializationFormatType> = new Set([\n  SerializationFormat.DEVALUE_V1,\n]);\n\n/**\n * Look up what serialization capabilities a workflow run supports based on\n * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).\n *\n * When the version is `undefined`, not a string, or not a valid semver string\n * (e.g. older runs that predate the field, or corrupted metadata),\n * we assume the most conservative capabilities (baseline formats only,\n * non-format capabilities all `false`).\n */\nexport function getRunCapabilities(\n  workflowCoreVersion: string | undefined\n): RunCapabilities {\n  if (!workflowCoreVersion || !semver.valid(workflowCoreVersion)) {\n    return {\n      supportedFormats: BASELINE_FORMATS,\n      framedByteStreams: false,\n    };\n  }\n\n  const formats = new Set<SerializationFormatType>(BASELINE_FORMATS);\n\n  for (const { format, minVersion } of FORMAT_VERSION_TABLE) {\n    if (semver.gte(workflowCoreVersion, minVersion)) {\n      formats.add(format);\n    }\n  }\n\n  const result: RunCapabilities = {\n    supportedFormats: formats,\n    framedByteStreams: false,\n  };\n\n  for (const { capability, minVersion } of CAPABILITY_VERSION_TABLE) {\n    if (semver.gte(workflowCoreVersion, minVersion)) {\n      result[capability] = true;\n    }\n  }\n\n  return result;\n}\n"]}

package/dist/capture-stack.d.ts

@@ -5,7 +5,7 @@
  * code frame at our `throw` site inside `@workflow/core`, which is useless
  * to the user.
  *
- * No-op on engines that don't expose `Error.captureStackTrace` — the stack
+ * No-op on engines that don't expose `Error.captureStackTrace`: the stack
  * degrades gracefully to the default behavior.
  *
  * Kept in its own tiny module so callers that can't participate in the

package/dist/capture-stack.js

@@ -5,7 +5,7 @@
  * code frame at our `throw` site inside `@workflow/core`, which is useless
  * to the user.
  *
- * No-op on engines that don't expose `Error.captureStackTrace` — the stack
+ * No-op on engines that don't expose `Error.captureStackTrace`: the stack
  * degrades gracefully to the default behavior.
  *
  * Kept in its own tiny module so callers that can't participate in the
@@ -18,4 +18,4 @@ stackStartFn) {
     const capture = Error.captureStackTrace;
     capture?.(err, stackStartFn);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwdHVyZS1zdGFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jYXB0dXJlLXN0YWNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQ25DLEdBQVU7QUFDVix3RkFBd0Y7QUFDeEYsWUFBc0I7SUFFdEIsTUFBTSxPQUFPLEdBQ1gsS0FHRCxDQUFDLGlCQUFpQixDQUFDO0lBQ3BCLE9BQU8sRUFBRSxDQUFDLEdBQUcsRUFBRSxZQUFZLENBQUMsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBWOC1vbmx5IChOb2RlLCBCdW4sIENocm9tZSwgRGVubykuIFJld3JpdGVzIGBlcnIuc3RhY2tgIHNvIHRoZSB0b3AgZnJhbWUgaXNcbiAqIHRoZSBjYWxsZXIgb2YgYHN0YWNrU3RhcnRGbmAgaW5zdGVhZCBvZiB0aGUgZnJhbWV3b3JrIGZ1bmN0aW9uIHRoYXQgdGhyZXcuXG4gKiBXaXRob3V0IHRoaXMsIHRlcm1pbmFsIG92ZXJsYXlzIChOZXh0LmpzLCBUdXJib3BhY2ssIFZTIENvZGUpIHJlbmRlciB0aGVcbiAqIGNvZGUgZnJhbWUgYXQgb3VyIGB0aHJvd2Agc2l0ZSBpbnNpZGUgYEB3b3JrZmxvdy9jb3JlYCwgd2hpY2ggaXMgdXNlbGVzc1xuICogdG8gdGhlIHVzZXIuXG4gKlxuICogTm8tb3Agb24gZW5naW5lcyB0aGF0IGRvbid0IGV4cG9zZSBgRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2VgIOKAlCB0aGUgc3RhY2tcbiAqIGRlZ3JhZGVzIGdyYWNlZnVsbHkgdG8gdGhlIGRlZmF1bHQgYmVoYXZpb3IuXG4gKlxuICogS2VwdCBpbiBpdHMgb3duIHRpbnkgbW9kdWxlIHNvIGNhbGxlcnMgdGhhdCBjYW4ndCBwYXJ0aWNpcGF0ZSBpbiB0aGVcbiAqIGBjb250ZXh0LWVycm9ycy50c2Ag4oaUIGB3b3JrZmxvdy9nZXQtd29ya2Zsb3ctbWV0YWRhdGEudHNgIGltcG9ydCBjeWNsZSBjYW5cbiAqIHN0aWxsIHB1bGwgaW4gdGhlIGhlbHBlciB3aXRob3V0IHB1bGxpbmcgaW4gdGhlIGZ1bGwgZXJyb3IgY2xhc3Nlcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlZGlyZWN0U3RhY2tUb0NhbGxlcihcbiAgZXJyOiBFcnJvcixcbiAgLy8gYmlvbWUtaWdub3JlIGxpbnQvY29tcGxleGl0eS9ub0Jhbm5lZFR5cGVzOiBzaWduYXR1cmUgbWF0Y2hlcyBFcnJvci5jYXB0dXJlU3RhY2tUcmFjZVxuICBzdGFja1N0YXJ0Rm46IEZ1bmN0aW9uXG4pOiB2b2lkIHtcbiAgY29uc3QgY2FwdHVyZSA9IChcbiAgICBFcnJvciBhcyB1bmtub3duIGFzIHtcbiAgICAgIGNhcHR1cmVTdGFja1RyYWNlPzogKHRhcmdldDogb2JqZWN0LCBmbjogRnVuY3Rpb24pID0+IHZvaWQ7XG4gICAgfVxuICApLmNhcHR1cmVTdGFja1RyYWNlO1xuICBjYXB0dXJlPy4oZXJyLCBzdGFja1N0YXJ0Rm4pO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwdHVyZS1zdGFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jYXB0dXJlLXN0YWNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQ25DLEdBQVU7QUFDVix3RkFBd0Y7QUFDeEYsWUFBc0I7SUFFdEIsTUFBTSxPQUFPLEdBQ1gsS0FHRCxDQUFDLGlCQUFpQixDQUFDO0lBQ3BCLE9BQU8sRUFBRSxDQUFDLEdBQUcsRUFBRSxZQUFZLENBQUMsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBWOC1vbmx5IChOb2RlLCBCdW4sIENocm9tZSwgRGVubykuIFJld3JpdGVzIGBlcnIuc3RhY2tgIHNvIHRoZSB0b3AgZnJhbWUgaXNcbiAqIHRoZSBjYWxsZXIgb2YgYHN0YWNrU3RhcnRGbmAgaW5zdGVhZCBvZiB0aGUgZnJhbWV3b3JrIGZ1bmN0aW9uIHRoYXQgdGhyZXcuXG4gKiBXaXRob3V0IHRoaXMsIHRlcm1pbmFsIG92ZXJsYXlzIChOZXh0LmpzLCBUdXJib3BhY2ssIFZTIENvZGUpIHJlbmRlciB0aGVcbiAqIGNvZGUgZnJhbWUgYXQgb3VyIGB0aHJvd2Agc2l0ZSBpbnNpZGUgYEB3b3JrZmxvdy9jb3JlYCwgd2hpY2ggaXMgdXNlbGVzc1xuICogdG8gdGhlIHVzZXIuXG4gKlxuICogTm8tb3Agb24gZW5naW5lcyB0aGF0IGRvbid0IGV4cG9zZSBgRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2VgOiB0aGUgc3RhY2tcbiAqIGRlZ3JhZGVzIGdyYWNlZnVsbHkgdG8gdGhlIGRlZmF1bHQgYmVoYXZpb3IuXG4gKlxuICogS2VwdCBpbiBpdHMgb3duIHRpbnkgbW9kdWxlIHNvIGNhbGxlcnMgdGhhdCBjYW4ndCBwYXJ0aWNpcGF0ZSBpbiB0aGVcbiAqIGBjb250ZXh0LWVycm9ycy50c2Ag4oaUIGB3b3JrZmxvdy9nZXQtd29ya2Zsb3ctbWV0YWRhdGEudHNgIGltcG9ydCBjeWNsZSBjYW5cbiAqIHN0aWxsIHB1bGwgaW4gdGhlIGhlbHBlciB3aXRob3V0IHB1bGxpbmcgaW4gdGhlIGZ1bGwgZXJyb3IgY2xhc3Nlcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlZGlyZWN0U3RhY2tUb0NhbGxlcihcbiAgZXJyOiBFcnJvcixcbiAgLy8gYmlvbWUtaWdub3JlIGxpbnQvY29tcGxleGl0eS9ub0Jhbm5lZFR5cGVzOiBzaWduYXR1cmUgbWF0Y2hlcyBFcnJvci5jYXB0dXJlU3RhY2tUcmFjZVxuICBzdGFja1N0YXJ0Rm46IEZ1bmN0aW9uXG4pOiB2b2lkIHtcbiAgY29uc3QgY2FwdHVyZSA9IChcbiAgICBFcnJvciBhcyB1bmtub3duIGFzIHtcbiAgICAgIGNhcHR1cmVTdGFja1RyYWNlPzogKHRhcmdldDogb2JqZWN0LCBmbjogRnVuY3Rpb24pID0+IHZvaWQ7XG4gICAgfVxuICApLmNhcHR1cmVTdGFja1RyYWNlO1xuICBjYXB0dXJlPy4oZXJyLCBzdGFja1N0YXJ0Rm4pO1xufVxuIl19

package/dist/class-serialization.d.ts

@@ -18,6 +18,38 @@
  * when serializing instances (e.g., step return values).
  */
 export declare function registerSerializationClass(classId: string, cls: Function): void;
+/**
+ * Stable, well-known registry ID for the SDK's `Run` class.
+ *
+ * The SWC plugin auto-registers `Run` under a *path-derived* ID (e.g.
+ * `class//./node_modules/@workflow/core/dist/runtime/run//Run`), which
+ * varies with the app's dependency layout and bundler. Host-side code
+ * that needs to construct `Run` instances inside the workflow VM (e.g.
+ * the hook event consumer resolving `hook.getConflict()`) cannot know
+ * that ID statically, so the workflow-mode `create-hook` module also
+ * aliases the bundle's `Run` under this stable ID at evaluation time.
+ *
+ * The `workflow` pseudo-path cannot collide with plugin-derived IDs,
+ * which always use real relative module paths (`./…` / `../…`).
+ */
+export declare const RUN_CLASS_ID = "class//workflow//Run";
+/**
+ * Register an additional registry ID for a class without touching its
+ * `classId` property.
+ *
+ * Unlike {@link registerSerializationClass}, this is safe to call for a
+ * class the SWC plugin has already registered: the plugin's inlined IIFE
+ * defines `classId` as non-configurable, so a second `defineProperty`
+ * would throw. Aliasing only adds a registry entry: the class keeps
+ * serializing under its primary (path-derived) id, while lookups succeed
+ * under both IDs.
+ *
+ * Registration is per-global by construction: evaluated inside the
+ * workflow VM it registers the VM's compiled class on the VM's registry;
+ * evaluated on the host it registers the host class on the host's
+ * registry. Each context resolves its own correct variant.
+ */
+export declare function aliasSerializationClass(classId: string, cls: Function, global?: Record<string, any>): void;
 /**
  * Find a registered class constructor by ID (used during deserialization)
  *

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

@@ -1 +1 @@
-{"version":3,"file":"class-serialization.d.ts","sourceRoot":"","sources":["../src/class-serialization.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAuBH;;;;;;;;;;;GAWG;AAEH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,QASxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAE1B,QAAQ,GAAG,SAAS,CAEtB"}
+{"version":3,"file":"class-serialization.d.ts","sourceRoot":"","sources":["../src/class-serialization.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAuBH;;;;;;;;;;;GAWG;AAEH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,QASxE;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,yBAAyB,CAAC;AAEnD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAEf,GAAG,EAAE,QAAQ,EACb,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAc,QAGzC;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAE1B,QAAQ,GAAG,SAAS,CAEtB"}

package/dist/class-serialization.js

@@ -44,6 +44,42 @@ export function registerSerializationClass(classId, cls) {
         configurable: false,
     });
 }
+/**
+ * Stable, well-known registry ID for the SDK's `Run` class.
+ *
+ * The SWC plugin auto-registers `Run` under a *path-derived* ID (e.g.
+ * `class//./node_modules/@workflow/core/dist/runtime/run//Run`), which
+ * varies with the app's dependency layout and bundler. Host-side code
+ * that needs to construct `Run` instances inside the workflow VM (e.g.
+ * the hook event consumer resolving `hook.getConflict()`) cannot know
+ * that ID statically, so the workflow-mode `create-hook` module also
+ * aliases the bundle's `Run` under this stable ID at evaluation time.
+ *
+ * The `workflow` pseudo-path cannot collide with plugin-derived IDs,
+ * which always use real relative module paths (`./…` / `../…`).
+ */
+export const RUN_CLASS_ID = 'class//workflow//Run';
+/**
+ * Register an additional registry ID for a class without touching its
+ * `classId` property.
+ *
+ * Unlike {@link registerSerializationClass}, this is safe to call for a
+ * class the SWC plugin has already registered: the plugin's inlined IIFE
+ * defines `classId` as non-configurable, so a second `defineProperty`
+ * would throw. Aliasing only adds a registry entry: the class keeps
+ * serializing under its primary (path-derived) id, while lookups succeed
+ * under both IDs.
+ *
+ * Registration is per-global by construction: evaluated inside the
+ * workflow VM it registers the VM's compiled class on the VM's registry;
+ * evaluated on the host it registers the host class on the host's
+ * registry. Each context resolves its own correct variant.
+ */
+export function aliasSerializationClass(classId, 
+// biome-ignore lint/complexity/noBannedTypes: We need to use Function to represent class constructors
+cls, global = globalThis) {
+    getRegistry(global).set(classId, cls);
+}
 /**
  * Find a registered class constructor by ID (used during deserialization)
  *
@@ -58,4 +94,4 @@ export function getSerializationClass(classId, global
 ) {
     return getRegistry(global).get(classId);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/classify-error.d.ts

@@ -1,12 +1,12 @@
-import { type RunErrorCode } from '@workflow/errors';
+import { type RunErrorCode, WorkflowWorldError } from '@workflow/errors';
 /**
  * Classify an error that caused a workflow run to fail.
  *
  * After the structural separation of infrastructure vs user code error
  * handling, the only errors that reach the `run_failed` try/catch are:
  * - User code errors (throws from workflow functions, propagated step failures)
- * - WorkflowRuntimeError and subclasses (corrupted event log, missing
- *   timestamps, workflow/step not registered, etc.)
+ * - WorkflowRuntimeError and subclasses (missing timestamps, workflow/step
+ *   not registered, corrupted event log, etc.)
  *
  * Uses each subclass's `.is()` static (a name-based duck check) instead of
  * a single `instanceof` check because workflows execute in a separate
@@ -15,5 +15,21 @@ import { type RunErrorCode } from '@workflow/errors';
  * thrown inside the workflow VM and we'd misclassify genuine runtime
  * errors as user errors.
  */
+export declare function isWorldContractError(err: unknown): err is WorkflowWorldError;
+/**
+ * True when an error from a world (workflow-server) call is a transient
+ * infrastructure failure that should be retried by redelivering the queue
+ * message, rather than failing the run. A fresh invocation will likely
+ * succeed once the backend (or the firewall in front of it) recovers.
+ *
+ * - `ThrottleError` (429): rate limited / load shed
+ * - `WorkflowWorldError` with `status >= 500`: server-side error
+ * - `WorkflowWorldError` with a retryable transport `code` (`TRANSPORT` /
+ *   `TIMEOUT`): the request never produced a usable response
+ *
+ * Uses `.is()` name-based duck checks (not `instanceof`) for the same
+ * cross-`vm`-realm reason described on `classifyRunError`.
+ */
+export declare function isRetryableWorldError(err: unknown): boolean;
 export declare function classifyRunError(err: unknown): RunErrorCode;
 //# sourceMappingURL=classify-error.d.ts.map

package/dist/classify-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"classify-error.d.ts","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAIlB,MAAM,kBAAkB,CAAC;AAe1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAO3D"}
+{"version":3,"file":"classify-error.d.ts","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,YAAY,EAQjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AA0C1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAe5E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAc3D;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAsC3D"}