@workflow/core 5.0.0-beta.6 → 5.0.0-beta.7

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,6 @@ 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;
 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,EAGL,KAAK,YAAY,EAIjB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAqB1B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAe5E;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAe3D"}

package/dist/classify-error.js

@@ -1,6 +1,11 @@
-import { RUN_ERROR_CODES, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRuntimeError, } from '@workflow/errors';
+import { CorruptedEventLogError, RUN_ERROR_CODES, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRuntimeError, WorkflowWorldError, } from '@workflow/errors';
+const WORLD_CONTRACT_ERROR_CODES = new Set([
+    'PARSE_ERROR',
+    'SCHEMA_VALIDATION',
+    RUN_ERROR_CODES.WORLD_CONTRACT_ERROR,
+]);
 /**
- * Set of error names that should classify as `RUNTIME_ERROR`. Each
+ * 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
@@ -17,8 +22,8 @@ const RUNTIME_ERROR_CHECKS = [
  * 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
@@ -27,7 +32,26 @@ const RUNTIME_ERROR_CHECKS = [
  * 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'));
+}
 export function classifyRunError(err) {
+    if (CorruptedEventLogError.is(err)) {
+        return RUN_ERROR_CODES.CORRUPTED_EVENT_LOG;
+    }
+    if (isWorldContractError(err)) {
+        return RUN_ERROR_CODES.WORLD_CONTRACT_ERROR;
+    }
     for (const isMatch of RUNTIME_ERROR_CHECKS) {
         if (isMatch(err)) {
             return RUN_ERROR_CODES.RUNTIME_ERROR;
@@ -35,4 +59,4 @@ export function classifyRunError(err) {
     }
     return RUN_ERROR_CODES.USER_ERROR;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"describe-error.d.ts","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAS1B;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAuCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,gBAAgB,CAuBlB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,YAAY,GACvB,gBAAgB,CA4ClB"}
+{"version":3,"file":"describe-error.d.ts","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EAGlB,MAAM,kBAAkB,CAAC;AAS1B;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA2CD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,gBAAgB,CA+ClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,CAAC,EAAE,YAAY,GACvB,gBAAgB,CAoElB"}

package/dist/describe-error.js

@@ -1,4 +1,4 @@
-import { RUN_ERROR_CODES, SerializationError, WorkflowRuntimeError, } from '@workflow/errors';
+import { CorruptedEventLogError, RUN_ERROR_CODES, SerializationError, WorkflowRuntimeError, } from '@workflow/errors';
 import { classifyRunError } from './classify-error.js';
 import { NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError, UnavailableInWorkflowContextError, } from './context-errors.js';
 const CONTEXT_ERROR_NAMES = new Set([
@@ -16,8 +16,10 @@ function isContextViolationError(err) {
 const SERIALIZATION_ERROR_HINT = 'A value passed across a workflow/step boundary could not be serialized. See the error message for the offending path and the Learn More link for details.';
 const CONTEXT_ERROR_HINT = 'A workflow-only or step-only API was called from the wrong context. The error message includes the exact API and how to move the call.';
 const RUNTIME_ERROR_HINT = 'This is an internal workflow SDK error, not a bug in your code. If it keeps happening, please report it with the stack trace and the runId.';
-const REPLAY_TIMEOUT_HINT = 'The workflow replay took too long. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work between step boundaries.';
+const CORRUPTED_EVENT_LOG_HINT = 'The workflow event log contains orphaned or mismatched events and cannot be replayed. This is an internal workflow SDK error; please report it with the runId.';
+const REPLAY_TIMEOUT_HINT = 'The workflow replay between step boundaries took too long. This bounds workflow-VM and event-log replay time only — step bodies (`"use step"` functions) are excluded. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work in workflow code outside of step bodies. Override the default budget via the WORKFLOW_REPLAY_TIMEOUT_MS env var if needed.';
 const MAX_DELIVERIES_HINT = 'The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure — check the most recent stack traces for the underlying cause.';
+const WORLD_CONTRACT_HINT = 'The workflow backend returned data that violated the SDK contract. This is not retryable; please report it with the stack trace and runId.';
 function normalizeErrorCode(code) {
     // Values read back from persisted events are `string | undefined` — we
     // only trust codes that match a known entry in `RUN_ERROR_CODES`.
@@ -34,16 +36,22 @@ function normalizeErrorCode(code) {
  * thrown object.
  */
 export function describeRunError(signal) {
-    const errorCode = normalizeErrorCode(signal.errorCode);
     const name = signal.errorName;
+    const errorCode = name === 'CorruptedEventLogError'
+        ? RUN_ERROR_CODES.CORRUPTED_EVENT_LOG
+        : normalizeErrorCode(signal.errorCode);
     if (name === 'SerializationError') {
         return { attribution: 'user', errorCode, hint: SERIALIZATION_ERROR_HINT };
     }
     if (name && CONTEXT_ERROR_NAMES.has(name)) {
         return { attribution: 'user', errorCode, hint: CONTEXT_ERROR_HINT };
     }
-    if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {
-        return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };
+    if (name === 'CorruptedEventLogError') {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
     }
     if (errorCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {
         return { attribution: 'sdk', errorCode, hint: REPLAY_TIMEOUT_HINT };
@@ -51,6 +59,23 @@ export function describeRunError(signal) {
     if (errorCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {
         return { attribution: 'sdk', errorCode, hint: MAX_DELIVERIES_HINT };
     }
+    if (errorCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    if (errorCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: WORLD_CONTRACT_HINT,
+        };
+    }
+    if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {
+        return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };
+    }
     if (errorCode === RUN_ERROR_CODES.RUNTIME_ERROR) {
         return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };
     }
@@ -93,6 +118,13 @@ export function describeError(err, errorCode) {
             hint: CONTEXT_ERROR_HINT,
         };
     }
+    if (CorruptedEventLogError.is(err)) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
     if (err instanceof WorkflowRuntimeError) {
         return {
             attribution: 'sdk',
@@ -114,6 +146,20 @@ export function describeError(err, errorCode) {
             hint: MAX_DELIVERIES_HINT,
         };
     }
+    if (effectiveCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: WORLD_CONTRACT_HINT,
+        };
+    }
     return { attribution: 'user', errorCode: effectiveCode };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"describe-error.js","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  SerializationError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { classifyRunError } from './classify-error.js';\nimport {\n  NotInStepContextError,\n  NotInWorkflowContextError,\n  NotInWorkflowOrStepContextError,\n  UnavailableInWorkflowContextError,\n} from './context-errors.js';\n\n/**\n * Attribution of a workflow/step failure for presentation.\n *\n * - `user`: the error came from customer code (a step or workflow function\n *   threw, or a value they passed across a boundary wasn't serializable).\n * - `sdk`: the SDK produced the error itself — an internal invariant broke,\n *   or a runtime guard rejected the call. These should be rare; when they\n *   happen we want to frame the terminal output as \"this is us, not you.\"\n */\nexport type ErrorAttribution = 'user' | 'sdk';\n\nexport interface ErrorDescription {\n  attribution: ErrorAttribution;\n  errorCode: RunErrorCode;\n  /**\n   * Short, class-aware hint to help a user understand what the error means.\n   * Only set for well-known SDK error classes (SerializationError,\n   * WorkflowRuntimeError, context-violation errors); `undefined` for plain\n   * user errors, where the stack is already the most useful thing to show.\n   */\n  hint?: string;\n}\n\n/**\n * Error signal fields carried on persisted failure events (e.g.\n * `run_failed` / `step_failed`). The shape is intentionally loose:\n *\n * - `errorCode` is typed as `string` rather than `RunErrorCode` because\n *   the value comes from stored JSON/CBOR and may predate the current\n *   enum — callers should not narrow on it blindly. Values that don't\n *   match a known `RUN_ERROR_CODES` entry fall through to USER_ERROR.\n * - `errorName` is the thrown `Error#name`. It is not universally\n *   persisted today; callers that have access to it (either via an\n *   in-memory throw or a richer payload) can pass it in to sharpen\n *   the attribution and hint. When absent, `describeRunError` still\n *   returns a sensible attribution from `errorCode` alone.\n */\nexport interface PersistedErrorSignal {\n  errorCode?: string;\n  errorName?: string;\n}\n\nconst CONTEXT_ERROR_NAMES = new Set([\n  'NotInWorkflowContextError',\n  'NotInStepContextError',\n  'NotInWorkflowOrStepContextError',\n  'UnavailableInWorkflowContextError',\n]);\n\nfunction isContextViolationError(err: unknown): boolean {\n  return (\n    err instanceof NotInWorkflowContextError ||\n    err instanceof NotInStepContextError ||\n    err instanceof NotInWorkflowOrStepContextError ||\n    err instanceof UnavailableInWorkflowContextError\n  );\n}\n\nconst SERIALIZATION_ERROR_HINT =\n  'A value passed across a workflow/step boundary could not be serialized. See the error message for the offending path and the Learn More link for details.';\nconst CONTEXT_ERROR_HINT =\n  'A workflow-only or step-only API was called from the wrong context. The error message includes the exact API and how to move the call.';\nconst RUNTIME_ERROR_HINT =\n  'This is an internal workflow SDK error, not a bug in your code. If it keeps happening, please report it with the stack trace and the runId.';\nconst REPLAY_TIMEOUT_HINT =\n  'The workflow replay took too long. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work between step boundaries.';\nconst MAX_DELIVERIES_HINT =\n  'The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure — check the most recent stack traces for the underlying cause.';\n\nfunction normalizeErrorCode(code: string | undefined): RunErrorCode {\n  // Values read back from persisted events are `string | undefined` — we\n  // only trust codes that match a known entry in `RUN_ERROR_CODES`.\n  const known = Object.values(RUN_ERROR_CODES) as readonly string[];\n  if (code && known.includes(code)) {\n    return code as RunErrorCode;\n  }\n  return RUN_ERROR_CODES.USER_ERROR;\n}\n\n/**\n * Data-driven variant of {@link describeError} that works from persisted\n * event fields instead of a live `Error` instance. Intended for CLI/web\n * renderers that read failure events and no longer have the original\n * thrown object.\n */\nexport function describeRunError(\n  signal: PersistedErrorSignal\n): ErrorDescription {\n  const errorCode = normalizeErrorCode(signal.errorCode);\n  const name = signal.errorName;\n\n  if (name === 'SerializationError') {\n    return { attribution: 'user', errorCode, hint: SERIALIZATION_ERROR_HINT };\n  }\n  if (name && CONTEXT_ERROR_NAMES.has(name)) {\n    return { attribution: 'user', errorCode, hint: CONTEXT_ERROR_HINT };\n  }\n  if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return { attribution: 'sdk', errorCode, hint: REPLAY_TIMEOUT_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return { attribution: 'sdk', errorCode, hint: MAX_DELIVERIES_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.RUNTIME_ERROR) {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  return { attribution: 'user', errorCode };\n}\n\n/**\n * Describe an error for user-facing presentation. Purely informational —\n * does not change any persisted event data or error classification used by\n * the runtime.\n *\n * The attribution here is more nuanced than `classifyRunError`:\n *\n * - `SerializationError` is technically raised by the SDK, but it almost\n *   always points at something the caller did (passed a non-serializable\n *   value, didn't register a class). We attribute it to the user.\n * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise\n *   describe a user mistake.\n * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)\n *   indicates an internal SDK invariant broke — surface that as `sdk`.\n *\n * @param err The error value thrown by the workflow / step.\n * @param errorCode Optional precomputed error code. Callers that already\n *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which\n *   `classifyRunError` can't derive from the error alone) should pass it so\n *   the attribution and hint reflect the actual failure category.\n */\nexport function describeError(\n  err: unknown,\n  errorCode?: RunErrorCode\n): ErrorDescription {\n  const effectiveCode = errorCode ?? classifyRunError(err);\n\n  if (SerializationError.is(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: SERIALIZATION_ERROR_HINT,\n    };\n  }\n\n  if (isContextViolationError(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: CONTEXT_ERROR_HINT,\n    };\n  }\n\n  if (err instanceof WorkflowRuntimeError) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: RUNTIME_ERROR_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: REPLAY_TIMEOUT_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: MAX_DELIVERIES_HINT,\n    };\n  }\n\n  return { attribution: 'user', errorCode: effectiveCode };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"describe-error.js","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CorruptedEventLogError,\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  SerializationError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { classifyRunError } from './classify-error.js';\nimport {\n  NotInStepContextError,\n  NotInWorkflowContextError,\n  NotInWorkflowOrStepContextError,\n  UnavailableInWorkflowContextError,\n} from './context-errors.js';\n\n/**\n * Attribution of a workflow/step failure for presentation.\n *\n * - `user`: the error came from customer code (a step or workflow function\n *   threw, or a value they passed across a boundary wasn't serializable).\n * - `sdk`: the SDK produced the error itself — an internal invariant broke,\n *   or a runtime guard rejected the call. These should be rare; when they\n *   happen we want to frame the terminal output as \"this is us, not you.\"\n */\nexport type ErrorAttribution = 'user' | 'sdk';\n\nexport interface ErrorDescription {\n  attribution: ErrorAttribution;\n  errorCode: RunErrorCode;\n  /**\n   * Short, class-aware hint to help a user understand what the error means.\n   * Only set for well-known SDK error classes (SerializationError,\n   * WorkflowRuntimeError, context-violation errors); `undefined` for plain\n   * user errors, where the stack is already the most useful thing to show.\n   */\n  hint?: string;\n}\n\n/**\n * Error signal fields carried on persisted failure events (e.g.\n * `run_failed` / `step_failed`). The shape is intentionally loose:\n *\n * - `errorCode` is typed as `string` rather than `RunErrorCode` because\n *   the value comes from stored JSON/CBOR and may predate the current\n *   enum — callers should not narrow on it blindly. Values that don't\n *   match a known `RUN_ERROR_CODES` entry fall through to USER_ERROR.\n * - `errorName` is the thrown `Error#name`. It is not universally\n *   persisted today; callers that have access to it (either via an\n *   in-memory throw or a richer payload) can pass it in to sharpen\n *   the attribution and hint. When absent, `describeRunError` still\n *   returns a sensible attribution from `errorCode` alone.\n */\nexport interface PersistedErrorSignal {\n  errorCode?: string;\n  errorName?: string;\n}\n\nconst CONTEXT_ERROR_NAMES = new Set([\n  'NotInWorkflowContextError',\n  'NotInStepContextError',\n  'NotInWorkflowOrStepContextError',\n  'UnavailableInWorkflowContextError',\n]);\n\nfunction isContextViolationError(err: unknown): boolean {\n  return (\n    err instanceof NotInWorkflowContextError ||\n    err instanceof NotInStepContextError ||\n    err instanceof NotInWorkflowOrStepContextError ||\n    err instanceof UnavailableInWorkflowContextError\n  );\n}\n\nconst SERIALIZATION_ERROR_HINT =\n  'A value passed across a workflow/step boundary could not be serialized. See the error message for the offending path and the Learn More link for details.';\nconst CONTEXT_ERROR_HINT =\n  'A workflow-only or step-only API was called from the wrong context. The error message includes the exact API and how to move the call.';\nconst RUNTIME_ERROR_HINT =\n  'This is an internal workflow SDK error, not a bug in your code. If it keeps happening, please report it with the stack trace and the runId.';\nconst CORRUPTED_EVENT_LOG_HINT =\n  'The workflow event log contains orphaned or mismatched events and cannot be replayed. This is an internal workflow SDK error; please report it with the runId.';\nconst REPLAY_TIMEOUT_HINT =\n  'The workflow replay between step boundaries took too long. This bounds workflow-VM and event-log replay time only — step bodies (`\"use step\"` functions) are excluded. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work in workflow code outside of step bodies. Override the default budget via the WORKFLOW_REPLAY_TIMEOUT_MS env var if needed.';\nconst MAX_DELIVERIES_HINT =\n  'The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure — check the most recent stack traces for the underlying cause.';\nconst WORLD_CONTRACT_HINT =\n  'The workflow backend returned data that violated the SDK contract. This is not retryable; please report it with the stack trace and runId.';\n\nfunction normalizeErrorCode(code: string | undefined): RunErrorCode {\n  // Values read back from persisted events are `string | undefined` — we\n  // only trust codes that match a known entry in `RUN_ERROR_CODES`.\n  const known = Object.values(RUN_ERROR_CODES) as readonly string[];\n  if (code && known.includes(code)) {\n    return code as RunErrorCode;\n  }\n  return RUN_ERROR_CODES.USER_ERROR;\n}\n\n/**\n * Data-driven variant of {@link describeError} that works from persisted\n * event fields instead of a live `Error` instance. Intended for CLI/web\n * renderers that read failure events and no longer have the original\n * thrown object.\n */\nexport function describeRunError(\n  signal: PersistedErrorSignal\n): ErrorDescription {\n  const name = signal.errorName;\n  const errorCode =\n    name === 'CorruptedEventLogError'\n      ? RUN_ERROR_CODES.CORRUPTED_EVENT_LOG\n      : normalizeErrorCode(signal.errorCode);\n\n  if (name === 'SerializationError') {\n    return { attribution: 'user', errorCode, hint: SERIALIZATION_ERROR_HINT };\n  }\n  if (name && CONTEXT_ERROR_NAMES.has(name)) {\n    return { attribution: 'user', errorCode, hint: CONTEXT_ERROR_HINT };\n  }\n  if (name === 'CorruptedEventLogError') {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n  if (errorCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return { attribution: 'sdk', errorCode, hint: REPLAY_TIMEOUT_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return { attribution: 'sdk', errorCode, hint: MAX_DELIVERIES_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n  if (errorCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: WORLD_CONTRACT_HINT,\n    };\n  }\n  if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.RUNTIME_ERROR) {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  return { attribution: 'user', errorCode };\n}\n\n/**\n * Describe an error for user-facing presentation. Purely informational —\n * does not change any persisted event data or error classification used by\n * the runtime.\n *\n * The attribution here is more nuanced than `classifyRunError`:\n *\n * - `SerializationError` is technically raised by the SDK, but it almost\n *   always points at something the caller did (passed a non-serializable\n *   value, didn't register a class). We attribute it to the user.\n * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise\n *   describe a user mistake.\n * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)\n *   indicates an internal SDK invariant broke — surface that as `sdk`.\n *\n * @param err The error value thrown by the workflow / step.\n * @param errorCode Optional precomputed error code. Callers that already\n *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which\n *   `classifyRunError` can't derive from the error alone) should pass it so\n *   the attribution and hint reflect the actual failure category.\n */\nexport function describeError(\n  err: unknown,\n  errorCode?: RunErrorCode\n): ErrorDescription {\n  const effectiveCode = errorCode ?? classifyRunError(err);\n\n  if (SerializationError.is(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: SERIALIZATION_ERROR_HINT,\n    };\n  }\n\n  if (isContextViolationError(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: CONTEXT_ERROR_HINT,\n    };\n  }\n\n  if (CorruptedEventLogError.is(err)) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n\n  if (err instanceof WorkflowRuntimeError) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: RUNTIME_ERROR_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: REPLAY_TIMEOUT_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: MAX_DELIVERIES_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: WORLD_CONTRACT_HINT,\n    };\n  }\n\n  return { attribution: 'user', errorCode: effectiveCode };\n}\n"]}

package/dist/encryption.d.ts

@@ -22,10 +22,16 @@ export type CryptoKey = import('node:crypto').webcrypto.CryptoKey;
  * Callers should call this once per run (after `getEncryptionKeyForRun()`)
  * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.
  *
+ * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios
+ * where the caller should not be able to perform the inverse operation
+ * with the key — for example a child workflow writing into a parent
+ * run's forwarded WritableStream only needs to encrypt, never decrypt.
+ *
  * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)
+ * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.
  * @returns CryptoKey ready for AES-GCM operations
  */
-export declare function importKey(raw: Uint8Array): Promise<import("crypto").webcrypto.CryptoKey>;
+export declare function importKey(raw: Uint8Array, usages?: ReadonlyArray<'encrypt' | 'decrypt'>): Promise<import("crypto").webcrypto.CryptoKey>;
 /**
  * Encrypt data using AES-256-GCM.
  *

package/dist/encryption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAMlE;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,UAAU,iDAU9C;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAWrB;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAerB"}
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAMlE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,aAAa,CAAC,SAAS,GAAG,SAAS,CAA0B,iDAiBtE;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAWrB;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAerB"}

package/dist/encryption.js

@@ -8,17 +8,24 @@ const KEY_LENGTH = 32; // bytes (AES-256)
  * Callers should call this once per run (after `getEncryptionKeyForRun()`)
  * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.
  *
+ * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios
+ * where the caller should not be able to perform the inverse operation
+ * with the key — for example a child workflow writing into a parent
+ * run's forwarded WritableStream only needs to encrypt, never decrypt.
+ *
  * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)
+ * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.
  * @returns CryptoKey ready for AES-GCM operations
  */
-export async function importKey(raw) {
+export async function importKey(raw, usages = ['encrypt', 'decrypt']) {
     if (raw.byteLength !== KEY_LENGTH) {
         throw new WorkflowRuntimeError(`Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`);
     }
-    return globalThis.crypto.subtle.importKey('raw', raw, 'AES-GCM', false, [
-        'encrypt',
-        'decrypt',
-    ]);
+    return globalThis.crypto.subtle.importKey('raw', raw, 'AES-GCM', false, 
+    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.
+    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches
+    // a strict subset of `KeyUsage[]`, so this cast is sound.
+    usages);
 }
 /**
  * Encrypt data using AES-256-GCM.
@@ -52,4 +59,4 @@ export async function decrypt(key, data) {
     const plaintext = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, ciphertext);
     return new Uint8Array(plaintext);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAyBxD,MAAM,YAAY,GAAG,EAAE,CAAC;AACxB,MAAM,UAAU,GAAG,GAAG,CAAC,CAAC,OAAO;AAC/B,MAAM,UAAU,GAAG,EAAE,CAAC,CAAC,kBAAkB;AAEzC;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,GAAe,EACf,SAA+C,CAAC,SAAS,EAAE,SAAS,CAAC;IAErE,IAAI,GAAG,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAClC,MAAM,IAAI,oBAAoB,CAC5B,kCAAkC,UAAU,eAAe,GAAG,CAAC,UAAU,EAAE,CAC5E,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CACvC,KAAK,EACL,GAAG,EACH,SAAS,EACT,KAAK;IACL,mEAAmE;IACnE,oEAAoE;IACpE,0DAA0D;IAC1D,MAAmC,CACpC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,GAAc,EACd,IAAgB;IAEhB,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC;IAC9E,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CACvD,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,EACrD,GAAG,EACH,IAAI,CACL,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,YAAY,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;IACpE,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACrB,MAAM,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,CAAC;IACrD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,GAAc,EACd,IAAgB;IAEhB,MAAM,SAAS,GAAG,YAAY,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC,mBAAmB;IACpE,IAAI,IAAI,CAAC,UAAU,GAAG,SAAS,EAAE,CAAC;QAChC,MAAM,IAAI,oBAAoB,CAC5B,+CAA+C,SAAS,eAAe,IAAI,CAAC,UAAU,EAAE,CACzF,CAAC;IACJ,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;IAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC/C,MAAM,SAAS,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CACtD,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,EACrD,GAAG,EACH,UAAU,CACX,CAAC;IACF,OAAO,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\n\n/**\n * Browser-compatible AES-256-GCM encryption module.\n *\n * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in\n * both modern browsers and Node.js 20+. This module is intentionally\n * free of Node.js-specific imports so it can be bundled for the browser.\n *\n * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte\n * AES-256 key. Callers should use `importKey()` once to convert it to a\n * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all\n * operations within the same run. This avoids repeated `importKey()`\n * calls on every encrypt/decrypt invocation.\n *\n * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`\n * The `encr` format prefix is NOT part of this module — it's added/stripped\n * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.\n */\n\n// CryptoKey is a global type in browsers and Node.js 20+, but TypeScript's\n// `es2022` lib doesn't include it. Re-export it from the node:crypto types\n// so consumers can reference it without adding `dom` lib.\nexport type CryptoKey = import('node:crypto').webcrypto.CryptoKey;\n\nconst NONCE_LENGTH = 12;\nconst TAG_LENGTH = 128; // bits\nconst KEY_LENGTH = 32; // bytes (AES-256)\n\n/**\n * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.\n *\n * Callers should call this once per run (after `getEncryptionKeyForRun()`)\n * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.\n *\n * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios\n * where the caller should not be able to perform the inverse operation\n * with the key — for example a child workflow writing into a parent\n * run's forwarded WritableStream only needs to encrypt, never decrypt.\n *\n * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)\n * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.\n * @returns CryptoKey ready for AES-GCM operations\n */\nexport async function importKey(\n  raw: Uint8Array,\n  usages: ReadonlyArray<'encrypt' | 'decrypt'> = ['encrypt', 'decrypt']\n) {\n  if (raw.byteLength !== KEY_LENGTH) {\n    throw new WorkflowRuntimeError(\n      `Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`\n    );\n  }\n  return globalThis.crypto.subtle.importKey(\n    'raw',\n    raw,\n    'AES-GCM',\n    false,\n    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.\n    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches\n    // a strict subset of `KeyUsage[]`, so this cast is sound.\n    usages as ('encrypt' | 'decrypt')[]\n  );\n}\n\n/**\n * Encrypt data using AES-256-GCM.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - Plaintext to encrypt\n * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n */\nexport async function encrypt(\n  key: CryptoKey,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));\n  const ciphertext = await globalThis.crypto.subtle.encrypt(\n    { name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH },\n    key,\n    data\n  );\n  const result = new Uint8Array(NONCE_LENGTH + ciphertext.byteLength);\n  result.set(nonce, 0);\n  result.set(new Uint8Array(ciphertext), NONCE_LENGTH);\n  return result;\n}\n\n/**\n * Decrypt data using AES-256-GCM.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n * @returns Decrypted plaintext\n */\nexport async function decrypt(\n  key: CryptoKey,\n  data: Uint8Array\n): Promise<Uint8Array> {\n  const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag\n  if (data.byteLength < minLength) {\n    throw new WorkflowRuntimeError(\n      `Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`\n    );\n  }\n  const nonce = data.subarray(0, NONCE_LENGTH);\n  const ciphertext = data.subarray(NONCE_LENGTH);\n  const plaintext = await globalThis.crypto.subtle.decrypt(\n    { name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH },\n    key,\n    ciphertext\n  );\n  return new Uint8Array(plaintext);\n}\n"]}

package/dist/runtime/constants.d.ts

@@ -1,4 +1,51 @@
 export declare const MAX_QUEUE_DELIVERIES = 48;
+/**
+ * Default maximum time allowed for the *replay* portion of a single workflow
+ * handler invocation (in ms). This budget only covers deterministic-replay
+ * and workflow-VM execution between step boundaries — inline step bodies
+ * (`"use step"` functions invoked via `executeStep`) do NOT count against
+ * it. Step bodies are bounded separately by the platform's function
+ * `maxDuration` (e.g. 800s on Vercel Pro Fluid) and `NO_INLINE_REPLAY_AFTER_MS`.
+ *
+ * If the non-step ("replay") time within a single invocation exceeds this
+ * budget, the handler exits so the queue can retry. After
+ * `REPLAY_TIMEOUT_MAX_RETRIES` exhausted attempts the run is failed with
+ * `RUN_ERROR_CODES.REPLAY_TIMEOUT`.
+ *
+ * Note that on Vercel Hobby (standard functions), the platform `maxDuration`
+ * is 60s — well below this budget, so the platform SIGTERM will fire first
+ * and the queue will re-deliver until the visibility window expires. With
+ * Fluid Compute on Hobby the per-function ceiling rises to 300s, still
+ * under the default budget.
+ *
+ * Override via the `WORKFLOW_REPLAY_TIMEOUT_MS` env var (clamped to
+ * `MIN_REPLAY_TIMEOUT_MS`..`MAX_REPLAY_TIMEOUT_MS`).
+ */
 export declare const REPLAY_TIMEOUT_MS = 240000;
+/** Lower bound for the replay-timeout env var override. */
+export declare const MIN_REPLAY_TIMEOUT_MS = 30000;
+/**
+ * Upper bound for the replay-timeout env var override. 780s leaves ≥20s of
+ * headroom under Vercel Pro Fluid's 800s function ceiling so the handler
+ * can write `run_failed` before SIGTERM.
+ */
+export declare const MAX_REPLAY_TIMEOUT_MS = 780000;
+/**
+ * Resolve the effective replay-timeout budget for the current process.
+ *
+ * Reads `process.env.WORKFLOW_REPLAY_TIMEOUT_MS` lazily so tests and
+ * deployments can override per invocation. Invalid / out-of-range values
+ * fall back to a safe value (no throw — the env var is an escape hatch,
+ * not a hard requirement) and emit a one-time warning so misconfiguration
+ * is observable.
+ */
+export declare function getReplayTimeoutMs(): number;
+/**
+ * Reset the warn-once cache. Test-only — exported so unit tests can
+ * exercise the warn path repeatedly without sharing state.
+ *
+ * @internal
+ */
+export declare function _resetReplayTimeoutWarnCacheForTests(): void;
 export declare const REPLAY_TIMEOUT_MAX_RETRIES = 3;
 //# sourceMappingURL=constants.d.ts.map

package/dist/runtime/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AASvC,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAMzC,eAAO,MAAM,0BAA0B,IAAI,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAgB7C;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CA6B3C;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D;AAMD,eAAO,MAAM,0BAA0B,IAAI,CAAC"}

package/dist/runtime/constants.js

@@ -1,3 +1,4 @@
+import { runtimeLogger } from '../logger.js';
 // Maximum number of queue delivery attempts before the handler gives up and
 // gracefully fails the run/step. This must be bounded under the VQS message
 // max visibility window (24 hours) so that our handler-side failure path
@@ -11,17 +12,94 @@
 // At 48 attempts the total elapsed time is approximately 20 hours, which is
 // safely under the 24-hour message visibility limit.
 export const MAX_QUEUE_DELIVERIES = 48;
-// Maximum time allowed for a single workflow replay execution (in ms).
-// If a replay exceeds this duration, the process exits so the queue can retry.
-// This must be lower than the function's maxDuration to ensure the
-// timeout handler has time to post the run_failed event before the platform
-// kills the function.
-// Note that on hobby plan, the maxDuration is 60s, so this barrier will not be hit,
-// and the queue will re-try until the visibility window expires.
+/**
+ * Default maximum time allowed for the *replay* portion of a single workflow
+ * handler invocation (in ms). This budget only covers deterministic-replay
+ * and workflow-VM execution between step boundaries — inline step bodies
+ * (`"use step"` functions invoked via `executeStep`) do NOT count against
+ * it. Step bodies are bounded separately by the platform's function
+ * `maxDuration` (e.g. 800s on Vercel Pro Fluid) and `NO_INLINE_REPLAY_AFTER_MS`.
+ *
+ * If the non-step ("replay") time within a single invocation exceeds this
+ * budget, the handler exits so the queue can retry. After
+ * `REPLAY_TIMEOUT_MAX_RETRIES` exhausted attempts the run is failed with
+ * `RUN_ERROR_CODES.REPLAY_TIMEOUT`.
+ *
+ * Note that on Vercel Hobby (standard functions), the platform `maxDuration`
+ * is 60s — well below this budget, so the platform SIGTERM will fire first
+ * and the queue will re-deliver until the visibility window expires. With
+ * Fluid Compute on Hobby the per-function ceiling rises to 300s, still
+ * under the default budget.
+ *
+ * Override via the `WORKFLOW_REPLAY_TIMEOUT_MS` env var (clamped to
+ * `MIN_REPLAY_TIMEOUT_MS`..`MAX_REPLAY_TIMEOUT_MS`).
+ */
 export const REPLAY_TIMEOUT_MS = 240_000;
+/** Lower bound for the replay-timeout env var override. */
+export const MIN_REPLAY_TIMEOUT_MS = 30_000;
+/**
+ * Upper bound for the replay-timeout env var override. 780s leaves ≥20s of
+ * headroom under Vercel Pro Fluid's 800s function ceiling so the handler
+ * can write `run_failed` before SIGTERM.
+ */
+export const MAX_REPLAY_TIMEOUT_MS = 780_000;
+// Track which raw env var values we've already warned about so the warning
+// log only fires once per process (the function may be called many times).
+const warnedReplayTimeoutValues = new Set();
+function warnOnce(raw, message, data) {
+    if (warnedReplayTimeoutValues.has(raw))
+        return;
+    warnedReplayTimeoutValues.add(raw);
+    runtimeLogger.warn(message, data);
+}
+/**
+ * Resolve the effective replay-timeout budget for the current process.
+ *
+ * Reads `process.env.WORKFLOW_REPLAY_TIMEOUT_MS` lazily so tests and
+ * deployments can override per invocation. Invalid / out-of-range values
+ * fall back to a safe value (no throw — the env var is an escape hatch,
+ * not a hard requirement) and emit a one-time warning so misconfiguration
+ * is observable.
+ */
+export function getReplayTimeoutMs() {
+    const raw = process.env.WORKFLOW_REPLAY_TIMEOUT_MS;
+    if (!raw)
+        return REPLAY_TIMEOUT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        warnOnce(raw, 'Ignoring WORKFLOW_REPLAY_TIMEOUT_MS: not a positive finite number; using default', { raw, defaultMs: REPLAY_TIMEOUT_MS });
+        return REPLAY_TIMEOUT_MS;
+    }
+    if (parsed < MIN_REPLAY_TIMEOUT_MS) {
+        warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS below minimum; clamped', {
+            raw,
+            clampedMs: MIN_REPLAY_TIMEOUT_MS,
+            minMs: MIN_REPLAY_TIMEOUT_MS,
+        });
+        return MIN_REPLAY_TIMEOUT_MS;
+    }
+    if (parsed > MAX_REPLAY_TIMEOUT_MS) {
+        warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS above maximum; clamped', {
+            raw,
+            clampedMs: MAX_REPLAY_TIMEOUT_MS,
+            maxMs: MAX_REPLAY_TIMEOUT_MS,
+        });
+        return MAX_REPLAY_TIMEOUT_MS;
+    }
+    return parsed;
+}
+/**
+ * Reset the warn-once cache. Test-only — exported so unit tests can
+ * exercise the warn path repeatedly without sharing state.
+ *
+ * @internal
+ */
+export function _resetReplayTimeoutWarnCacheForTests() {
+    warnedReplayTimeoutValues.clear();
+}
 // Number of queue delivery attempts to allow before permanently failing a run
 // due to a replay timeout. On attempts 1 through this value, the timeout
 // handler exits without writing run_failed so the queue retries the message.
 // On the next attempt the run is marked as failed.
 export const REPLAY_TIMEOUT_MAX_RETRIES = 3;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,4EAA4E;AAC5E,4EAA4E;AAC5E,yEAAyE;AACzE,oDAAoD;AACpD,EAAE;AACF,kDAAkD;AAClD,2EAA2E;AAC3E,+DAA+D;AAC/D,wEAAwE;AACxE,EAAE;AACF,4EAA4E;AAC5E,qDAAqD;AACrD,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAEzC,2DAA2D;AAC3D,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC;AAE7C,2EAA2E;AAC3E,2EAA2E;AAC3E,MAAM,yBAAyB,GAAG,IAAI,GAAG,EAAU,CAAC;AAEpD,SAAS,QAAQ,CACf,GAAW,EACX,OAAe,EACf,IAA6B;IAE7B,IAAI,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO;IAC/C,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACnC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC;IACnD,IAAI,CAAC,GAAG;QAAE,OAAO,iBAAiB,CAAC;IACnC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;QAC5C,QAAQ,CACN,GAAG,EACH,kFAAkF,EAClF,EAAE,GAAG,EAAE,SAAS,EAAE,iBAAiB,EAAE,CACtC,CAAC;QACF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IACD,IAAI,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACnC,QAAQ,CAAC,GAAG,EAAE,mDAAmD,EAAE;YACjE,GAAG;YACH,SAAS,EAAE,qBAAqB;YAChC,KAAK,EAAE,qBAAqB;SAC7B,CAAC,CAAC;QACH,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,IAAI,MAAM,GAAG,qBAAqB,EAAE,CAAC;QACnC,QAAQ,CAAC,GAAG,EAAE,mDAAmD,EAAE;YACjE,GAAG;YACH,SAAS,EAAE,qBAAqB;YAChC,KAAK,EAAE,qBAAqB;SAC7B,CAAC,CAAC;QACH,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oCAAoC;IAClD,yBAAyB,CAAC,KAAK,EAAE,CAAC;AACpC,CAAC;AAED,8EAA8E;AAC9E,yEAAyE;AACzE,6EAA6E;AAC7E,mDAAmD;AACnD,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC","sourcesContent":["import { runtimeLogger } from '../logger.js';\n\n// Maximum number of queue delivery attempts before the handler gives up and\n// gracefully fails the run/step. This must be bounded under the VQS message\n// max visibility window (24 hours) so that our handler-side failure path\n// reliably executes before VQS expires the message.\n//\n// VQS retry schedule (with retryAfterSeconds: 5):\n//   Attempts 1–32:  linear backoff at 5s each  → 32 × 5s = 160s (~2.7 min)\n//   Attempts 33+:   exponential backoff: 60s × 2^(attempt-32),\n//                   capped at 7,200s (2h), floored at retryAfterSeconds\n//\n// At 48 attempts the total elapsed time is approximately 20 hours, which is\n// safely under the 24-hour message visibility limit.\nexport const MAX_QUEUE_DELIVERIES = 48;\n\n/**\n * Default maximum time allowed for the *replay* portion of a single workflow\n * handler invocation (in ms). This budget only covers deterministic-replay\n * and workflow-VM execution between step boundaries — inline step bodies\n * (`\"use step\"` functions invoked via `executeStep`) do NOT count against\n * it. Step bodies are bounded separately by the platform's function\n * `maxDuration` (e.g. 800s on Vercel Pro Fluid) and `NO_INLINE_REPLAY_AFTER_MS`.\n *\n * If the non-step (\"replay\") time within a single invocation exceeds this\n * budget, the handler exits so the queue can retry. After\n * `REPLAY_TIMEOUT_MAX_RETRIES` exhausted attempts the run is failed with\n * `RUN_ERROR_CODES.REPLAY_TIMEOUT`.\n *\n * Note that on Vercel Hobby (standard functions), the platform `maxDuration`\n * is 60s — well below this budget, so the platform SIGTERM will fire first\n * and the queue will re-deliver until the visibility window expires. With\n * Fluid Compute on Hobby the per-function ceiling rises to 300s, still\n * under the default budget.\n *\n * Override via the `WORKFLOW_REPLAY_TIMEOUT_MS` env var (clamped to\n * `MIN_REPLAY_TIMEOUT_MS`..`MAX_REPLAY_TIMEOUT_MS`).\n */\nexport const REPLAY_TIMEOUT_MS = 240_000;\n\n/** Lower bound for the replay-timeout env var override. */\nexport const MIN_REPLAY_TIMEOUT_MS = 30_000;\n\n/**\n * Upper bound for the replay-timeout env var override. 780s leaves ≥20s of\n * headroom under Vercel Pro Fluid's 800s function ceiling so the handler\n * can write `run_failed` before SIGTERM.\n */\nexport const MAX_REPLAY_TIMEOUT_MS = 780_000;\n\n// Track which raw env var values we've already warned about so the warning\n// log only fires once per process (the function may be called many times).\nconst warnedReplayTimeoutValues = new Set<string>();\n\nfunction warnOnce(\n  raw: string,\n  message: string,\n  data: Record<string, unknown>\n): void {\n  if (warnedReplayTimeoutValues.has(raw)) return;\n  warnedReplayTimeoutValues.add(raw);\n  runtimeLogger.warn(message, data);\n}\n\n/**\n * Resolve the effective replay-timeout budget for the current process.\n *\n * Reads `process.env.WORKFLOW_REPLAY_TIMEOUT_MS` lazily so tests and\n * deployments can override per invocation. Invalid / out-of-range values\n * fall back to a safe value (no throw — the env var is an escape hatch,\n * not a hard requirement) and emit a one-time warning so misconfiguration\n * is observable.\n */\nexport function getReplayTimeoutMs(): number {\n  const raw = process.env.WORKFLOW_REPLAY_TIMEOUT_MS;\n  if (!raw) return REPLAY_TIMEOUT_MS;\n  const parsed = Number(raw);\n  if (!Number.isFinite(parsed) || parsed <= 0) {\n    warnOnce(\n      raw,\n      'Ignoring WORKFLOW_REPLAY_TIMEOUT_MS: not a positive finite number; using default',\n      { raw, defaultMs: REPLAY_TIMEOUT_MS }\n    );\n    return REPLAY_TIMEOUT_MS;\n  }\n  if (parsed < MIN_REPLAY_TIMEOUT_MS) {\n    warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS below minimum; clamped', {\n      raw,\n      clampedMs: MIN_REPLAY_TIMEOUT_MS,\n      minMs: MIN_REPLAY_TIMEOUT_MS,\n    });\n    return MIN_REPLAY_TIMEOUT_MS;\n  }\n  if (parsed > MAX_REPLAY_TIMEOUT_MS) {\n    warnOnce(raw, 'WORKFLOW_REPLAY_TIMEOUT_MS above maximum; clamped', {\n      raw,\n      clampedMs: MAX_REPLAY_TIMEOUT_MS,\n      maxMs: MAX_REPLAY_TIMEOUT_MS,\n    });\n    return MAX_REPLAY_TIMEOUT_MS;\n  }\n  return parsed;\n}\n\n/**\n * Reset the warn-once cache. Test-only — exported so unit tests can\n * exercise the warn path repeatedly without sharing state.\n *\n * @internal\n */\nexport function _resetReplayTimeoutWarnCacheForTests(): void {\n  warnedReplayTimeoutValues.clear();\n}\n\n// Number of queue delivery attempts to allow before permanently failing a run\n// due to a replay timeout. On attempts 1 through this value, the timeout\n// handler exits without writing run_failed so the queue retries the message.\n// On the next attempt the run is marked as failed.\nexport const REPLAY_TIMEOUT_MAX_RETRIES = 3;\n"]}

package/dist/runtime/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,KAAK,EACN,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAiB7D;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAOzE;AAWD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAYD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAoGD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CA2E5B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CA6DrD;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,MAAM,GACxB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA8BrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBA0BxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,WAAW,GAAG,MAAM,GAC5B,MAAM,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAiBtC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,KAAK,EACN,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAiB7D;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAOzE;AAWD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAYD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAoGD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CA2E5B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAqErD;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,MAAM,GACxB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA8BrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBA0BxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,WAAW,GAAG,MAAM,GAC5B,MAAM,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAiBtC"}