@workflow/core 4.8.3 → 4.8.5

package/dist/runtime/suspension-handler.js

@@ -1,4 +1,4 @@
-import { EntityConflictError, HookNotFoundError, RunExpiredError, } from '@workflow/errors';
+import { EntityConflictError, HookNotFoundError, RunExpiredError, RuntimeDecryptionError, } from '@workflow/errors';
 import { SPEC_VERSION_CURRENT, } from '@workflow/world';
 import { importKey } from '../encryption.js';
 import { runtimeLogger } from '../logger.js';
@@ -6,6 +6,7 @@ import { dehydrateStepArguments } from '../serialization.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
 import { serializeTraceCarrier } from '../telemetry.js';
 import { queueMessage, withPreconditionRetry, } from './helpers.js';
+import { unserializableStepInputPlaceholder } from './unserializable-step.js';
 /**
  * Extracts W3C trace context headers from a trace carrier for HTTP propagation.
  * Returns an object with `traceparent` and optionally `tracestate` headers.
@@ -182,6 +183,96 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     const stepsNeedingCreation = new Set(stepItems
         .filter((queueItem) => !queueItem.hasCreatedEvent)
         .map((queueItem) => queueItem.correlationId));
+    // Correlation IDs of steps finalized as failed because their arguments
+    // refused to serialize — see finalizeUnserializableStep below.
+    const failedStepCorrelationIds = new Set();
+    /**
+     * A step whose arguments fail to serialize is deterministic: every replay
+     * re-derives the same unserializable value, so redelivering the
+     * orchestrator message can never succeed. Instead of rejecting the whole
+     * suspension (which fails the run from the outside, where no user code can
+     * observe it), treat it exactly like a step-body failure: write
+     * `step_created` with a placeholder input (every World requires the step
+     * entity to exist before a terminal step event, and the real input is
+     * precisely what refused to serialize) followed by `step_failed` carrying
+     * the serialization error. The next replay rejects the step's promise with
+     * it, so a try/catch around the step call observes the error; uncaught, it
+     * propagates out of the workflow body and fails the run as a USER_ERROR —
+     * without burning queue redeliveries either way.
+     */
+    const finalizeUnserializableStep = async (queueItem, error) => {
+        runtimeLogger.warn('Step arguments failed to serialize; failing the step so the ' +
+            'workflow can observe the error', {
+            workflowRunId: runId,
+            correlationId: queueItem.correlationId,
+            stepName: queueItem.stepName,
+            error: error.message,
+        });
+        // Marker placeholder (not empty args): byte-identical-to-zero-args would
+        // make `workflow inspect steps` show "no arguments" for the one step
+        // whose entire problem was its arguments.
+        const placeholderInput = (await dehydrateStepArguments(unserializableStepInputPlaceholder(), runId, encryptionKey, suspension.globalThis));
+        try {
+            await createGuarded({
+                eventType: 'step_created',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: queueItem.correlationId,
+                eventData: {
+                    stepName: queueItem.stepName,
+                    workflowName: run.workflowName,
+                    input: placeholderInput,
+                },
+            }, { requestId });
+        }
+        catch (createErr) {
+            if (EntityConflictError.is(createErr)) {
+                // A concurrent handler already created the step — the failure is
+                // deterministic, so it is racing toward the same step_failed below.
+                runtimeLogger.info('Step already exists, continuing', {
+                    workflowRunId: runId,
+                    correlationId: queueItem.correlationId,
+                    message: createErr.message,
+                });
+            }
+            else if (RunExpiredError.is(createErr)) {
+                // Run already finished — nothing to observe the failure.
+                return;
+            }
+            else {
+                throw createErr;
+            }
+        }
+        try {
+            await createGuarded({
+                eventType: 'step_failed',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: queueItem.correlationId,
+                eventData: {
+                    stepName: queueItem.stepName,
+                    // The message carries the framed serialization hint; the step
+                    // consumer rejects the step's promise with a FatalError built
+                    // from it, exactly like any other step failure.
+                    error: error.message,
+                    stack: error.stack,
+                },
+            }, { requestId });
+        }
+        catch (failErr) {
+            if (EntityConflictError.is(failErr) || RunExpiredError.is(failErr)) {
+                // Step already terminal (a concurrent handler wrote the same
+                // deterministic failure) or the run already finished.
+                runtimeLogger.info('Tried failing step, but step or run has already finished.', {
+                    workflowRunId: runId,
+                    correlationId: queueItem.correlationId,
+                    message: failErr.message,
+                });
+            }
+            else {
+                throw failErr;
+            }
+        }
+        failedStepCorrelationIds.add(queueItem.correlationId);
+    };
     // Process steps and waits in parallel
     // Each step: create event (if needed) -> queue message
     // Each wait: create event (if needed)
@@ -191,11 +282,25 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         ops.push((async () => {
             // Create step event if not already created
             if (stepsNeedingCreation.has(queueItem.correlationId)) {
-                const dehydratedInput = await dehydrateStepArguments({
-                    args: queueItem.args,
-                    closureVars: queueItem.closureVars,
-                    thisVal: queueItem.thisVal,
-                }, runId, encryptionKey, suspension.globalThis);
+                let dehydratedInput;
+                try {
+                    dehydratedInput = await dehydrateStepArguments({
+                        args: queueItem.args,
+                        closureVars: queueItem.closureVars,
+                        thisVal: queueItem.thisVal,
+                    }, runId, encryptionKey, suspension.globalThis);
+                }
+                catch (err) {
+                    if (RuntimeDecryptionError.is(err)) {
+                        // An SDK fault, not a user value problem. Keep its identity
+                        // (RUNTIME_ERROR) and current fail-the-suspension behavior.
+                        throw err;
+                    }
+                    // Every other failure out of dehydrateStepArguments is a
+                    // serialization failure on the step's own arguments.
+                    await finalizeUnserializableStep(queueItem, err instanceof Error ? err : new Error(String(err)));
+                    return;
+                }
                 const stepEvent = {
                     eventType: 'step_created',
                     specVersion: SPEC_VERSION_CURRENT,
@@ -296,7 +401,22 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         ...Attribute.WorkflowStepsCreated(stepItems.length),
         ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),
         ...Attribute.WorkflowWaitsCreated(waitItems.length),
+        ...(failedStepCorrelationIds.size > 0
+            ? Attribute.WorkflowStepsFailedSerialization(failedStepCorrelationIds.size)
+            : {}),
     });
+    // Steps whose arguments failed to serialize were finalized above as
+    // step_created + step_failed (see finalizeUnserializableStep). No
+    // step-execution message is dispatched for them, so when such a step is
+    // the only pending work nothing would ever wake the run again — schedule
+    // an immediate re-invocation. The replay rejects the step's promise with
+    // the serialization error, which a try/catch around the step call
+    // observes; uncaught, it propagates out of the workflow body and fails
+    // the run as a USER_ERROR. Healthy sibling steps were already queued
+    // above, so they execute in parallel invocations regardless.
+    if (failedStepCorrelationIds.size > 0) {
+        return { timeoutSeconds: 0, failedStepCorrelationIds };
+    }
     // If any hook conflicts occurred, re-enqueue the workflow immediately
     // On the next iteration, the hook consumer will see the hook_conflict event
     // and reject the promise with a WorkflowRuntimeError
@@ -318,4 +438,4 @@ export async function handleSuspension({ suspension, world, run, span, requestId
     }
     return {};
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suspension-handler.js","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport {\n  EntityConflictError,\n  HookNotFoundError,\n  RunExpiredError,\n} from '@workflow/errors';\nimport {\n  type CreateEventParams,\n  type CreateEventRequest,\n  type EventResult,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { importKey } from '../encryption.js';\nimport type {\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateStepArguments } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { serializeTraceCarrier } from '../telemetry.js';\nimport {\n  type MutableEventLog,\n  queueMessage,\n  withPreconditionRetry,\n} from './helpers.js';\n\n/**\n * Extracts W3C trace context headers from a trace carrier for HTTP propagation.\n * Returns an object with `traceparent` and optionally `tracestate` headers.\n */\nfunction extractTraceHeaders(\n  traceCarrier: Record<string, string>\n): Record<string, string> {\n  const headers: Record<string, string> = {};\n  if (traceCarrier.traceparent) {\n    headers.traceparent = traceCarrier.traceparent;\n  }\n  if (traceCarrier.tracestate) {\n    headers.tracestate = traceCarrier.tracestate;\n  }\n  return headers;\n}\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n  /**\n   * The runtime's loaded event log. Each event creation is sent with this\n   * snapshot's `stateUpdatedAt` and, if the backend rejects it as stale (412),\n   * the log is reloaded in place and the create is retried — see\n   * `withPreconditionRetry`. Guarding per-create (rather than the whole\n   * suspension) ensures a retry never re-issues an already-created event.\n   */\n  eventLog?: MutableEventLog;\n}\n\nexport interface SuspensionHandlerResult {\n  timeoutSeconds?: number;\n}\n\nasync function createHookEvent({\n  runId,\n  hookEvent,\n  queueItem,\n  requestId,\n  createEvent,\n}: {\n  runId: string;\n  hookEvent: CreateEventRequest;\n  queueItem: HookInvocationQueueItem;\n  requestId?: string;\n  createEvent: (\n    data: CreateEventRequest,\n    params?: CreateEventParams\n  ) => Promise<EventResult>;\n}): Promise<{\n  hasHookConflict: boolean;\n  hasAwaitedHookCreation: boolean;\n}> {\n  try {\n    const result = await createEvent(hookEvent, {\n      requestId,\n    });\n\n    // Check if the world returned a hook_conflict event instead of hook_created.\n    // The hook_conflict event is stored in the event log and will be replayed\n    // on the next workflow invocation, causing the hook's promise to reject.\n    if (result.event?.eventType === 'hook_conflict') {\n      return {\n        hasHookConflict: true,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    return {\n      hasHookConflict: false,\n      hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n    };\n  } catch (err) {\n    if (EntityConflictError.is(err)) {\n      runtimeLogger.info('Hook already exists, continuing', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n      };\n    }\n\n    if (RunExpiredError.is(err)) {\n      runtimeLogger.info('Workflow run already completed, skipping hook', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    throw err;\n  }\n}\n\n/**\n * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).\n * Uses an event-sourced architecture where entities (steps, hooks) are created atomically\n * with their corresponding events via events.create().\n *\n * Processing order:\n * 1. Hooks are processed first to prevent race conditions with webhook receivers\n * 2. Steps and waits are processed in parallel after hooks complete\n */\nexport async function handleSuspension({\n  suspension,\n  world,\n  run,\n  span,\n  requestId,\n  eventLog,\n}: SuspensionHandlerParams): Promise<SuspensionHandlerResult> {\n  const runId = run.runId;\n  const workflowName = run.workflowName;\n  const workflowStartedAt = run.startedAt ? +run.startedAt : Date.now();\n\n  // Create an event with the optimistic-concurrency guard when the caller\n  // supplied a loaded event log; otherwise create it directly (callers without\n  // a replay snapshot, e.g. tests). The guard reloads + retries on a stale\n  // (412) rejection, keeping `eventLog` current in place. All suspension events\n  // are non-run_created events on this run's `runId`.\n  const createGuarded = (\n    data: CreateEventRequest,\n    params?: CreateEventParams\n  ): Promise<EventResult> => {\n    if (!eventLog) {\n      return world.events.create(runId, data, params);\n    }\n    return withPreconditionRetry(runId, eventLog, (stateUpdatedAt) =>\n      world.events.create(runId, data, { ...params, stateUpdatedAt })\n    );\n  };\n  // Separate queue items by type\n  const stepItems = suspension.steps.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.steps.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.steps.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n\n  // Split hooks by what actions they need\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n  // Hooks needing disposal: any disposed hook (including those needing creation first)\n  // Hooks are created before disposal in the processing order below\n  const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);\n\n  // Resolve encryption key for this run\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n\n  // Build hook_created events (World will atomically create hook entities)\n  const hookEvents = await Promise.all(\n    hooksNeedingCreation.map(async (queueItem) => {\n      const hookMetadata: SerializedData | undefined =\n        typeof queueItem.metadata === 'undefined'\n          ? undefined\n          : ((await dehydrateStepArguments(\n              queueItem.metadata,\n              runId,\n              encryptionKey,\n              suspension.globalThis\n            )) as SerializedData);\n      return {\n        queueItem,\n        hookEvent: {\n          eventType: 'hook_created' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            token: queueItem.token,\n            metadata: hookMetadata,\n            isWebhook: queueItem.isWebhook ?? false,\n          },\n        },\n      };\n    })\n  );\n\n  // Process hooks first to prevent race conditions with webhook receivers\n  // All hook creations run in parallel\n  // Track any hook conflicts that occur - these will be handled by re-enqueueing the workflow\n  let hasHookConflict = false;\n  let hasAwaitedHookCreation = false;\n\n  if (hookEvents.length > 0) {\n    const results = await Promise.all(\n      hookEvents.map(({ hookEvent, queueItem }) =>\n        createHookEvent({\n          runId,\n          hookEvent,\n          queueItem,\n          requestId,\n          createEvent: createGuarded,\n        })\n      )\n    );\n    hasHookConflict = results.some((result) => result.hasHookConflict);\n    hasAwaitedHookCreation = results.some(\n      (result) => result.hasAwaitedHookCreation\n    );\n  }\n\n  // Process hook disposals - these release hook tokens for reuse by other workflows\n  if (hooksNeedingDisposal.length > 0) {\n    await Promise.all(\n      hooksNeedingDisposal.map(async (queueItem) => {\n        const hookDisposedEvent: CreateEventRequest = {\n          eventType: 'hook_disposed' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            token: queueItem.token,\n          },\n        };\n        try {\n          await createGuarded(hookDisposedEvent, { requestId });\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            // Hook was already disposed by a concurrent invocation — safe to skip\n            runtimeLogger.info(\n              'Hook already disposed, skipping duplicate disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping hook disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (HookNotFoundError.is(err)) {\n            // Hook may have already been disposed or never created\n            runtimeLogger.info('Hook not found for disposal, continuing', {\n              workflowRunId: runId,\n              correlationId: queueItem.correlationId,\n              message: err.message,\n            });\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Build a map of stepId -> step event for steps that need creation\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Process steps and waits in parallel\n  // Each step: create event (if needed) -> queue message\n  // Each wait: create event (if needed)\n  const ops: Promise<void>[] = [];\n\n  // Steps: create event then queue message, all in parallel\n  for (const queueItem of stepItems) {\n    ops.push(\n      (async () => {\n        // Create step event if not already created\n        if (stepsNeedingCreation.has(queueItem.correlationId)) {\n          const dehydratedInput = await dehydrateStepArguments(\n            {\n              args: queueItem.args,\n              closureVars: queueItem.closureVars,\n              thisVal: queueItem.thisVal,\n            },\n            runId,\n            encryptionKey,\n            suspension.globalThis\n          );\n          const stepEvent: CreateEventRequest = {\n            eventType: 'step_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              stepName: queueItem.stepName,\n              workflowName: run.workflowName,\n              input: dehydratedInput as SerializedData,\n            },\n          };\n          try {\n            await createGuarded(stepEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Step already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        }\n\n        // Queue step execution message\n        // Serialize trace context once and include in both payload and headers\n        // Payload: for manual context restoration in step handler\n        // Headers: for automatic trace propagation by Vercel's infrastructure\n        const traceCarrier = await serializeTraceCarrier();\n        await queueMessage(\n          world,\n          `__wkf_step_${queueItem.stepName}`,\n          {\n            workflowName,\n            workflowRunId: runId,\n            workflowStartedAt,\n            stepId: queueItem.correlationId,\n            traceCarrier,\n            requestedAt: new Date(),\n          },\n          {\n            idempotencyKey: queueItem.correlationId,\n            headers: {\n              ...extractTraceHeaders(traceCarrier),\n            },\n          }\n        );\n      })()\n    );\n  }\n\n  // Waits: create events in parallel (no queueing needed for waits)\n  for (const queueItem of waitItems) {\n    if (!queueItem.hasCreatedEvent) {\n      ops.push(\n        (async () => {\n          const waitEvent: CreateEventRequest = {\n            eventType: 'wait_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              resumeAt: queueItem.resumeAt,\n            },\n          };\n          try {\n            await createGuarded(waitEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Wait already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  // Await the step_created / wait_created event creates before returning.\n  // The caller (workflowEntrypoint) only enqueues the step-dispatch queue\n  // messages AFTER handleSuspension resolves, and the queue handler acks\n  // the orchestrator message only after the caller resolves. So the step_created\n  // events must be durable here, and the dispatch sends must complete in the caller,\n  // all before ack. If the process crashes before this resolves, the orchestrator\n  // message is not acked and VQS redelivers, re-creates the (idempotent)\n  // step_created and re-dispatches, and recovers the run instead of orphaning it.\n  await Promise.all(ops);\n\n  // Calculate minimum timeout from waits\n  const now = Date.now();\n  const minTimeoutSeconds = waitItems.reduce<number | null>(\n    (min, queueItem) => {\n      const resumeAtMs = queueItem.resumeAt.getTime();\n      const delayMs = Math.max(1000, resumeAtMs - now);\n      const timeoutSeconds = Math.ceil(delayMs / 1000);\n      if (min === null) return timeoutSeconds;\n      return Math.min(min, timeoutSeconds);\n    },\n    null\n  );\n\n  span?.setAttributes({\n    ...Attribute.WorkflowRunStatus('workflow_suspended'),\n    ...Attribute.WorkflowStepsCreated(stepItems.length),\n    ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),\n    ...Attribute.WorkflowWaitsCreated(waitItems.length),\n  });\n\n  // If any hook conflicts occurred, re-enqueue the workflow immediately\n  // On the next iteration, the hook consumer will see the hook_conflict event\n  // and reject the promise with a WorkflowRuntimeError\n  // We do this after processing all other operations (steps, waits) to ensure\n  // they are recorded in the event log before the re-execution\n  if (hasHookConflict) {\n    return { timeoutSeconds: 0 };\n  }\n\n  // A `hook.getConflict()` awaiter needs an immediate re-invocation: the\n  // replay consumes the just-committed hook_created and resolves the\n  // awaiter with `null`. Without it the run would sit idle until some\n  // unrelated message woke it. Any pending steps were already queued\n  // above, so they execute in parallel invocations regardless.\n  if (hasAwaitedHookCreation) {\n    return { timeoutSeconds: 0 };\n  }\n\n  if (minTimeoutSeconds !== null) {\n    return { timeoutSeconds: minTimeoutSeconds };\n  }\n\n  return {};\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suspension-handler.js","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EACf,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAKL,oBAAoB,GAGrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAO7C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,SAAS,MAAM,sCAAsC,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAEL,YAAY,EACZ,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,kCAAkC,EAAE,MAAM,0BAA0B,CAAC;AAE9E;;;GAGG;AACH,SAAS,mBAAmB,CAC1B,YAAoC;IAEpC,MAAM,OAAO,GAA2B,EAAE,CAAC;IAC3C,IAAI,YAAY,CAAC,WAAW,EAAE,CAAC;QAC7B,OAAO,CAAC,WAAW,GAAG,YAAY,CAAC,WAAW,CAAC;IACjD,CAAC;IACD,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;QAC5B,OAAO,CAAC,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC;IAC/C,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAkCD,KAAK,UAAU,eAAe,CAAC,EAC7B,KAAK,EACL,SAAS,EACT,SAAS,EACT,SAAS,EACT,WAAW,GAUZ;IAIC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,SAAS,EAAE;YAC1C,SAAS;SACV,CAAC,CAAC;QAEH,6EAA6E;QAC7E,0EAA0E;QAC1E,yEAAyE;QACzE,IAAI,MAAM,CAAC,KAAK,EAAE,SAAS,KAAK,eAAe,EAAE,CAAC;YAChD,OAAO;gBACL,eAAe,EAAE,IAAI;gBACrB,sBAAsB,EAAE,KAAK;aAC9B,CAAC;QACJ,CAAC;QAED,OAAO;YACL,eAAe,EAAE,KAAK;YACtB,sBAAsB,EAAE,SAAS,CAAC,kBAAkB,KAAK,IAAI;SAC9D,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;YAChC,aAAa,CAAC,IAAI,CAAC,iCAAiC,EAAE;gBACpD,aAAa,EAAE,KAAK;gBACpB,OAAO,EAAE,GAAG,CAAC,OAAO;aACrB,CAAC,CAAC;YACH,OAAO;gBACL,eAAe,EAAE,KAAK;gBACtB,sBAAsB,EAAE,SAAS,CAAC,kBAAkB,KAAK,IAAI;aAC9D,CAAC;QACJ,CAAC;QAED,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,aAAa,CAAC,IAAI,CAAC,+CAA+C,EAAE;gBAClE,aAAa,EAAE,KAAK;gBACpB,OAAO,EAAE,GAAG,CAAC,OAAO;aACrB,CAAC,CAAC;YACH,OAAO;gBACL,eAAe,EAAE,KAAK;gBACtB,sBAAsB,EAAE,KAAK;aAC9B,CAAC;QACJ,CAAC;QAED,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,EACT,QAAQ,GACgB;IACxB,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;IACxB,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,CAAC;IACtC,MAAM,iBAAiB,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IAEtE,wEAAwE;IACxE,6EAA6E;IAC7E,yEAAyE;IACzE,8EAA8E;IAC9E,oDAAoD;IACpD,MAAM,aAAa,GAAG,CACpB,IAAwB,EACxB,MAA0B,EACJ,EAAE;QACxB,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,cAAc,EAAE,EAAE,CAC/D,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,MAAM,EAAE,cAAc,EAAE,CAAC,CAChE,CAAC;IACJ,CAAC,CAAC;IACF,+BAA+B;IAC/B,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,MAAM,CACvC,CAAC,IAAI,EAAmC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAChE,CAAC;IACF,MAAM,YAAY,GAAG,UAAU,CAAC,KAAK,CAAC,MAAM,CAC1C,CAAC,IAAI,EAAmC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAChE,CAAC;IACF,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,MAAM,CACvC,CAAC,IAAI,EAAmC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAChE,CAAC;IAEF,wCAAwC;IACxC,MAAM,oBAAoB,GAAG,YAAY,CAAC,MAAM,CAC9C,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,eAAe,CAChC,CAAC;IACF,qFAAqF;IACrF,kEAAkE;IAClE,MAAM,oBAAoB,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAE1E,sCAAsC;IACtC,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,GAAG,CAAC,CAAC;IACzD,MAAM,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAEnE,yEAAyE;IACzE,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,GAAG,CAClC,oBAAoB,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;QAC3C,MAAM,YAAY,GAChB,OAAO,SAAS,CAAC,QAAQ,KAAK,WAAW;YACvC,CAAC,CAAC,SAAS;YACX,CAAC,CAAE,CAAC,MAAM,sBAAsB,CAC5B,SAAS,CAAC,QAAQ,EAClB,KAAK,EACL,aAAa,EACb,UAAU,CAAC,UAAU,CACtB,CAAoB,CAAC;QAC5B,OAAO;YACL,SAAS;YACT,SAAS,EAAE;gBACT,SAAS,EAAE,cAAuB;gBAClC,WAAW,EAAE,oBAAoB;gBACjC,aAAa,EAAE,SAAS,CAAC,aAAa;gBACtC,SAAS,EAAE;oBACT,KAAK,EAAE,SAAS,CAAC,KAAK;oBACtB,QAAQ,EAAE,YAAY;oBACtB,SAAS,EAAE,SAAS,CAAC,SAAS,IAAI,KAAK;iBACxC;aACF;SACF,CAAC;IACJ,CAAC,CAAC,CACH,CAAC;IAEF,wEAAwE;IACxE,qCAAqC;IACrC,4FAA4F;IAC5F,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,IAAI,sBAAsB,GAAG,KAAK,CAAC;IAEnC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,CAC1C,eAAe,CAAC;YACd,KAAK;YACL,SAAS;YACT,SAAS;YACT,SAAS;YACT,WAAW,EAAE,aAAa;SAC3B,CAAC,CACH,CACF,CAAC;QACF,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QACnE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CACnC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,sBAAsB,CAC1C,CAAC;IACJ,CAAC;IAED,kFAAkF;IAClF,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpC,MAAM,OAAO,CAAC,GAAG,CACf,oBAAoB,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;YAC3C,MAAM,iBAAiB,GAAuB;gBAC5C,SAAS,EAAE,eAAwB;gBACnC,WAAW,EAAE,oBAAoB;gBACjC,aAAa,EAAE,SAAS,CAAC,aAAa;gBACtC,SAAS,EAAE;oBACT,KAAK,EAAE,SAAS,CAAC,KAAK;iBACvB;aACF,CAAC;YACF,IAAI,CAAC;gBACH,MAAM,aAAa,CAAC,iBAAiB,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;YACxD,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;oBAChC,sEAAsE;oBACtE,aAAa,CAAC,IAAI,CAChB,oDAAoD,EACpD;wBACE,aAAa,EAAE,KAAK;wBACpB,aAAa,EAAE,SAAS,CAAC,aAAa;wBACtC,OAAO,EAAE,GAAG,CAAC,OAAO;qBACrB,CACF,CAAC;gBACJ,CAAC;qBAAM,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;oBACnC,aAAa,CAAC,IAAI,CAChB,wDAAwD,EACxD;wBACE,aAAa,EAAE,KAAK;wBACpB,aAAa,EAAE,SAAS,CAAC,aAAa;wBACtC,OAAO,EAAE,GAAG,CAAC,OAAO;qBACrB,CACF,CAAC;gBACJ,CAAC;qBAAM,IAAI,iBAAiB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;oBACrC,uDAAuD;oBACvD,aAAa,CAAC,IAAI,CAAC,yCAAyC,EAAE;wBAC5D,aAAa,EAAE,KAAK;wBACpB,aAAa,EAAE,SAAS,CAAC,aAAa;wBACtC,OAAO,EAAE,GAAG,CAAC,OAAO;qBACrB,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,MAAM,GAAG,CAAC;gBACZ,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,mEAAmE;IACnE,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAClC,SAAS;SACN,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC;SACjD,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,aAAa,CAAC,CAC/C,CAAC;IAEF,uEAAuE;IACvE,+DAA+D;IAC/D,MAAM,wBAAwB,GAAG,IAAI,GAAG,EAAU,CAAC;IAEnD;;;;;;;;;;;;;OAaG;IACH,MAAM,0BAA0B,GAAG,KAAK,EACtC,SAAkC,EAClC,KAAY,EACG,EAAE;QACjB,aAAa,CAAC,IAAI,CAChB,8DAA8D;YAC5D,gCAAgC,EAClC;YACE,aAAa,EAAE,KAAK;YACpB,aAAa,EAAE,SAAS,CAAC,aAAa;YACtC,QAAQ,EAAE,SAAS,CAAC,QAAQ;YAC5B,KAAK,EAAE,KAAK,CAAC,OAAO;SACrB,CACF,CAAC;QACF,yEAAyE;QACzE,qEAAqE;QACrE,0CAA0C;QAC1C,MAAM,gBAAgB,GAAG,CAAC,MAAM,sBAAsB,CACpD,kCAAkC,EAAE,EACpC,KAAK,EACL,aAAa,EACb,UAAU,CAAC,UAAU,CACtB,CAAmB,CAAC;QACrB,IAAI,CAAC;YACH,MAAM,aAAa,CACjB;gBACE,SAAS,EAAE,cAAuB;gBAClC,WAAW,EAAE,oBAAoB;gBACjC,aAAa,EAAE,SAAS,CAAC,aAAa;gBACtC,SAAS,EAAE;oBACT,QAAQ,EAAE,SAAS,CAAC,QAAQ;oBAC5B,YAAY,EAAE,GAAG,CAAC,YAAY;oBAC9B,KAAK,EAAE,gBAAgB;iBACxB;aACF,EACD,EAAE,SAAS,EAAE,CACd,CAAC;QACJ,CAAC;QAAC,OAAO,SAAS,EAAE,CAAC;YACnB,IAAI,mBAAmB,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;gBACtC,iEAAiE;gBACjE,oEAAoE;gBACpE,aAAa,CAAC,IAAI,CAAC,iCAAiC,EAAE;oBACpD,aAAa,EAAE,KAAK;oBACpB,aAAa,EAAE,SAAS,CAAC,aAAa;oBACtC,OAAO,EAAE,SAAS,CAAC,OAAO;iBAC3B,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,eAAe,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;gBACzC,yDAAyD;gBACzD,OAAO;YACT,CAAC;iBAAM,CAAC;gBACN,MAAM,SAAS,CAAC;YAClB,CAAC;QACH,CAAC;QACD,IAAI,CAAC;YACH,MAAM,aAAa,CACjB;gBACE,SAAS,EAAE,aAAsB;gBACjC,WAAW,EAAE,oBAAoB;gBACjC,aAAa,EAAE,SAAS,CAAC,aAAa;gBACtC,SAAS,EAAE;oBACT,QAAQ,EAAE,SAAS,CAAC,QAAQ;oBAC5B,8DAA8D;oBAC9D,8DAA8D;oBAC9D,gDAAgD;oBAChD,KAAK,EAAE,KAAK,CAAC,OAAO;oBACpB,KAAK,EAAE,KAAK,CAAC,KAAK;iBACnB;aACF,EACD,EAAE,SAAS,EAAE,CACd,CAAC;QACJ,CAAC;QAAC,OAAO,OAAO,EAAE,CAAC;YACjB,IAAI,mBAAmB,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;gBACnE,6DAA6D;gBAC7D,sDAAsD;gBACtD,aAAa,CAAC,IAAI,CAChB,2DAA2D,EAC3D;oBACE,aAAa,EAAE,KAAK;oBACpB,aAAa,EAAE,SAAS,CAAC,aAAa;oBACtC,OAAO,EAAE,OAAO,CAAC,OAAO;iBACzB,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,MAAM,OAAO,CAAC;YAChB,CAAC;QACH,CAAC;QACD,wBAAwB,CAAC,GAAG,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IACxD,CAAC,CAAC;IAEF,sCAAsC;IACtC,uDAAuD;IACvD,sCAAsC;IACtC,MAAM,GAAG,GAAoB,EAAE,CAAC;IAEhC,0DAA0D;IAC1D,KAAK,MAAM,SAAS,IAAI,SAAS,EAAE,CAAC;QAClC,GAAG,CAAC,IAAI,CACN,CAAC,KAAK,IAAI,EAAE;YACV,2CAA2C;YAC3C,IAAI,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC;gBACtD,IAAI,eAAqC,CAAC;gBAC1C,IAAI,CAAC;oBACH,eAAe,GAAG,MAAM,sBAAsB,CAC5C;wBACE,IAAI,EAAE,SAAS,CAAC,IAAI;wBACpB,WAAW,EAAE,SAAS,CAAC,WAAW;wBAClC,OAAO,EAAE,SAAS,CAAC,OAAO;qBAC3B,EACD,KAAK,EACL,aAAa,EACb,UAAU,CAAC,UAAU,CACtB,CAAC;gBACJ,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,sBAAsB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;wBACnC,4DAA4D;wBAC5D,4DAA4D;wBAC5D,MAAM,GAAG,CAAC;oBACZ,CAAC;oBACD,yDAAyD;oBACzD,qDAAqD;oBACrD,MAAM,0BAA0B,CAC9B,SAAS,EACT,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CACpD,CAAC;oBACF,OAAO;gBACT,CAAC;gBACD,MAAM,SAAS,GAAuB;oBACpC,SAAS,EAAE,cAAuB;oBAClC,WAAW,EAAE,oBAAoB;oBACjC,aAAa,EAAE,SAAS,CAAC,aAAa;oBACtC,SAAS,EAAE;wBACT,QAAQ,EAAE,SAAS,CAAC,QAAQ;wBAC5B,YAAY,EAAE,GAAG,CAAC,YAAY;wBAC9B,KAAK,EAAE,eAAiC;qBACzC;iBACF,CAAC;gBACF,IAAI,CAAC;oBACH,MAAM,aAAa,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;gBAChD,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;wBAChC,aAAa,CAAC,IAAI,CAAC,iCAAiC,EAAE;4BACpD,aAAa,EAAE,KAAK;4BACpB,aAAa,EAAE,SAAS,CAAC,aAAa;4BACtC,OAAO,EAAE,GAAG,CAAC,OAAO;yBACrB,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,MAAM,GAAG,CAAC;oBACZ,CAAC;gBACH,CAAC;YACH,CAAC;YAED,+BAA+B;YAC/B,uEAAuE;YACvE,0DAA0D;YAC1D,sEAAsE;YACtE,MAAM,YAAY,GAAG,MAAM,qBAAqB,EAAE,CAAC;YACnD,MAAM,YAAY,CAChB,KAAK,EACL,cAAc,SAAS,CAAC,QAAQ,EAAE,EAClC;gBACE,YAAY;gBACZ,aAAa,EAAE,KAAK;gBACpB,iBAAiB;gBACjB,MAAM,EAAE,SAAS,CAAC,aAAa;gBAC/B,YAAY;gBACZ,WAAW,EAAE,IAAI,IAAI,EAAE;aACxB,EACD;gBACE,cAAc,EAAE,SAAS,CAAC,aAAa;gBACvC,OAAO,EAAE;oBACP,GAAG,mBAAmB,CAAC,YAAY,CAAC;iBACrC;aACF,CACF,CAAC;QACJ,CAAC,CAAC,EAAE,CACL,CAAC;IACJ,CAAC;IAED,kEAAkE;IAClE,KAAK,MAAM,SAAS,IAAI,SAAS,EAAE,CAAC;QAClC,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;YAC/B,GAAG,CAAC,IAAI,CACN,CAAC,KAAK,IAAI,EAAE;gBACV,MAAM,SAAS,GAAuB;oBACpC,SAAS,EAAE,cAAuB;oBAClC,WAAW,EAAE,oBAAoB;oBACjC,aAAa,EAAE,SAAS,CAAC,aAAa;oBACtC,SAAS,EAAE;wBACT,QAAQ,EAAE,SAAS,CAAC,QAAQ;qBAC7B;iBACF,CAAC;gBACF,IAAI,CAAC;oBACH,MAAM,aAAa,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;gBAChD,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;wBAChC,aAAa,CAAC,IAAI,CAAC,iCAAiC,EAAE;4BACpD,aAAa,EAAE,KAAK;4BACpB,aAAa,EAAE,SAAS,CAAC,aAAa;4BACtC,OAAO,EAAE,GAAG,CAAC,OAAO;yBACrB,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,MAAM,GAAG,CAAC;oBACZ,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,EAAE,CACL,CAAC;QACJ,CAAC;IACH,CAAC;IAED,wEAAwE;IACxE,wEAAwE;IACxE,uEAAuE;IACvE,+EAA+E;IAC/E,mFAAmF;IACnF,gFAAgF;IAChF,uEAAuE;IACvE,gFAAgF;IAChF,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAEvB,uCAAuC;IACvC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,MAAM,iBAAiB,GAAG,SAAS,CAAC,MAAM,CACxC,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE;QACjB,MAAM,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;QAChD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,GAAG,CAAC,CAAC;QACjD,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;QACjD,IAAI,GAAG,KAAK,IAAI;YAAE,OAAO,cAAc,CAAC;QACxC,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;IACvC,CAAC,EACD,IAAI,CACL,CAAC;IAEF,IAAI,EAAE,aAAa,CAAC;QAClB,GAAG,SAAS,CAAC,iBAAiB,CAAC,oBAAoB,CAAC;QACpD,GAAG,SAAS,CAAC,oBAAoB,CAAC,SAAS,CAAC,MAAM,CAAC;QACnD,GAAG,SAAS,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,CAAC;QAC9D,GAAG,SAAS,CAAC,oBAAoB,CAAC,SAAS,CAAC,MAAM,CAAC;QACnD,GAAG,CAAC,wBAAwB,CAAC,IAAI,GAAG,CAAC;YACnC,CAAC,CAAC,SAAS,CAAC,gCAAgC,CACxC,wBAAwB,CAAC,IAAI,CAC9B;YACH,CAAC,CAAC,EAAE,CAAC;KACR,CAAC,CAAC;IAEH,oEAAoE;IACpE,kEAAkE;IAClE,wEAAwE;IACxE,yEAAyE;IACzE,yEAAyE;IACzE,kEAAkE;IAClE,uEAAuE;IACvE,qEAAqE;IACrE,6DAA6D;IAC7D,IAAI,wBAAwB,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;QACtC,OAAO,EAAE,cAAc,EAAE,CAAC,EAAE,wBAAwB,EAAE,CAAC;IACzD,CAAC;IAED,sEAAsE;IACtE,4EAA4E;IAC5E,qDAAqD;IACrD,4EAA4E;IAC5E,6DAA6D;IAC7D,IAAI,eAAe,EAAE,CAAC;QACpB,OAAO,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC;IAC/B,CAAC;IAED,uEAAuE;IACvE,mEAAmE;IACnE,oEAAoE;IACpE,mEAAmE;IACnE,6DAA6D;IAC7D,IAAI,sBAAsB,EAAE,CAAC;QAC3B,OAAO,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC;IAC/B,CAAC;IAED,IAAI,iBAAiB,KAAK,IAAI,EAAE,CAAC;QAC/B,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,CAAC;IAC/C,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC","sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport {\n  EntityConflictError,\n  HookNotFoundError,\n  RunExpiredError,\n  RuntimeDecryptionError,\n} from '@workflow/errors';\nimport {\n  type CreateEventParams,\n  type CreateEventRequest,\n  type EventResult,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { importKey } from '../encryption.js';\nimport type {\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateStepArguments } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { serializeTraceCarrier } from '../telemetry.js';\nimport {\n  type MutableEventLog,\n  queueMessage,\n  withPreconditionRetry,\n} from './helpers.js';\nimport { unserializableStepInputPlaceholder } from './unserializable-step.js';\n\n/**\n * Extracts W3C trace context headers from a trace carrier for HTTP propagation.\n * Returns an object with `traceparent` and optionally `tracestate` headers.\n */\nfunction extractTraceHeaders(\n  traceCarrier: Record<string, string>\n): Record<string, string> {\n  const headers: Record<string, string> = {};\n  if (traceCarrier.traceparent) {\n    headers.traceparent = traceCarrier.traceparent;\n  }\n  if (traceCarrier.tracestate) {\n    headers.tracestate = traceCarrier.tracestate;\n  }\n  return headers;\n}\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n  /**\n   * The runtime's loaded event log. Each event creation is sent with this\n   * snapshot's `stateUpdatedAt` and, if the backend rejects it as stale (412),\n   * the log is reloaded in place and the create is retried — see\n   * `withPreconditionRetry`. Guarding per-create (rather than the whole\n   * suspension) ensures a retry never re-issues an already-created event.\n   */\n  eventLog?: MutableEventLog;\n}\n\nexport interface SuspensionHandlerResult {\n  timeoutSeconds?: number;\n  /**\n   * Correlation IDs of steps whose arguments failed to serialize. Each was\n   * finalized here as `step_created` (with a placeholder input — the real\n   * input is precisely what refused to serialize) followed by `step_failed`\n   * carrying the serialization error, so the next replay rejects the step's\n   * promise and a try/catch around the step call observes the error —\n   * exactly like a step-body failure. No step-execution message is\n   * dispatched for these, so an immediate re-invocation is scheduled\n   * (`timeoutSeconds: 0`): when the failed step was the only pending work,\n   * nothing else would ever wake the run to observe the terminal event.\n   */\n  failedStepCorrelationIds?: Set<string>;\n}\n\nasync function createHookEvent({\n  runId,\n  hookEvent,\n  queueItem,\n  requestId,\n  createEvent,\n}: {\n  runId: string;\n  hookEvent: CreateEventRequest;\n  queueItem: HookInvocationQueueItem;\n  requestId?: string;\n  createEvent: (\n    data: CreateEventRequest,\n    params?: CreateEventParams\n  ) => Promise<EventResult>;\n}): Promise<{\n  hasHookConflict: boolean;\n  hasAwaitedHookCreation: boolean;\n}> {\n  try {\n    const result = await createEvent(hookEvent, {\n      requestId,\n    });\n\n    // Check if the world returned a hook_conflict event instead of hook_created.\n    // The hook_conflict event is stored in the event log and will be replayed\n    // on the next workflow invocation, causing the hook's promise to reject.\n    if (result.event?.eventType === 'hook_conflict') {\n      return {\n        hasHookConflict: true,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    return {\n      hasHookConflict: false,\n      hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n    };\n  } catch (err) {\n    if (EntityConflictError.is(err)) {\n      runtimeLogger.info('Hook already exists, continuing', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true,\n      };\n    }\n\n    if (RunExpiredError.is(err)) {\n      runtimeLogger.info('Workflow run already completed, skipping hook', {\n        workflowRunId: runId,\n        message: err.message,\n      });\n      return {\n        hasHookConflict: false,\n        hasAwaitedHookCreation: false,\n      };\n    }\n\n    throw err;\n  }\n}\n\n/**\n * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).\n * Uses an event-sourced architecture where entities (steps, hooks) are created atomically\n * with their corresponding events via events.create().\n *\n * Processing order:\n * 1. Hooks are processed first to prevent race conditions with webhook receivers\n * 2. Steps and waits are processed in parallel after hooks complete\n */\nexport async function handleSuspension({\n  suspension,\n  world,\n  run,\n  span,\n  requestId,\n  eventLog,\n}: SuspensionHandlerParams): Promise<SuspensionHandlerResult> {\n  const runId = run.runId;\n  const workflowName = run.workflowName;\n  const workflowStartedAt = run.startedAt ? +run.startedAt : Date.now();\n\n  // Create an event with the optimistic-concurrency guard when the caller\n  // supplied a loaded event log; otherwise create it directly (callers without\n  // a replay snapshot, e.g. tests). The guard reloads + retries on a stale\n  // (412) rejection, keeping `eventLog` current in place. All suspension events\n  // are non-run_created events on this run's `runId`.\n  const createGuarded = (\n    data: CreateEventRequest,\n    params?: CreateEventParams\n  ): Promise<EventResult> => {\n    if (!eventLog) {\n      return world.events.create(runId, data, params);\n    }\n    return withPreconditionRetry(runId, eventLog, (stateUpdatedAt) =>\n      world.events.create(runId, data, { ...params, stateUpdatedAt })\n    );\n  };\n  // Separate queue items by type\n  const stepItems = suspension.steps.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.steps.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.steps.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n\n  // Split hooks by what actions they need\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n  // Hooks needing disposal: any disposed hook (including those needing creation first)\n  // Hooks are created before disposal in the processing order below\n  const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);\n\n  // Resolve encryption key for this run\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n\n  // Build hook_created events (World will atomically create hook entities)\n  const hookEvents = await Promise.all(\n    hooksNeedingCreation.map(async (queueItem) => {\n      const hookMetadata: SerializedData | undefined =\n        typeof queueItem.metadata === 'undefined'\n          ? undefined\n          : ((await dehydrateStepArguments(\n              queueItem.metadata,\n              runId,\n              encryptionKey,\n              suspension.globalThis\n            )) as SerializedData);\n      return {\n        queueItem,\n        hookEvent: {\n          eventType: 'hook_created' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            token: queueItem.token,\n            metadata: hookMetadata,\n            isWebhook: queueItem.isWebhook ?? false,\n          },\n        },\n      };\n    })\n  );\n\n  // Process hooks first to prevent race conditions with webhook receivers\n  // All hook creations run in parallel\n  // Track any hook conflicts that occur - these will be handled by re-enqueueing the workflow\n  let hasHookConflict = false;\n  let hasAwaitedHookCreation = false;\n\n  if (hookEvents.length > 0) {\n    const results = await Promise.all(\n      hookEvents.map(({ hookEvent, queueItem }) =>\n        createHookEvent({\n          runId,\n          hookEvent,\n          queueItem,\n          requestId,\n          createEvent: createGuarded,\n        })\n      )\n    );\n    hasHookConflict = results.some((result) => result.hasHookConflict);\n    hasAwaitedHookCreation = results.some(\n      (result) => result.hasAwaitedHookCreation\n    );\n  }\n\n  // Process hook disposals - these release hook tokens for reuse by other workflows\n  if (hooksNeedingDisposal.length > 0) {\n    await Promise.all(\n      hooksNeedingDisposal.map(async (queueItem) => {\n        const hookDisposedEvent: CreateEventRequest = {\n          eventType: 'hook_disposed' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            token: queueItem.token,\n          },\n        };\n        try {\n          await createGuarded(hookDisposedEvent, { requestId });\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            // Hook was already disposed by a concurrent invocation — safe to skip\n            runtimeLogger.info(\n              'Hook already disposed, skipping duplicate disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping hook disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (HookNotFoundError.is(err)) {\n            // Hook may have already been disposed or never created\n            runtimeLogger.info('Hook not found for disposal, continuing', {\n              workflowRunId: runId,\n              correlationId: queueItem.correlationId,\n              message: err.message,\n            });\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Build a map of stepId -> step event for steps that need creation\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Correlation IDs of steps finalized as failed because their arguments\n  // refused to serialize — see finalizeUnserializableStep below.\n  const failedStepCorrelationIds = new Set<string>();\n\n  /**\n   * A step whose arguments fail to serialize is deterministic: every replay\n   * re-derives the same unserializable value, so redelivering the\n   * orchestrator message can never succeed. Instead of rejecting the whole\n   * suspension (which fails the run from the outside, where no user code can\n   * observe it), treat it exactly like a step-body failure: write\n   * `step_created` with a placeholder input (every World requires the step\n   * entity to exist before a terminal step event, and the real input is\n   * precisely what refused to serialize) followed by `step_failed` carrying\n   * the serialization error. The next replay rejects the step's promise with\n   * it, so a try/catch around the step call observes the error; uncaught, it\n   * propagates out of the workflow body and fails the run as a USER_ERROR —\n   * without burning queue redeliveries either way.\n   */\n  const finalizeUnserializableStep = async (\n    queueItem: StepInvocationQueueItem,\n    error: Error\n  ): Promise<void> => {\n    runtimeLogger.warn(\n      'Step arguments failed to serialize; failing the step so the ' +\n        'workflow can observe the error',\n      {\n        workflowRunId: runId,\n        correlationId: queueItem.correlationId,\n        stepName: queueItem.stepName,\n        error: error.message,\n      }\n    );\n    // Marker placeholder (not empty args): byte-identical-to-zero-args would\n    // make `workflow inspect steps` show \"no arguments\" for the one step\n    // whose entire problem was its arguments.\n    const placeholderInput = (await dehydrateStepArguments(\n      unserializableStepInputPlaceholder(),\n      runId,\n      encryptionKey,\n      suspension.globalThis\n    )) as SerializedData;\n    try {\n      await createGuarded(\n        {\n          eventType: 'step_created' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            stepName: queueItem.stepName,\n            workflowName: run.workflowName,\n            input: placeholderInput,\n          },\n        },\n        { requestId }\n      );\n    } catch (createErr) {\n      if (EntityConflictError.is(createErr)) {\n        // A concurrent handler already created the step — the failure is\n        // deterministic, so it is racing toward the same step_failed below.\n        runtimeLogger.info('Step already exists, continuing', {\n          workflowRunId: runId,\n          correlationId: queueItem.correlationId,\n          message: createErr.message,\n        });\n      } else if (RunExpiredError.is(createErr)) {\n        // Run already finished — nothing to observe the failure.\n        return;\n      } else {\n        throw createErr;\n      }\n    }\n    try {\n      await createGuarded(\n        {\n          eventType: 'step_failed' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n          eventData: {\n            stepName: queueItem.stepName,\n            // The message carries the framed serialization hint; the step\n            // consumer rejects the step's promise with a FatalError built\n            // from it, exactly like any other step failure.\n            error: error.message,\n            stack: error.stack,\n          },\n        },\n        { requestId }\n      );\n    } catch (failErr) {\n      if (EntityConflictError.is(failErr) || RunExpiredError.is(failErr)) {\n        // Step already terminal (a concurrent handler wrote the same\n        // deterministic failure) or the run already finished.\n        runtimeLogger.info(\n          'Tried failing step, but step or run has already finished.',\n          {\n            workflowRunId: runId,\n            correlationId: queueItem.correlationId,\n            message: failErr.message,\n          }\n        );\n      } else {\n        throw failErr;\n      }\n    }\n    failedStepCorrelationIds.add(queueItem.correlationId);\n  };\n\n  // Process steps and waits in parallel\n  // Each step: create event (if needed) -> queue message\n  // Each wait: create event (if needed)\n  const ops: Promise<void>[] = [];\n\n  // Steps: create event then queue message, all in parallel\n  for (const queueItem of stepItems) {\n    ops.push(\n      (async () => {\n        // Create step event if not already created\n        if (stepsNeedingCreation.has(queueItem.correlationId)) {\n          let dehydratedInput: Uint8Array | unknown;\n          try {\n            dehydratedInput = await dehydrateStepArguments(\n              {\n                args: queueItem.args,\n                closureVars: queueItem.closureVars,\n                thisVal: queueItem.thisVal,\n              },\n              runId,\n              encryptionKey,\n              suspension.globalThis\n            );\n          } catch (err) {\n            if (RuntimeDecryptionError.is(err)) {\n              // An SDK fault, not a user value problem. Keep its identity\n              // (RUNTIME_ERROR) and current fail-the-suspension behavior.\n              throw err;\n            }\n            // Every other failure out of dehydrateStepArguments is a\n            // serialization failure on the step's own arguments.\n            await finalizeUnserializableStep(\n              queueItem,\n              err instanceof Error ? err : new Error(String(err))\n            );\n            return;\n          }\n          const stepEvent: CreateEventRequest = {\n            eventType: 'step_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              stepName: queueItem.stepName,\n              workflowName: run.workflowName,\n              input: dehydratedInput as SerializedData,\n            },\n          };\n          try {\n            await createGuarded(stepEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Step already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        }\n\n        // Queue step execution message\n        // Serialize trace context once and include in both payload and headers\n        // Payload: for manual context restoration in step handler\n        // Headers: for automatic trace propagation by Vercel's infrastructure\n        const traceCarrier = await serializeTraceCarrier();\n        await queueMessage(\n          world,\n          `__wkf_step_${queueItem.stepName}`,\n          {\n            workflowName,\n            workflowRunId: runId,\n            workflowStartedAt,\n            stepId: queueItem.correlationId,\n            traceCarrier,\n            requestedAt: new Date(),\n          },\n          {\n            idempotencyKey: queueItem.correlationId,\n            headers: {\n              ...extractTraceHeaders(traceCarrier),\n            },\n          }\n        );\n      })()\n    );\n  }\n\n  // Waits: create events in parallel (no queueing needed for waits)\n  for (const queueItem of waitItems) {\n    if (!queueItem.hasCreatedEvent) {\n      ops.push(\n        (async () => {\n          const waitEvent: CreateEventRequest = {\n            eventType: 'wait_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              resumeAt: queueItem.resumeAt,\n            },\n          };\n          try {\n            await createGuarded(waitEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Wait already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  // Await the step_created / wait_created event creates before returning.\n  // The caller (workflowEntrypoint) only enqueues the step-dispatch queue\n  // messages AFTER handleSuspension resolves, and the queue handler acks\n  // the orchestrator message only after the caller resolves. So the step_created\n  // events must be durable here, and the dispatch sends must complete in the caller,\n  // all before ack. If the process crashes before this resolves, the orchestrator\n  // message is not acked and VQS redelivers, re-creates the (idempotent)\n  // step_created and re-dispatches, and recovers the run instead of orphaning it.\n  await Promise.all(ops);\n\n  // Calculate minimum timeout from waits\n  const now = Date.now();\n  const minTimeoutSeconds = waitItems.reduce<number | null>(\n    (min, queueItem) => {\n      const resumeAtMs = queueItem.resumeAt.getTime();\n      const delayMs = Math.max(1000, resumeAtMs - now);\n      const timeoutSeconds = Math.ceil(delayMs / 1000);\n      if (min === null) return timeoutSeconds;\n      return Math.min(min, timeoutSeconds);\n    },\n    null\n  );\n\n  span?.setAttributes({\n    ...Attribute.WorkflowRunStatus('workflow_suspended'),\n    ...Attribute.WorkflowStepsCreated(stepItems.length),\n    ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),\n    ...Attribute.WorkflowWaitsCreated(waitItems.length),\n    ...(failedStepCorrelationIds.size > 0\n      ? Attribute.WorkflowStepsFailedSerialization(\n          failedStepCorrelationIds.size\n        )\n      : {}),\n  });\n\n  // Steps whose arguments failed to serialize were finalized above as\n  // step_created + step_failed (see finalizeUnserializableStep). No\n  // step-execution message is dispatched for them, so when such a step is\n  // the only pending work nothing would ever wake the run again — schedule\n  // an immediate re-invocation. The replay rejects the step's promise with\n  // the serialization error, which a try/catch around the step call\n  // observes; uncaught, it propagates out of the workflow body and fails\n  // the run as a USER_ERROR. Healthy sibling steps were already queued\n  // above, so they execute in parallel invocations regardless.\n  if (failedStepCorrelationIds.size > 0) {\n    return { timeoutSeconds: 0, failedStepCorrelationIds };\n  }\n\n  // If any hook conflicts occurred, re-enqueue the workflow immediately\n  // On the next iteration, the hook consumer will see the hook_conflict event\n  // and reject the promise with a WorkflowRuntimeError\n  // We do this after processing all other operations (steps, waits) to ensure\n  // they are recorded in the event log before the re-execution\n  if (hasHookConflict) {\n    return { timeoutSeconds: 0 };\n  }\n\n  // A `hook.getConflict()` awaiter needs an immediate re-invocation: the\n  // replay consumes the just-committed hook_created and resolves the\n  // awaiter with `null`. Without it the run would sit idle until some\n  // unrelated message woke it. Any pending steps were already queued\n  // above, so they execute in parallel invocations regardless.\n  if (hasAwaitedHookCreation) {\n    return { timeoutSeconds: 0 };\n  }\n\n  if (minTimeoutSeconds !== null) {\n    return { timeoutSeconds: minTimeoutSeconds };\n  }\n\n  return {};\n}\n"]}

package/dist/runtime/unserializable-step.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared shape for finalizing a step whose arguments failed to serialize
+ * (used by both the node:vm suspension handler and the QuickJS entrypoint).
+ *
+ * The world requires a `step_created` before any terminal step event, and
+ * the step's real input is precisely what refused to serialize — so the
+ * finalization writes a placeholder input. The marker string makes the
+ * placeholder distinguishable from a genuine zero-argument step in
+ * `workflow inspect steps` and the observability UI: a reader sees
+ * "input unavailable" instead of "no arguments".
+ */
+export declare const UNSERIALIZABLE_STEP_INPUT_MARKER = "[input unavailable: step argument serialization failed]";
+/**
+ * The placeholder value serialized into the failed step's `step_created`
+ * input. Matches the `{ args, closureVars, thisVal }` triple
+ * `dehydrateStepArguments` / the QuickJS bootstrap produce for real steps,
+ * so every consumer hydrates it uniformly, plus the structural flag the
+ * step executor checks before running user code (see
+ * {@link isUnserializableStepInputPlaceholder}).
+ */
+export declare function unserializableStepInputPlaceholder(): Record<string, unknown>;
+/**
+ * Whether a hydrated step input is the finalization placeholder.
+ *
+ * Finalization writes `step_created` (placeholder) and `step_failed` as two
+ * separate durable writes; a crash or transient failure between them leaves
+ * a pending step whose stored input is the placeholder. Redelivery then
+ * dispatches that step through normal crash recovery — the executor calls
+ * this before running user code and completes the intended failure (a fatal
+ * SerializationError → `step_failed`) instead of silently invoking the step
+ * body with placeholder arguments.
+ */
+export declare function isUnserializableStepInputPlaceholder(hydratedInput: unknown): boolean;
+//# sourceMappingURL=unserializable-step.d.ts.map

package/dist/runtime/unserializable-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unserializable-step.d.ts","sourceRoot":"","sources":["../../src/runtime/unserializable-step.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gCAAgC,4DACc,CAAC;AAU5D;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAO5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oCAAoC,CAClD,aAAa,EAAE,OAAO,GACrB,OAAO,CAMT"}

package/dist/runtime/unserializable-step.js

@@ -0,0 +1,52 @@
+/**
+ * Shared shape for finalizing a step whose arguments failed to serialize
+ * (used by both the node:vm suspension handler and the QuickJS entrypoint).
+ *
+ * The world requires a `step_created` before any terminal step event, and
+ * the step's real input is precisely what refused to serialize — so the
+ * finalization writes a placeholder input. The marker string makes the
+ * placeholder distinguishable from a genuine zero-argument step in
+ * `workflow inspect steps` and the observability UI: a reader sees
+ * "input unavailable" instead of "no arguments".
+ */
+export const UNSERIALIZABLE_STEP_INPUT_MARKER = '[input unavailable: step argument serialization failed]';
+/**
+ * Structural discriminator on the placeholder's top level. The
+ * `{ args, closureVars, thisVal }` triple is built by the SDK — user code
+ * never controls its top-level keys — so this flag cannot false-positive on
+ * a legitimate input, unlike the display marker inside `args`.
+ */
+const UNSERIALIZABLE_FLAG = '__workflowUnserializableStepInput';
+/**
+ * The placeholder value serialized into the failed step's `step_created`
+ * input. Matches the `{ args, closureVars, thisVal }` triple
+ * `dehydrateStepArguments` / the QuickJS bootstrap produce for real steps,
+ * so every consumer hydrates it uniformly, plus the structural flag the
+ * step executor checks before running user code (see
+ * {@link isUnserializableStepInputPlaceholder}).
+ */
+export function unserializableStepInputPlaceholder() {
+    return {
+        args: [UNSERIALIZABLE_STEP_INPUT_MARKER],
+        closureVars: [],
+        thisVal: undefined,
+        [UNSERIALIZABLE_FLAG]: true,
+    };
+}
+/**
+ * Whether a hydrated step input is the finalization placeholder.
+ *
+ * Finalization writes `step_created` (placeholder) and `step_failed` as two
+ * separate durable writes; a crash or transient failure between them leaves
+ * a pending step whose stored input is the placeholder. Redelivery then
+ * dispatches that step through normal crash recovery — the executor calls
+ * this before running user code and completes the intended failure (a fatal
+ * SerializationError → `step_failed`) instead of silently invoking the step
+ * body with placeholder arguments.
+ */
+export function isUnserializableStepInputPlaceholder(hydratedInput) {
+    return (typeof hydratedInput === 'object' &&
+        hydratedInput !== null &&
+        hydratedInput[UNSERIALIZABLE_FLAG] === true);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization.d.ts

@@ -56,6 +56,12 @@ export declare function decodeFormatPrefix(data: Uint8Array | unknown): {
     format: SerializationFormatType;
     payload: Uint8Array;
 };
+/**
+ * Format a serialization error with context about what failed.
+ * Extracts path, value, and reason from devalue's DevalueError when available.
+ * Logs the problematic value to the console for better debugging.
+ */
+export declare function formatSerializationError(context: string, error: unknown): string;
 /**
  * Detect if a readable stream is a byte stream.
  *
@@ -135,14 +141,22 @@ export declare const FRAMED_STREAM_MAX_TOTAL_RECONNECTS = 1000;
  * bytes buffered before the cut are discarded — the server will resend the
  * in-flight chunk in full from the new startIndex.
  *
- * A clean upstream close (EOF with no error) signals the stream is truly
- * done; we close the wrapper and do not reconnect.
+ * A clean upstream close (EOF with no error) is NOT trusted as completion
+ * on its own: some transport paths normalize a mid-stream abort into a
+ * graceful end (observed in production on Vercel response streaming, where
+ * the server's max-duration abort arrives at the client as a clean EOF).
+ * On EOF the wrapper verifies against the stream's authoritative metadata
+ * (`getStreamInfo`) that the stream is complete AND that every chunk up to
+ * `done` was delivered; otherwise it reconnects from the next chunk exactly
+ * like an errored connection. If the metadata read itself fails, the EOF is
+ * trusted (legacy behavior) rather than failing a read that may well be
+ * complete.
  *
  * Negative `startIndex` values (last-N semantics) skip the reconnect
  * machinery because we cannot compute an absolute resume position without
  * a tail-index lookup — the returned stream behaves as a single-shot read.
  */
-export declare function createReconnectingFramedStream(name: string, startIndex?: number): ReadableStream<Uint8Array>;
+export declare function createReconnectingFramedStream(runId: string, name: string, startIndex?: number): ReadableStream<Uint8Array>;
 export declare class WorkflowServerWritableStream extends WritableStream<Uint8Array> {
     constructor(name: string, runId: string);
 }

package/dist/serialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"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"}