@workflow/core 5.0.0-beta.2 → 5.0.0-beta.21

package/dist/private.d.ts

@@ -5,6 +5,7 @@ import type { CryptoKey } from './encryption.js';
 import type { EventsConsumer } from './events-consumer.js';
 import type { QueueItem } from './global.js';
 import type { Serializable } from './schemas.js';
+import type { StepHydrationCache } from './step-hydration-cache.js';
 export type StepFunction<Args extends Serializable[] = any[], Result extends Serializable | unknown = unknown> = ((...args: Args) => Promise<Result>) & {
     maxRetries?: number;
     stepId?: string;
@@ -46,11 +47,102 @@ export interface WorkflowOrchestratorContext {
     promiseQueue: Promise<void>;
     /**
      * Counter of in-flight async data delivery operations (step result
-     * hydration, hook payload hydration). Suspensions must wait for this
-     * to reach 0 before firing, to avoid preempting data delivery.
+     * hydration, hook payload hydration, abort signal hydration). Suspensions
+     * must wait for this to reach 0 before firing, to avoid preempting data
+     * delivery — e.g. dehydrating a step's arguments while an abort that should
+     * be reflected in those arguments is still hydrating its reason.
      */
     pendingDeliveries: number;
+    /**
+     * Ordered registry of in-flight "branch-deciding" deliveries — the
+     * resolutions a workflow typically `Promise.race`s on: buffered hook
+     * payloads (`hook_received`) and wait completions (`wait_completed`).
+     * Keyed by the delivery's position (index) in the consumed event log.
+     *
+     * The problem: a buffered hook payload is observed via the async hook
+     * iterator (`yield await this`), costing extra microtask hops, while a
+     * `wait_completed` resolves with fewer hops — and a reused sleep can
+     * resolve in an entirely earlier loop iteration. Either way, the
+     * resolution that the committed event log ordered first can lose a
+     * `Promise.race` to a faster- or already-resolved competitor, diverging
+     * from the log and surfacing as `CorruptedEventLogError`.
+     *
+     * The fix is a strict, deterministic delivery order anchored on
+     * event-log position: a delivery does not resolve to the workflow until
+     * every earlier-in-log delivery of the OPPOSITE kind has been delivered.
+     * (Opposite kind only: sequential same-kind hook payloads must not block
+     * one another, and a wait need not wait behind a later wait.) Because the
+     * gate is "the earlier delivery resolved", not "won a timing race", the
+     * outcome is independent of microtask hops, hydration/decryption time,
+     * and `Promise.race` argument order.
+     *
+     * Index is used rather than the `eventId` string because `eventId` is an
+     * opaque, world-assigned value not guaranteed to sort in creation order
+     * (only the bundled ULID worlds happen to).
+     *
+     * Optional so older/out-of-tree contexts (and lightweight test harnesses)
+     * that do not initialize it degrade gracefully to the previous behavior.
+     */
+    pendingDeliveryBarriers?: Map<number, DeliveryBarrierEntry>;
+    /**
+     * Per-run memoization cache for hydrated step return values, keyed by the
+     * `step_completed` event id. Owned by the inline replay loop in `runtime.ts`
+     * and threaded through each `runWorkflow` call so it survives across replay
+     * iterations of the SAME run (a fresh context is created each iteration) but
+     * never leaks across unrelated runs.
+     *
+     * On replay K of a sequential N-step workflow, the step consumer would
+     * otherwise re-decrypt and re-parse the results of all K already-completed
+     * steps — O(N²) across an invocation. This cache makes a completed step's
+     * result available in O(1) on subsequent replays. Only primitive results are
+     * memoized, so a shared reference can never let one replay's mutation leak
+     * into the next; see `step-hydration-cache.ts` for the full rationale.
+     *
+     * Optional so contexts that do not initialize it (test harnesses) degrade
+     * gracefully to re-hydrating every replay — identical to previous behavior.
+     */
+    stepHydrationCache?: StepHydrationCache;
+}
+/** The kind of branch-deciding delivery a barrier represents. */
+export type DeliveryKind = 'hook' | 'wait';
+interface DeliveryBarrierEntry {
+    kind: DeliveryKind;
+    /** Resolves once this delivery has resolved to the workflow. */
+    delivered: Promise<void>;
 }
+/**
+ * Awaits, in strict event-log order, every still-registered delivery whose
+ * index is earlier than `eventIndex` AND whose kind is in `deferBehindKinds`,
+ * so that this resolution is handed to the workflow only after all relevant
+ * earlier-in-log deliveries have been. This is what keeps a `Promise.race`
+ * deterministic and aligned with the committed event log, independent of
+ * microtask-hop counts, hydration time, or race-argument order.
+ *
+ * `deferBehindKinds` is the opposite kind(s): a hook defers behind earlier
+ * WAITS (not earlier hooks — those are sequential same-entity payloads), a
+ * wait defers behind earlier HOOKS.
+ */
+export declare function awaitEarlierDeliveries(ctx: WorkflowOrchestratorContext, eventIndex: number | undefined, deferBehindKinds: readonly DeliveryKind[]): Promise<void>;
+/** Handle for a registered branch-deciding delivery barrier. */
+export interface DeliveryBarrier {
+    /**
+     * Mark this delivery as delivered to the workflow. Resolves its
+     * `delivered` promise so any later-in-log opposite-kind delivery gated on
+     * it (via {@link awaitEarlierDeliveries}) may proceed, and removes it from
+     * the registry. Idempotent.
+     */
+    markDelivered: () => void;
+}
+/**
+ * Register a branch-deciding delivery at its event-log index so that later
+ * opposite-kind deliveries can be ordered strictly after it. Returns an inert
+ * handle when `pendingDeliveryBarriers` is not initialized.
+ *
+ * To guarantee a later delivery gated on this one can never hang when this
+ * delivery is abandoned (the workflow took a different branch or is
+ * suspending and never observes it), the barrier auto-resolves at idle.
+ */
+export declare function registerDeliveryBarrier(ctx: WorkflowOrchestratorContext, eventIndex: number | undefined, kind: DeliveryKind): DeliveryBarrier;
 /**
  * Schedule a callback to fire only after all pending data deliveries
  * (step results, hook payloads) and async deserialization have completed.
@@ -58,6 +150,19 @@ export interface WorkflowOrchestratorContext {
  * if > 0, wait for promiseQueue → repeat. This handles the multi-round
  * delivery pattern where each hook payload delivery cycle appends new
  * async work to the promiseQueue.
+ *
+ * The initial `setTimeout(0)` macrotask is load-bearing and must NOT be
+ * downgraded to a microtask (`queueMicrotask`/`Promise.resolve().then`).
+ * `pendingDeliveries` only guards the host-side hydration window; between a
+ * delivery's `resolve()` and the workflow VM body running its continuation to
+ * register the next subscriber, `pendingDeliveries` is already 0 even though
+ * the VM is mid-reaction. Node does not guarantee a microtask scheduled in
+ * the host context settles after the cross-VM promise chain (resolve in host
+ * → workflow code in VM → subscribe back in host); the macrotask boundary
+ * gives that chain time to run, so the suspension does not preempt a sibling
+ * delivery still in flight. Empirically, replacing it with `queueMicrotask`
+ * breaks hook/sleep `Promise.race` ordering (CorruptedEventLogError).
  */
 export declare function scheduleWhenIdle(ctx: WorkflowOrchestratorContext, fn: () => void): void;
+export {};
 //# sourceMappingURL=private.d.ts.map

package/dist/private.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private.d.ts","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,MAAM,YAAY,CACtB,IAAI,SAAS,YAAY,EAAE,GAAG,GAAG,EAAE,EACnC,MAAM,SAAS,YAAY,GAAG,OAAO,GAAG,OAAO,IAC7C,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAsEF;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAGxE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAoBxE;AAOD,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC;IACrC,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,cAAc,EAAE,cAAc,CAAC;IAC/B;;;OAGG;IACH,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACzC,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACxC,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,2BAA2B,EAChC,EAAE,EAAE,MAAM,IAAI,GACb,IAAI,CAYN"}
+{"version":3,"file":"private.d.ts","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,MAAM,MAAM,YAAY,CACtB,IAAI,SAAS,YAAY,EAAE,GAAG,GAAG,EAAE,EACnC,MAAM,SAAS,YAAY,GAAG,OAAO,GAAG,OAAO,IAC7C,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAsEF;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,QAGxE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAoBxE;AAOD,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC;IACrC,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,cAAc,EAAE,cAAc,CAAC;IAC/B;;;OAGG;IACH,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACzC,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACxC,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B;;;;;;OAMG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,uBAAuB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC5D;;;;;;;;;;;;;;;;OAgBG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3C,UAAU,oBAAoB;IAC5B,IAAI,EAAE,YAAY,CAAC;IACnB,gEAAgE;IAChE,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,2BAA2B,EAChC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,gBAAgB,EAAE,SAAS,YAAY,EAAE,GACxC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,aAAa,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,2BAA2B,EAChC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,IAAI,EAAE,YAAY,GACjB,eAAe,CA6BjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,2BAA2B,EAChC,EAAE,EAAE,MAAM,IAAI,GACb,IAAI,CAYN"}

package/dist/private.js

@@ -1,11 +1,12 @@
 /**
  * Utils used by the bundler when transforming code
  */
+import { withResolvers } from '@workflow/utils';
 const RegisteredStepsKey = Symbol.for('@workflow/core//registeredSteps');
 const globalSymbols = globalThis;
 // biome-ignore lint/suspicious/noAssignInExpressions: /
 const registeredSteps = (globalSymbols[RegisteredStepsKey] ??= new Map());
-const BUILTIN_STEP_NAMES = new Set([
+const BUILTIN_RESPONSE_STEP_NAMES = new Set([
     '__builtin_response_array_buffer',
     '__builtin_response_json',
     '__builtin_response_text',
@@ -41,7 +42,7 @@ function getStepIdAliasCandidates(stepId) {
     return Array.from(modulePathAliases, (aliasModulePath) => `step//${aliasModulePath}//${fnName}`);
 }
 function getBuiltinResponseStepAlias(stepId) {
-    if (!BUILTIN_STEP_NAMES.has(stepId)) {
+    if (!BUILTIN_RESPONSE_STEP_NAMES.has(stepId)) {
         return undefined;
     }
     for (const [registeredStepId, stepFn] of registeredSteps.entries()) {
@@ -85,6 +86,70 @@ export function getStepFunction(stepId) {
     }
     return undefined;
 }
+/**
+ * Awaits, in strict event-log order, every still-registered delivery whose
+ * index is earlier than `eventIndex` AND whose kind is in `deferBehindKinds`,
+ * so that this resolution is handed to the workflow only after all relevant
+ * earlier-in-log deliveries have been. This is what keeps a `Promise.race`
+ * deterministic and aligned with the committed event log, independent of
+ * microtask-hop counts, hydration time, or race-argument order.
+ *
+ * `deferBehindKinds` is the opposite kind(s): a hook defers behind earlier
+ * WAITS (not earlier hooks — those are sequential same-entity payloads), a
+ * wait defers behind earlier HOOKS.
+ */
+export async function awaitEarlierDeliveries(ctx, eventIndex, deferBehindKinds) {
+    // Defensive: tolerate contexts that predate this field (test harnesses).
+    if (eventIndex === undefined ||
+        !ctx.pendingDeliveryBarriers ||
+        ctx.pendingDeliveryBarriers.size === 0) {
+        return;
+    }
+    const earlier = [];
+    for (const [index, entry] of ctx.pendingDeliveryBarriers) {
+        if (index < eventIndex && deferBehindKinds.includes(entry.kind)) {
+            earlier.push(entry.delivered);
+        }
+    }
+    if (earlier.length > 0) {
+        await Promise.all(earlier);
+    }
+}
+/**
+ * Register a branch-deciding delivery at its event-log index so that later
+ * opposite-kind deliveries can be ordered strictly after it. Returns an inert
+ * handle when `pendingDeliveryBarriers` is not initialized.
+ *
+ * To guarantee a later delivery gated on this one can never hang when this
+ * delivery is abandoned (the workflow took a different branch or is
+ * suspending and never observes it), the barrier auto-resolves at idle.
+ */
+export function registerDeliveryBarrier(ctx, eventIndex, kind) {
+    const barriers = ctx.pendingDeliveryBarriers;
+    if (!barriers || eventIndex === undefined) {
+        return { markDelivered: () => { } };
+    }
+    let done = false;
+    const { promise, resolve } = withResolvers();
+    const entry = { kind, delivered: promise };
+    barriers.set(eventIndex, entry);
+    const finish = () => {
+        if (done) {
+            return;
+        }
+        done = true;
+        if (barriers.get(eventIndex) === entry) {
+            barriers.delete(eventIndex);
+        }
+        resolve();
+    };
+    // Safety net: if this delivery is never delivered to the workflow (its
+    // branch was not taken / the run is suspending), resolve at idle so a
+    // later opposite-kind delivery gated on it cannot deadlock and the
+    // registry cannot leak an entry per abandoned delivery.
+    scheduleWhenIdle(ctx, finish);
+    return { markDelivered: finish };
+}
 /**
  * Schedule a callback to fire only after all pending data deliveries
  * (step results, hook payloads) and async deserialization have completed.
@@ -92,6 +157,18 @@ export function getStepFunction(stepId) {
  * if > 0, wait for promiseQueue → repeat. This handles the multi-round
  * delivery pattern where each hook payload delivery cycle appends new
  * async work to the promiseQueue.
+ *
+ * The initial `setTimeout(0)` macrotask is load-bearing and must NOT be
+ * downgraded to a microtask (`queueMicrotask`/`Promise.resolve().then`).
+ * `pendingDeliveries` only guards the host-side hydration window; between a
+ * delivery's `resolve()` and the workflow VM body running its continuation to
+ * register the next subscriber, `pendingDeliveries` is already 0 even though
+ * the VM is mid-reaction. Node does not guarantee a microtask scheduled in
+ * the host context settles after the cross-VM promise chain (resolve in host
+ * → workflow code in VM → subscribe back in host); the macrotask boundary
+ * gives that chain time to run, so the suspension does not preempt a sibling
+ * delivery still in flight. Empirically, replacing it with `queueMicrotask`
+ * breaks hook/sleep `Promise.race` ordering (CorruptedEventLogError).
  */
 export function scheduleWhenIdle(ctx, fn) {
     const check = () => {
@@ -107,4 +184,4 @@ export function scheduleWhenIdle(ctx, fn) {
     };
     setTimeout(check, 0);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"private.js","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Utils used by the bundler when transforming code\n */\n\nimport type { CryptoKey } from './encryption.js';\nimport type { EventsConsumer } from './events-consumer.js';\nimport type { QueueItem } from './global.js';\nimport type { Serializable } from './schemas.js';\n\nexport type StepFunction<\n  Args extends Serializable[] = any[],\n  Result extends Serializable | unknown = unknown,\n> = ((...args: Args) => Promise<Result>) & {\n  maxRetries?: number;\n  stepId?: string;\n};\n\nconst RegisteredStepsKey = Symbol.for('@workflow/core//registeredSteps');\n\nconst globalSymbols: typeof globalThis & {\n  [RegisteredStepsKey]?: Map<string, StepFunction>;\n} = globalThis;\n\n// biome-ignore lint/suspicious/noAssignInExpressions: /\nconst registeredSteps = (globalSymbols[RegisteredStepsKey] ??= new Map<\n  string,\n  StepFunction\n>());\n\nconst BUILTIN_STEP_NAMES = new Set([\n  '__builtin_response_array_buffer',\n  '__builtin_response_json',\n  '__builtin_response_text',\n]);\n\nfunction getStepIdAliasCandidates(stepId: string): string[] {\n  const parts = stepId.split('//');\n  if (parts.length !== 3 || parts[0] !== 'step') {\n    return [];\n  }\n\n  const modulePath = parts[1];\n  const fnName = parts[2];\n  const modulePathAliases = new Set<string>();\n\n  const addAlias = (aliasModulePath: string) => {\n    if (aliasModulePath !== modulePath) {\n      modulePathAliases.add(aliasModulePath);\n    }\n  };\n\n  if (modulePath.startsWith('./workflows/')) {\n    const workflowRelativePath = modulePath.slice('./'.length);\n    addAlias(`./example/${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./example/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./example/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./src/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./src/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./example/${workflowRelativePath}`);\n  }\n\n  return Array.from(\n    modulePathAliases,\n    (aliasModulePath) => `step//${aliasModulePath}//${fnName}`\n  );\n}\n\nfunction getBuiltinResponseStepAlias(stepId: string): StepFunction | undefined {\n  if (!BUILTIN_STEP_NAMES.has(stepId)) {\n    return undefined;\n  }\n\n  for (const [registeredStepId, stepFn] of registeredSteps.entries()) {\n    if (registeredStepId.endsWith(`//${stepId}`)) {\n      return stepFn;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Register a step function to be served in the server bundle.\n * Also sets the stepId property on the function for serialization support.\n *\n * Note: The SWC compiler plugin no longer generates calls to this function.\n * Step registration is now inlined as a self-contained IIFE that writes\n * directly to the global Map at Symbol.for(\"@workflow/core//registeredSteps\").\n * This function is kept for internal/test use only.\n */\nexport function registerStepFunction(stepId: string, stepFn: StepFunction) {\n  registeredSteps.set(stepId, stepFn);\n  stepFn.stepId = stepId;\n}\n\n/**\n * Find a registered step function by name\n */\nexport function getStepFunction(stepId: string): StepFunction | undefined {\n  const directMatch = registeredSteps.get(stepId);\n  if (directMatch) {\n    return directMatch;\n  }\n\n  // Support equivalent workflow path aliases in mixed symlink environments.\n  for (const aliasStepId of getStepIdAliasCandidates(stepId)) {\n    const aliasMatch = registeredSteps.get(aliasStepId);\n    if (aliasMatch) {\n      return aliasMatch;\n    }\n  }\n\n  const builtinAliasMatch = getBuiltinResponseStepAlias(stepId);\n  if (builtinAliasMatch) {\n    return builtinAliasMatch;\n  }\n\n  return undefined;\n}\n\n// Note: __private_getClosureVars is no longer re-exported here.\n// The SWC compiler plugin now inlines closure variable access as a\n// self-contained IIFE that reads directly from the global AsyncLocalStorage\n// at Symbol.for(\"WORKFLOW_STEP_CONTEXT_STORAGE\").\n\nexport interface WorkflowOrchestratorContext {\n  runId: string;\n  encryptionKey: CryptoKey | undefined;\n  globalThis: typeof globalThis;\n  eventsConsumer: EventsConsumer;\n  /**\n   * Map of pending invocations keyed by correlationId.\n   * Using Map instead of Array for O(1) lookup/delete operations.\n   */\n  invocationsQueue: Map<string, QueueItem>;\n  onWorkflowError: (error: Error) => void;\n  generateUlid: () => string;\n  generateNanoid: () => string;\n  /**\n   * Sequential promise queue that ensures all event-driven promise resolutions\n   * (step results, hook payloads, failures, suspensions) happen in event log\n   * order. Every resolve, reject, or workflow error is chained through this\n   * queue so that even if individual operations take variable time (e.g.,\n   * async decryption), promises resolve deterministically.\n   */\n  promiseQueue: Promise<void>;\n  /**\n   * Counter of in-flight async data delivery operations (step result\n   * hydration, hook payload hydration). Suspensions must wait for this\n   * to reach 0 before firing, to avoid preempting data delivery.\n   */\n  pendingDeliveries: number;\n}\n\n/**\n * Schedule a callback to fire only after all pending data deliveries\n * (step results, hook payloads) and async deserialization have completed.\n * Uses a polling loop: setTimeout(0) → check pendingDeliveries →\n * if > 0, wait for promiseQueue → repeat. This handles the multi-round\n * delivery pattern where each hook payload delivery cycle appends new\n * async work to the promiseQueue.\n */\nexport function scheduleWhenIdle(\n  ctx: WorkflowOrchestratorContext,\n  fn: () => void\n): void {\n  const check = () => {\n    if (ctx.pendingDeliveries > 0) {\n      // Still delivering data — wait for queue to drain, then re-check\n      ctx.promiseQueue.then(() => {\n        setTimeout(check, 0);\n      });\n    } else {\n      fn();\n    }\n  };\n  setTimeout(check, 0);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"private.js","sourceRoot":"","sources":["../src/private.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Utils used by the bundler when transforming code\n */\n\nimport { withResolvers } from '@workflow/utils';\nimport type { CryptoKey } from './encryption.js';\nimport type { EventsConsumer } from './events-consumer.js';\nimport type { QueueItem } from './global.js';\nimport type { Serializable } from './schemas.js';\nimport type { StepHydrationCache } from './step-hydration-cache.js';\n\nexport type StepFunction<\n  Args extends Serializable[] = any[],\n  Result extends Serializable | unknown = unknown,\n> = ((...args: Args) => Promise<Result>) & {\n  maxRetries?: number;\n  stepId?: string;\n};\n\nconst RegisteredStepsKey = Symbol.for('@workflow/core//registeredSteps');\n\nconst globalSymbols: typeof globalThis & {\n  [RegisteredStepsKey]?: Map<string, StepFunction>;\n} = globalThis;\n\n// biome-ignore lint/suspicious/noAssignInExpressions: /\nconst registeredSteps = (globalSymbols[RegisteredStepsKey] ??= new Map<\n  string,\n  StepFunction\n>());\n\nconst BUILTIN_RESPONSE_STEP_NAMES = new Set([\n  '__builtin_response_array_buffer',\n  '__builtin_response_json',\n  '__builtin_response_text',\n]);\n\nfunction getStepIdAliasCandidates(stepId: string): string[] {\n  const parts = stepId.split('//');\n  if (parts.length !== 3 || parts[0] !== 'step') {\n    return [];\n  }\n\n  const modulePath = parts[1];\n  const fnName = parts[2];\n  const modulePathAliases = new Set<string>();\n\n  const addAlias = (aliasModulePath: string) => {\n    if (aliasModulePath !== modulePath) {\n      modulePathAliases.add(aliasModulePath);\n    }\n  };\n\n  if (modulePath.startsWith('./workflows/')) {\n    const workflowRelativePath = modulePath.slice('./'.length);\n    addAlias(`./example/${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./example/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./example/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./src/${workflowRelativePath}`);\n  } else if (modulePath.startsWith('./src/workflows/')) {\n    const workflowRelativePath = modulePath.slice('./src/'.length);\n    addAlias(`./${workflowRelativePath}`);\n    addAlias(`./example/${workflowRelativePath}`);\n  }\n\n  return Array.from(\n    modulePathAliases,\n    (aliasModulePath) => `step//${aliasModulePath}//${fnName}`\n  );\n}\n\nfunction getBuiltinResponseStepAlias(stepId: string): StepFunction | undefined {\n  if (!BUILTIN_RESPONSE_STEP_NAMES.has(stepId)) {\n    return undefined;\n  }\n\n  for (const [registeredStepId, stepFn] of registeredSteps.entries()) {\n    if (registeredStepId.endsWith(`//${stepId}`)) {\n      return stepFn;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Register a step function to be served in the server bundle.\n * Also sets the stepId property on the function for serialization support.\n *\n * Note: The SWC compiler plugin no longer generates calls to this function.\n * Step registration is now inlined as a self-contained IIFE that writes\n * directly to the global Map at Symbol.for(\"@workflow/core//registeredSteps\").\n * This function is kept for internal/test use only.\n */\nexport function registerStepFunction(stepId: string, stepFn: StepFunction) {\n  registeredSteps.set(stepId, stepFn);\n  stepFn.stepId = stepId;\n}\n\n/**\n * Find a registered step function by name\n */\nexport function getStepFunction(stepId: string): StepFunction | undefined {\n  const directMatch = registeredSteps.get(stepId);\n  if (directMatch) {\n    return directMatch;\n  }\n\n  // Support equivalent workflow path aliases in mixed symlink environments.\n  for (const aliasStepId of getStepIdAliasCandidates(stepId)) {\n    const aliasMatch = registeredSteps.get(aliasStepId);\n    if (aliasMatch) {\n      return aliasMatch;\n    }\n  }\n\n  const builtinAliasMatch = getBuiltinResponseStepAlias(stepId);\n  if (builtinAliasMatch) {\n    return builtinAliasMatch;\n  }\n\n  return undefined;\n}\n\n// Note: __private_getClosureVars is no longer re-exported here.\n// The SWC compiler plugin now inlines closure variable access as a\n// self-contained IIFE that reads directly from the global AsyncLocalStorage\n// at Symbol.for(\"WORKFLOW_STEP_CONTEXT_STORAGE\").\n\nexport interface WorkflowOrchestratorContext {\n  runId: string;\n  encryptionKey: CryptoKey | undefined;\n  globalThis: typeof globalThis;\n  eventsConsumer: EventsConsumer;\n  /**\n   * Map of pending invocations keyed by correlationId.\n   * Using Map instead of Array for O(1) lookup/delete operations.\n   */\n  invocationsQueue: Map<string, QueueItem>;\n  onWorkflowError: (error: Error) => void;\n  generateUlid: () => string;\n  generateNanoid: () => string;\n  /**\n   * Sequential promise queue that ensures all event-driven promise resolutions\n   * (step results, hook payloads, failures, suspensions) happen in event log\n   * order. Every resolve, reject, or workflow error is chained through this\n   * queue so that even if individual operations take variable time (e.g.,\n   * async decryption), promises resolve deterministically.\n   */\n  promiseQueue: Promise<void>;\n  /**\n   * Counter of in-flight async data delivery operations (step result\n   * hydration, hook payload hydration, abort signal hydration). Suspensions\n   * must wait for this to reach 0 before firing, to avoid preempting data\n   * delivery — e.g. dehydrating a step's arguments while an abort that should\n   * be reflected in those arguments is still hydrating its reason.\n   */\n  pendingDeliveries: number;\n  /**\n   * Ordered registry of in-flight \"branch-deciding\" deliveries — the\n   * resolutions a workflow typically `Promise.race`s on: buffered hook\n   * payloads (`hook_received`) and wait completions (`wait_completed`).\n   * Keyed by the delivery's position (index) in the consumed event log.\n   *\n   * The problem: a buffered hook payload is observed via the async hook\n   * iterator (`yield await this`), costing extra microtask hops, while a\n   * `wait_completed` resolves with fewer hops — and a reused sleep can\n   * resolve in an entirely earlier loop iteration. Either way, the\n   * resolution that the committed event log ordered first can lose a\n   * `Promise.race` to a faster- or already-resolved competitor, diverging\n   * from the log and surfacing as `CorruptedEventLogError`.\n   *\n   * The fix is a strict, deterministic delivery order anchored on\n   * event-log position: a delivery does not resolve to the workflow until\n   * every earlier-in-log delivery of the OPPOSITE kind has been delivered.\n   * (Opposite kind only: sequential same-kind hook payloads must not block\n   * one another, and a wait need not wait behind a later wait.) Because the\n   * gate is \"the earlier delivery resolved\", not \"won a timing race\", the\n   * outcome is independent of microtask hops, hydration/decryption time,\n   * and `Promise.race` argument order.\n   *\n   * Index is used rather than the `eventId` string because `eventId` is an\n   * opaque, world-assigned value not guaranteed to sort in creation order\n   * (only the bundled ULID worlds happen to).\n   *\n   * Optional so older/out-of-tree contexts (and lightweight test harnesses)\n   * that do not initialize it degrade gracefully to the previous behavior.\n   */\n  pendingDeliveryBarriers?: Map<number, DeliveryBarrierEntry>;\n  /**\n   * Per-run memoization cache for hydrated step return values, keyed by the\n   * `step_completed` event id. Owned by the inline replay loop in `runtime.ts`\n   * and threaded through each `runWorkflow` call so it survives across replay\n   * iterations of the SAME run (a fresh context is created each iteration) but\n   * never leaks across unrelated runs.\n   *\n   * On replay K of a sequential N-step workflow, the step consumer would\n   * otherwise re-decrypt and re-parse the results of all K already-completed\n   * steps — O(N²) across an invocation. This cache makes a completed step's\n   * result available in O(1) on subsequent replays. Only primitive results are\n   * memoized, so a shared reference can never let one replay's mutation leak\n   * into the next; see `step-hydration-cache.ts` for the full rationale.\n   *\n   * Optional so contexts that do not initialize it (test harnesses) degrade\n   * gracefully to re-hydrating every replay — identical to previous behavior.\n   */\n  stepHydrationCache?: StepHydrationCache;\n}\n\n/** The kind of branch-deciding delivery a barrier represents. */\nexport type DeliveryKind = 'hook' | 'wait';\n\ninterface DeliveryBarrierEntry {\n  kind: DeliveryKind;\n  /** Resolves once this delivery has resolved to the workflow. */\n  delivered: Promise<void>;\n}\n\n/**\n * Awaits, in strict event-log order, every still-registered delivery whose\n * index is earlier than `eventIndex` AND whose kind is in `deferBehindKinds`,\n * so that this resolution is handed to the workflow only after all relevant\n * earlier-in-log deliveries have been. This is what keeps a `Promise.race`\n * deterministic and aligned with the committed event log, independent of\n * microtask-hop counts, hydration time, or race-argument order.\n *\n * `deferBehindKinds` is the opposite kind(s): a hook defers behind earlier\n * WAITS (not earlier hooks — those are sequential same-entity payloads), a\n * wait defers behind earlier HOOKS.\n */\nexport async function awaitEarlierDeliveries(\n  ctx: WorkflowOrchestratorContext,\n  eventIndex: number | undefined,\n  deferBehindKinds: readonly DeliveryKind[]\n): Promise<void> {\n  // Defensive: tolerate contexts that predate this field (test harnesses).\n  if (\n    eventIndex === undefined ||\n    !ctx.pendingDeliveryBarriers ||\n    ctx.pendingDeliveryBarriers.size === 0\n  ) {\n    return;\n  }\n  const earlier: Promise<void>[] = [];\n  for (const [index, entry] of ctx.pendingDeliveryBarriers) {\n    if (index < eventIndex && deferBehindKinds.includes(entry.kind)) {\n      earlier.push(entry.delivered);\n    }\n  }\n  if (earlier.length > 0) {\n    await Promise.all(earlier);\n  }\n}\n\n/** Handle for a registered branch-deciding delivery barrier. */\nexport interface DeliveryBarrier {\n  /**\n   * Mark this delivery as delivered to the workflow. Resolves its\n   * `delivered` promise so any later-in-log opposite-kind delivery gated on\n   * it (via {@link awaitEarlierDeliveries}) may proceed, and removes it from\n   * the registry. Idempotent.\n   */\n  markDelivered: () => void;\n}\n\n/**\n * Register a branch-deciding delivery at its event-log index so that later\n * opposite-kind deliveries can be ordered strictly after it. Returns an inert\n * handle when `pendingDeliveryBarriers` is not initialized.\n *\n * To guarantee a later delivery gated on this one can never hang when this\n * delivery is abandoned (the workflow took a different branch or is\n * suspending and never observes it), the barrier auto-resolves at idle.\n */\nexport function registerDeliveryBarrier(\n  ctx: WorkflowOrchestratorContext,\n  eventIndex: number | undefined,\n  kind: DeliveryKind\n): DeliveryBarrier {\n  const barriers = ctx.pendingDeliveryBarriers;\n  if (!barriers || eventIndex === undefined) {\n    return { markDelivered: () => {} };\n  }\n\n  let done = false;\n  const { promise, resolve } = withResolvers<void>();\n  const entry: DeliveryBarrierEntry = { kind, delivered: promise };\n  barriers.set(eventIndex, entry);\n\n  const finish = () => {\n    if (done) {\n      return;\n    }\n    done = true;\n    if (barriers.get(eventIndex) === entry) {\n      barriers.delete(eventIndex);\n    }\n    resolve();\n  };\n\n  // Safety net: if this delivery is never delivered to the workflow (its\n  // branch was not taken / the run is suspending), resolve at idle so a\n  // later opposite-kind delivery gated on it cannot deadlock and the\n  // registry cannot leak an entry per abandoned delivery.\n  scheduleWhenIdle(ctx, finish);\n\n  return { markDelivered: finish };\n}\n\n/**\n * Schedule a callback to fire only after all pending data deliveries\n * (step results, hook payloads) and async deserialization have completed.\n * Uses a polling loop: setTimeout(0) → check pendingDeliveries →\n * if > 0, wait for promiseQueue → repeat. This handles the multi-round\n * delivery pattern where each hook payload delivery cycle appends new\n * async work to the promiseQueue.\n *\n * The initial `setTimeout(0)` macrotask is load-bearing and must NOT be\n * downgraded to a microtask (`queueMicrotask`/`Promise.resolve().then`).\n * `pendingDeliveries` only guards the host-side hydration window; between a\n * delivery's `resolve()` and the workflow VM body running its continuation to\n * register the next subscriber, `pendingDeliveries` is already 0 even though\n * the VM is mid-reaction. Node does not guarantee a microtask scheduled in\n * the host context settles after the cross-VM promise chain (resolve in host\n * → workflow code in VM → subscribe back in host); the macrotask boundary\n * gives that chain time to run, so the suspension does not preempt a sibling\n * delivery still in flight. Empirically, replacing it with `queueMicrotask`\n * breaks hook/sleep `Promise.race` ordering (CorruptedEventLogError).\n */\nexport function scheduleWhenIdle(\n  ctx: WorkflowOrchestratorContext,\n  fn: () => void\n): void {\n  const check = () => {\n    if (ctx.pendingDeliveries > 0) {\n      // Still delivering data — wait for queue to drain, then re-check\n      ctx.promiseQueue.then(() => {\n        setTimeout(check, 0);\n      });\n    } else {\n      fn();\n    }\n  };\n  setTimeout(check, 0);\n}\n"]}

package/dist/runtime/constants.d.ts

@@ -1,4 +1,125 @@
 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;
+/**
+ * Default maximum number of steps the owned-inline path runs inline (in
+ * parallel) per suspension. The rest are queued to background handlers. Each
+ * inline step is created lazily — its `step_created` is folded into the
+ * `step_started` that `executeStep` sends — so inlining N steps saves N queue
+ * round-trips for a `Promise.all`-style fan-out. `1` reproduces the
+ * single-inline-step behavior exactly (useful kill-switch).
+ *
+ * Override via `WORKFLOW_MAX_INLINE_STEPS` (clamped to
+ * `MIN_MAX_INLINE_STEPS`..`MAX_MAX_INLINE_STEPS`).
+ */
+export declare const MAX_INLINE_STEPS = 3;
+/** Lower bound for the inline-steps env override (1 = single inline step). */
+export declare const MIN_MAX_INLINE_STEPS = 1;
+/**
+ * Upper bound for the inline-steps env override. Inline bodies run in parallel
+ * within one function invocation, so this caps memory/CPU fan-out per handler.
+ */
+export declare const MAX_MAX_INLINE_STEPS = 16;
+/**
+ * Resolve the effective max number of inline steps for the current process.
+ *
+ * Reads `process.env.WORKFLOW_MAX_INLINE_STEPS` 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) and emit a
+ * one-time warning so misconfiguration is observable.
+ */
+export declare function getMaxInlineSteps(): number;
+/**
+ * Whether optimistic inline step start is enabled. When on, the owned-inline
+ * path begins running a brand-new step's body *before* its lazy `step_started`
+ * network call resolves (the input is already known locally), awaiting the
+ * `step_started` only before the terminal write.
+ *
+ * This can run a step body more than once when handlers race for the same
+ * step's create-claim — both run the body before one wins. That is unsafe for
+ * steps with non-idempotent side effects; in particular, two concurrent runs
+ * of a step that writes to the workflow stream (e.g. an AI agent streaming
+ * tokens) can interleave and corrupt the stream data. So the optimization is
+ * **off by default** and must be explicitly opted into per deployment.
+ *
+ * Reads `process.env.WORKFLOW_OPTIMISTIC_INLINE_START` lazily. Default OFF;
+ * enabled only by an explicit `'1'` / `'true'`.
+ */
+export declare function isOptimisticInlineStartEnabled(): boolean;
+/**
+ * Whether an operator has **explicitly disabled** optimistic inline start via
+ * `WORKFLOW_OPTIMISTIC_INLINE_START=0` / `=false`. Distinct from "unset": unset
+ * leaves the optimization off by default but lets turbo force it on; an explicit
+ * `0`/`false` is an operator opt-out that turbo must honor (turbo's forced
+ * optimistic start still runs a step body before `step_started`/`run_started` is
+ * confirmed, the property such an operator is opting out of), so
+ * `forceOptimisticStart` defers to this. Reads the env var lazily.
+ */
+export declare function isOptimisticInlineStartExplicitlyDisabled(): boolean;
+/**
+ * Whether "turbo mode" is enabled. Turbo mode fast-paths the *first delivery of
+ * the first invocation* of a run (detected by the entrypoint via `runInput`
+ * presence + `metadata.attempt === 1`): it backgrounds the `run_started` event
+ * creation, skips the initial event-log load (nothing has been written yet),
+ * and forces optimistic inline step start for that invocation — independent of
+ * `WORKFLOW_OPTIMISTIC_INLINE_START`.
+ *
+ * Forcing optimistic start is safe here because the first delivery has no
+ * concurrent peer handler to race the step create-claim, so a step body runs
+ * exactly once. That single-handler guarantee ends as soon as the run creates a
+ * hook or wait (which introduce resume/parallel invocations), so the runtime
+ * exits turbo at that point.
+ *
+ * Reads `process.env.WORKFLOW_TURBO` lazily. Default **ON**; disabled only by an
+ * explicit `'0'` / `'false'` (case-insensitive).
+ */
+export declare function isTurboEnabled(): boolean;
+export declare const REPLAY_DIVERGENCE_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;AAE5C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAKvC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CA2B1C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAIxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yCAAyC,IAAI,OAAO,CAInE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAIxC;AAKD,eAAO,MAAM,6BAA6B,IAAI,CAAC"}