@workflow/core 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/attribute-changes.d.ts

@@ -0,0 +1,7 @@
+import { type AttributeChange } from '@workflow/world';
+interface AttributeChangeOptions {
+    allowReservedAttributes?: boolean;
+}
+export declare function normalizeAttributeChanges(attrs: Record<string, string | undefined>, options?: AttributeChangeOptions): AttributeChange[];
+export {};
+//# 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,iBAAiB,CAAC;AAEzB,UAAU,sBAAsB;IAC9B,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,sBAA2B,GACnC,eAAe,EAAE,CA4BnB"}

package/dist/attribute-changes.js

@@ -0,0 +1,25 @@
+import { FatalError } from '@workflow/errors';
+import { AttributeValidationError, validateAttributeChanges, } from '@workflow/world';
+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,22 @@
  *    `@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.
  */
 import { type SerializationFormatType } from './serialization.js';
 /**
@@ -32,6 +43,15 @@ 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
@@ -39,7 +59,8 @@ export interface RunCapabilities {
  *
  * 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).
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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;AAgDD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CA4BjB"}

package/dist/capabilities.js

@@ -15,11 +15,22 @@
  *    `@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.
  */
 import semver from 'semver';
 import { SerializationFormat, } from './serialization.js';
@@ -30,10 +41,23 @@ 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' },
     // 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 = [{ capability: 'framedByteStreams', minVersion: '5.0.0-beta.15' }];
 /**
  * The set of formats supported by all specVersion 2 runs, regardless of
  * `@workflow/core` version. These are the baseline formats that were present
@@ -48,11 +72,15 @@ const BASELINE_FORMATS = new Set([
  *
  * 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).
+ * 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 +88,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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,oEAAoE;IACpE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE;IACjE,kBAAkB;IAClB,6DAA6D;IAC7D,qEAAqE;CACtE,CAAC;AAEF;;;GAGG;AACH,MAAM,wBAAwB,GAQzB,CAAC,EAAE,UAAU,EAAE,mBAAmB,EAAE,UAAU,EAAE,eAAe,EAAE,CAAC,CAAC;AAExE;;;;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 */\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  // 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  // 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\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. very old 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

@@ -0,0 +1,16 @@
+/**
+ * V8-only (Node, Bun, Chrome, Deno). Rewrites `err.stack` so the top frame is
+ * the caller of `stackStartFn` instead of the framework function that threw.
+ * Without this, terminal overlays (Next.js, Turbopack, VS Code) render the
+ * 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
+ * degrades gracefully to the default behavior.
+ *
+ * Kept in its own tiny module so callers that can't participate in the
+ * `context-errors.ts` ↔ `workflow/get-workflow-metadata.ts` import cycle can
+ * still pull in the helper without pulling in the full error classes.
+ */
+export declare function redirectStackToCaller(err: Error, stackStartFn: Function): void;
+//# sourceMappingURL=capture-stack.d.ts.map

package/dist/capture-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-stack.d.ts","sourceRoot":"","sources":["../src/capture-stack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,KAAK,EAEV,YAAY,EAAE,QAAQ,GACrB,IAAI,CAON"}

package/dist/capture-stack.js

@@ -0,0 +1,21 @@
+/**
+ * V8-only (Node, Bun, Chrome, Deno). Rewrites `err.stack` so the top frame is
+ * the caller of `stackStartFn` instead of the framework function that threw.
+ * Without this, terminal overlays (Next.js, Turbopack, VS Code) render the
+ * 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
+ * degrades gracefully to the default behavior.
+ *
+ * Kept in its own tiny module so callers that can't participate in the
+ * `context-errors.ts` ↔ `workflow/get-workflow-metadata.ts` import cycle can
+ * still pull in the helper without pulling in the full error classes.
+ */
+export function redirectStackToCaller(err, 
+// biome-ignore lint/complexity/noBannedTypes: signature matches Error.captureStackTrace
+stackStartFn) {
+    const capture = Error.captureStackTrace;
+    capture?.(err, stackStartFn);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwdHVyZS1zdGFjay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9jYXB0dXJlLXN0YWNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLFVBQVUscUJBQXFCLENBQ25DLEdBQVU7QUFDVix3RkFBd0Y7QUFDeEYsWUFBc0I7SUFFdEIsTUFBTSxPQUFPLEdBQ1gsS0FHRCxDQUFDLGlCQUFpQixDQUFDO0lBQ3BCLE9BQU8sRUFBRSxDQUFDLEdBQUcsRUFBRSxZQUFZLENBQUMsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBWOC1vbmx5IChOb2RlLCBCdW4sIENocm9tZSwgRGVubykuIFJld3JpdGVzIGBlcnIuc3RhY2tgIHNvIHRoZSB0b3AgZnJhbWUgaXNcbiAqIHRoZSBjYWxsZXIgb2YgYHN0YWNrU3RhcnRGbmAgaW5zdGVhZCBvZiB0aGUgZnJhbWV3b3JrIGZ1bmN0aW9uIHRoYXQgdGhyZXcuXG4gKiBXaXRob3V0IHRoaXMsIHRlcm1pbmFsIG92ZXJsYXlzIChOZXh0LmpzLCBUdXJib3BhY2ssIFZTIENvZGUpIHJlbmRlciB0aGVcbiAqIGNvZGUgZnJhbWUgYXQgb3VyIGB0aHJvd2Agc2l0ZSBpbnNpZGUgYEB3b3JrZmxvdy9jb3JlYCwgd2hpY2ggaXMgdXNlbGVzc1xuICogdG8gdGhlIHVzZXIuXG4gKlxuICogTm8tb3Agb24gZW5naW5lcyB0aGF0IGRvbid0IGV4cG9zZSBgRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2VgIOKAlCB0aGUgc3RhY2tcbiAqIGRlZ3JhZGVzIGdyYWNlZnVsbHkgdG8gdGhlIGRlZmF1bHQgYmVoYXZpb3IuXG4gKlxuICogS2VwdCBpbiBpdHMgb3duIHRpbnkgbW9kdWxlIHNvIGNhbGxlcnMgdGhhdCBjYW4ndCBwYXJ0aWNpcGF0ZSBpbiB0aGVcbiAqIGBjb250ZXh0LWVycm9ycy50c2Ag4oaUIGB3b3JrZmxvdy9nZXQtd29ya2Zsb3ctbWV0YWRhdGEudHNgIGltcG9ydCBjeWNsZSBjYW5cbiAqIHN0aWxsIHB1bGwgaW4gdGhlIGhlbHBlciB3aXRob3V0IHB1bGxpbmcgaW4gdGhlIGZ1bGwgZXJyb3IgY2xhc3Nlcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlZGlyZWN0U3RhY2tUb0NhbGxlcihcbiAgZXJyOiBFcnJvcixcbiAgLy8gYmlvbWUtaWdub3JlIGxpbnQvY29tcGxleGl0eS9ub0Jhbm5lZFR5cGVzOiBzaWduYXR1cmUgbWF0Y2hlcyBFcnJvci5jYXB0dXJlU3RhY2tUcmFjZVxuICBzdGFja1N0YXJ0Rm46IEZ1bmN0aW9uXG4pOiB2b2lkIHtcbiAgY29uc3QgY2FwdHVyZSA9IChcbiAgICBFcnJvciBhcyB1bmtub3duIGFzIHtcbiAgICAgIGNhcHR1cmVTdGFja1RyYWNlPzogKHRhcmdldDogb2JqZWN0LCBmbjogRnVuY3Rpb24pID0+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.
+ *
+ * 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.
+ *
+ * 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,35 @@
-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
+ * `vm` realm: the VM-context `WorkflowRuntimeError` and the host-context
+ * one are distinct classes, so `instanceof` returns `false` for any error
+ * 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,EACL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAK3D"}
+{"version":3,"file":"classify-error.d.ts","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAMjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAsC1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAe5E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAW3D;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CA0B3D"}

package/dist/classify-error.js

@@ -1,17 +1,114 @@
-import { RUN_ERROR_CODES, WorkflowRuntimeError, } from '@workflow/errors';
+import { CorruptedEventLogError, ReplayDivergenceError, RUN_ERROR_CODES, RuntimeDecryptionError, StepNotRegisteredError, ThrottleError, WorkflowNotRegisteredError, WorkflowRuntimeError, WorkflowWorldError, } from '@workflow/errors';
+const WORLD_CONTRACT_ERROR_CODES = new Set([
+    'PARSE_ERROR',
+    'SCHEMA_VALIDATION',
+    RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
+]);
+/**
+ * `WorkflowWorldError.code` values that mark a transient transport failure
+ * (set by world-vercel's HTTP client): `TRANSPORT` covers an exhausted
+ * RetryAgent (`UND_ERR_REQ_RETRY` — e.g. the firewall in front of
+ * workflow-server shedding load with 429/503), a dropped socket, or a
+ * connect/DNS failure; `TIMEOUT` covers a request that exceeded the client
+ * timeout. Both are infrastructure failures a fresh invocation can recover
+ * from. Kept distinct from `WORLD_CONTRACT_ERROR_CODES` so a transport blip is
+ * never misclassified as the server returning a malformed response.
+ */
+const RETRYABLE_WORLD_ERROR_CODES = new Set(['TRANSPORT', 'TIMEOUT']);
+/**
+ * Set of error names that should classify as generic `RUNTIME_ERROR`. Each
+ * `*.is()` static does a name-based duck check, so subclassing alone is
+ * not enough — we have to enumerate every concrete subclass we want to
+ * recognize. Keep in sync with the `WorkflowRuntimeError` class hierarchy
+ * in `@workflow/errors`.
+ */
+const RUNTIME_ERROR_CHECKS = [
+    WorkflowRuntimeError.is,
+    StepNotRegisteredError.is,
+    WorkflowNotRegisteredError.is,
+    // SDK-level encryption failures (most notably AES-GCM auth-tag
+    // mismatches surfacing as a native `OperationError` from
+    // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at
+    // the encryption module boundary.
+    RuntimeDecryptionError.is,
+];
 /**
  * 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
+ * `vm` realm: the VM-context `WorkflowRuntimeError` and the host-context
+ * one are distinct classes, so `instanceof` returns `false` for any error
+ * thrown inside the workflow VM and we'd misclassify genuine runtime
+ * errors as user errors.
+ */
+export function isWorldContractError(err) {
+    if (!WorkflowWorldError.is(err) || err.status !== undefined) {
+        return false;
+    }
+    const cause = 'cause' in err ? err.cause : undefined;
+    return ((err.code !== undefined && WORLD_CONTRACT_ERROR_CODES.has(err.code)) ||
+        err.message.startsWith('Failed to parse response body for ') ||
+        err.message.startsWith('Schema validation failed for ') ||
+        (typeof cause === 'object' &&
+            cause !== null &&
+            'name' in cause &&
+            cause.name === 'ZodError'));
+}
+/**
+ * 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 function isRetryableWorldError(err) {
+    if (ThrottleError.is(err)) {
+        return true;
+    }
+    if (!WorkflowWorldError.is(err)) {
+        return false;
+    }
+    if (err.status !== undefined && err.status >= 500) {
+        return true;
+    }
+    return err.code !== undefined && RETRYABLE_WORLD_ERROR_CODES.has(err.code);
+}
 export function classifyRunError(err) {
-    if (err instanceof WorkflowRuntimeError) {
-        return RUN_ERROR_CODES.RUNTIME_ERROR;
+    if (ReplayDivergenceError.is(err)) {
+        return RUN_ERROR_CODES.REPLAY_DIVERGENCE;
+    }
+    if (CorruptedEventLogError.is(err)) {
+        return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;
+    }
+    // World-layer faults — both a malformed response (contract violation) and a
+    // transient infrastructure failure (throttle / 5xx / transport / timeout,
+    // e.g. a firewall challenge) — are the backend's fault, not the user's.
+    // Bucket them under WORLD_CONTRACT_ERROR rather than USER_ERROR so dashboards
+    // attribute an outage correctly. Note the retryable variants are normally
+    // redelivered via the queue (see `isRetryableWorldError`) and only reach this
+    // terminal classification if the run ultimately gives up.
+    if (isWorldContractError(err) || isRetryableWorldError(err)) {
+        return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;
+    }
+    for (const isMatch of RUNTIME_ERROR_CHECKS) {
+        if (isMatch(err)) {
+            return RUN_ERROR_CODES.RUNTIME_ERROR;
+        }
     }
     return RUN_ERROR_CODES.USER_ERROR;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3NpZnktZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY2xhc3NpZnktZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUVMLGVBQWUsRUFDZixvQkFBb0IsR0FDckIsTUFBTSxrQkFBa0IsQ0FBQztBQUUxQjs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxHQUFZO0lBQzNDLElBQUksR0FBRyxZQUFZLG9CQUFvQixFQUFFLENBQUM7UUFDeEMsT0FBTyxlQUFlLENBQUMsYUFBYSxDQUFDO0lBQ3ZDLENBQUM7SUFDRCxPQUFPLGVBQWUsQ0FBQyxVQUFVLENBQUM7QUFDcEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIHR5cGUgUnVuRXJyb3JDb2RlLFxuICBSVU5fRVJST1JfQ09ERVMsXG4gIFdvcmtmbG93UnVudGltZUVycm9yLFxufSBmcm9tICdAd29ya2Zsb3cvZXJyb3JzJztcblxuLyoqXG4gKiBDbGFzc2lmeSBhbiBlcnJvciB0aGF0IGNhdXNlZCBhIHdvcmtmbG93IHJ1biB0byBmYWlsLlxuICpcbiAqIEFmdGVyIHRoZSBzdHJ1Y3R1cmFsIHNlcGFyYXRpb24gb2YgaW5mcmFzdHJ1Y3R1cmUgdnMgdXNlciBjb2RlIGVycm9yXG4gKiBoYW5kbGluZywgdGhlIG9ubHkgZXJyb3JzIHRoYXQgcmVhY2ggdGhlIGBydW5fZmFpbGVkYCB0cnkvY2F0Y2ggYXJlOlxuICogLSBVc2VyIGNvZGUgZXJyb3JzICh0aHJvd3MgZnJvbSB3b3JrZmxvdyBmdW5jdGlvbnMsIHByb3BhZ2F0ZWQgc3RlcCBmYWlsdXJlcylcbiAqIC0gV29ya2Zsb3dSdW50aW1lRXJyb3IgYW5kIHN1YmNsYXNzZXMgKGNvcnJ1cHRlZCBldmVudCBsb2csIG1pc3NpbmdcbiAqICAgdGltZXN0YW1wcywgd29ya2Zsb3cvc3RlcCBub3QgcmVnaXN0ZXJlZCwgZXRjLilcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNsYXNzaWZ5UnVuRXJyb3IoZXJyOiB1bmtub3duKTogUnVuRXJyb3JDb2RlIHtcbiAgaWYgKGVyciBpbnN0YW5jZW9mIFdvcmtmbG93UnVudGltZUVycm9yKSB7XG4gICAgcmV0dXJuIFJVTl9FUlJPUl9DT0RFUy5SVU5USU1FX0VSUk9SO1xuICB9XG4gIHJldHVybiBSVU5fRVJST1JfQ09ERVMuVVNFUl9FUlJPUjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classify-error.js","sourceRoot":"","sources":["../src/classify-error.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EAEf,sBAAsB,EACtB,sBAAsB,EACtB,aAAa,EACb,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,0BAA0B,GAAG,IAAI,GAAG,CAAC;IACzC,aAAa;IACb,mBAAmB;IACnB,eAAe,CAAC,oBAAoB;CACrC,CAAC,CAAC;AAEH;;;;;;;;;GASG;AACH,MAAM,2BAA2B,GAAG,IAAI,GAAG,CAAC,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,oBAAoB,GAAG;IAC3B,oBAAoB,CAAC,EAAE;IACvB,sBAAsB,CAAC,EAAE;IACzB,0BAA0B,CAAC,EAAE;IAC7B,+DAA+D;IAC/D,yDAAyD;IACzD,oEAAoE;IACpE,kCAAkC;IAClC,sBAAsB,CAAC,EAAE;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAY;IAC/C,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC5D,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACrD,OAAO,CACL,CAAC,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,0BAA0B,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpE,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,oCAAoC,CAAC;QAC5D,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,+BAA+B,CAAC;QACvD,CAAC,OAAO,KAAK,KAAK,QAAQ;YACxB,KAAK,KAAK,IAAI;YACd,MAAM,IAAI,KAAK;YACf,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC,CAC7B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY;IAChD,IAAI,aAAa,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QAChC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,2BAA2B,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC7E,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,GAAY;IAC3C,IAAI,qBAAqB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QAClC,OAAO,eAAe,CAAC,iBAAiB,CAAC;IAC3C,CAAC;IAED,IAAI,sBAAsB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,OAAO,eAAe,CAAC,mBAAmB,CAAC;IAC7C,CAAC;IAED,4EAA4E;IAC5E,0EAA0E;IAC1E,wEAAwE;IACxE,8EAA8E;IAC9E,0EAA0E;IAC1E,8EAA8E;IAC9E,0DAA0D;IAC1D,IAAI,oBAAoB,CAAC,GAAG,CAAC,IAAI,qBAAqB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC5D,OAAO,eAAe,CAAC,oBAAoB,CAAC;IAC9C,CAAC;IAED,KAAK,MAAM,OAAO,IAAI,oBAAoB,EAAE,CAAC;QAC3C,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACjB,OAAO,eAAe,CAAC,aAAa,CAAC;QACvC,CAAC;IACH,CAAC;IACD,OAAO,eAAe,CAAC,UAAU,CAAC;AACpC,CAAC","sourcesContent":["import {\n  CorruptedEventLogError,\n  ReplayDivergenceError,\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  RuntimeDecryptionError,\n  StepNotRegisteredError,\n  ThrottleError,\n  WorkflowNotRegisteredError,\n  WorkflowRuntimeError,\n  WorkflowWorldError,\n} from '@workflow/errors';\n\nconst WORLD_CONTRACT_ERROR_CODES = new Set([\n  'PARSE_ERROR',\n  'SCHEMA_VALIDATION',\n  RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,\n]);\n\n/**\n * `WorkflowWorldError.code` values that mark a transient transport failure\n * (set by world-vercel's HTTP client): `TRANSPORT` covers an exhausted\n * RetryAgent (`UND_ERR_REQ_RETRY` — e.g. the firewall in front of\n * workflow-server shedding load with 429/503), a dropped socket, or a\n * connect/DNS failure; `TIMEOUT` covers a request that exceeded the client\n * timeout. Both are infrastructure failures a fresh invocation can recover\n * from. Kept distinct from `WORLD_CONTRACT_ERROR_CODES` so a transport blip is\n * never misclassified as the server returning a malformed response.\n */\nconst RETRYABLE_WORLD_ERROR_CODES = new Set(['TRANSPORT', 'TIMEOUT']);\n\n/**\n * Set of error names that should classify as generic `RUNTIME_ERROR`. Each\n * `*.is()` static does a name-based duck check, so subclassing alone is\n * not enough — we have to enumerate every concrete subclass we want to\n * recognize. Keep in sync with the `WorkflowRuntimeError` class hierarchy\n * in `@workflow/errors`.\n */\nconst RUNTIME_ERROR_CHECKS = [\n  WorkflowRuntimeError.is,\n  StepNotRegisteredError.is,\n  WorkflowNotRegisteredError.is,\n  // SDK-level encryption failures (most notably AES-GCM auth-tag\n  // mismatches surfacing as a native `OperationError` from\n  // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at\n  // the encryption module boundary.\n  RuntimeDecryptionError.is,\n];\n\n/**\n * Classify an error that caused a workflow run to fail.\n *\n * After the structural separation of infrastructure vs user code error\n * handling, the only errors that reach the `run_failed` try/catch are:\n * - User code errors (throws from workflow functions, propagated step failures)\n * - WorkflowRuntimeError and subclasses (missing timestamps, workflow/step\n *   not registered, corrupted event log, etc.)\n *\n * Uses each subclass's `.is()` static (a name-based duck check) instead of\n * a single `instanceof` check because workflows execute in a separate\n * `vm` realm: the VM-context `WorkflowRuntimeError` and the host-context\n * one are distinct classes, so `instanceof` returns `false` for any error\n * thrown inside the workflow VM and we'd misclassify genuine runtime\n * errors as user errors.\n */\nexport function isWorldContractError(err: unknown): err is WorkflowWorldError {\n  if (!WorkflowWorldError.is(err) || err.status !== undefined) {\n    return false;\n  }\n\n  const cause = 'cause' in err ? err.cause : undefined;\n  return (\n    (err.code !== undefined && WORLD_CONTRACT_ERROR_CODES.has(err.code)) ||\n    err.message.startsWith('Failed to parse response body for ') ||\n    err.message.startsWith('Schema validation failed for ') ||\n    (typeof cause === 'object' &&\n      cause !== null &&\n      'name' in cause &&\n      cause.name === 'ZodError')\n  );\n}\n\n/**\n * True when an error from a world (workflow-server) call is a transient\n * infrastructure failure that should be retried by redelivering the queue\n * message, rather than failing the run. A fresh invocation will likely\n * succeed once the backend (or the firewall in front of it) recovers.\n *\n * - `ThrottleError` (429): rate limited / load shed\n * - `WorkflowWorldError` with `status >= 500`: server-side error\n * - `WorkflowWorldError` with a retryable transport `code` (`TRANSPORT` /\n *   `TIMEOUT`): the request never produced a usable response\n *\n * Uses `.is()` name-based duck checks (not `instanceof`) for the same\n * cross-`vm`-realm reason described on `classifyRunError`.\n */\nexport function isRetryableWorldError(err: unknown): boolean {\n  if (ThrottleError.is(err)) {\n    return true;\n  }\n  if (!WorkflowWorldError.is(err)) {\n    return false;\n  }\n  if (err.status !== undefined && err.status >= 500) {\n    return true;\n  }\n  return err.code !== undefined && RETRYABLE_WORLD_ERROR_CODES.has(err.code);\n}\n\nexport function classifyRunError(err: unknown): RunErrorCode {\n  if (ReplayDivergenceError.is(err)) {\n    return RUN_ERROR_CODES.REPLAY_DIVERGENCE;\n  }\n\n  if (CorruptedEventLogError.is(err)) {\n    return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;\n  }\n\n  // World-layer faults — both a malformed response (contract violation) and a\n  // transient infrastructure failure (throttle / 5xx / transport / timeout,\n  // e.g. a firewall challenge) — are the backend's fault, not the user's.\n  // Bucket them under WORLD_CONTRACT_ERROR rather than USER_ERROR so dashboards\n  // attribute an outage correctly. Note the retryable variants are normally\n  // redelivered via the queue (see `isRetryableWorldError`) and only reach this\n  // terminal classification if the run ultimately gives up.\n  if (isWorldContractError(err) || isRetryableWorldError(err)) {\n    return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;\n  }\n\n  for (const isMatch of RUNTIME_ERROR_CHECKS) {\n    if (isMatch(err)) {\n      return RUN_ERROR_CODES.RUNTIME_ERROR;\n    }\n  }\n  return RUN_ERROR_CODES.USER_ERROR;\n}\n"]}

package/dist/context-errors.d.ts

@@ -0,0 +1,27 @@
+import { ContextViolationError, type DocsUrl, NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError } from './context-violation-error.js';
+export { ContextViolationError, NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError, };
+/**
+ * Thrown when an API that MUST NOT run inside a workflow function is called
+ * from one (e.g. `resumeHook()`, which would cause determinism issues).
+ * The message names the specific workflow that made the offending call.
+ */
+export declare class UnavailableInWorkflowContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+/**
+ * Throw a {@link NotInWorkflowContextError} whose stack trace points at the
+ * user code that called `stackStartFn`, not at our framework internals.
+ *
+ * Prefer this over `throw new NotInWorkflowContextError(...)` so tooling
+ * (Next.js error overlay, VS Code terminal linkifier, Sentry, etc.) shows
+ * the user's call site as the relevant frame.
+ */
+export declare function throwNotInWorkflowContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwNotInStepContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwNotInWorkflowOrStepContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwUnavailableInWorkflowContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+//# sourceMappingURL=context-errors.d.ts.map

package/dist/context-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-errors.d.ts","sourceRoot":"","sources":["../src/context-errors.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EAErB,KAAK,OAAO,EACZ,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,EAChC,MAAM,8BAA8B,CAAC;AAUtC,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,GAChC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,iCAAkC,SAAQ,qBAAqB;IAC1E,IAAI,SAAuC;gBAE/B,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CAgDnD;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP;AAED,6CAA6C;AAC7C,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP;AAED,6CAA6C;AAC7C,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP;AAED,6CAA6C;AAC7C,wBAAgB,iCAAiC,CAC/C,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAEhB,YAAY,EAAE,QAAQ,GACrB,KAAK,CAIP"}