@workflow/core 5.0.0-beta.43 → 5.0.0-beta.46

package/dist/runtime/resume-latency.d.ts

@@ -6,46 +6,56 @@ import type { HookResumeTiming } from '@workflow/world';
  *
  * ```text
  * T0 resumeHook() entered
- *      producer_prep   — hook lookup, serialization, encryption
+ *      producer_prep   : hook lookup, serialization, encryption
  * T1 queue publish requested
- *      queue_delivery  — network + VQS delivery (incl. any affinity re-route)
+ *      queue_delivery  : network + VQS delivery (incl. any affinity re-route)
  * T2 final consumer's queue handler entered
- *      resume_setup    — affinity check, hook_received re-ensure, replay preload
+ *      resume_setup    : affinity check, hook_received re-ensure, replay preload
  * T3 replay begins
- *      replay          — VM/session creation and workflow replay
+ *      replay          : VM/session creation and workflow replay
  * T4 next durable step encountered
- *      step_dispatch   — suspension handling, inline batch or queue dispatch
+ *      step_dispatch   : suspension handling, inline batch or queue dispatch
  * T5 step_started request begins
- *      step_claim      — the claim round trip
+ *      step_claim      : the claim round trip
  * T6 step_started response returned
- *      step_prepare    — key resolution, argument hydration, context setup
+ *      step_prepare    : key resolution, argument hydration, context setup
  * T7 immediately before stepFn.apply()
  * ```
  *
- * The producer's direct `hook_received` POST races the queue publish on the
- * parallel fast path, so it deliberately has no phase of its own — the two
- * overlap, and representing both as additive phases would double-count. It
- * remains visible as a contextual span (`hook.resume`).
+ * On the lazy path the producer writes no `hook_received` at all (the
+ * consumer materializes it from `hookInput`), so the window has no producer
+ * write phase. On the sequential path that write is awaited inside
+ * `producer_prep`, and for messages from an older producer, which raced the
+ * write against the publish, it overlapped `producer_prep` rather than adding
+ * to it. Either way it has no phase of its own; it remains visible as a
+ * contextual span (`hook.resume`).
  *
  * T0/T1 are stamped on the producer's machine and T2..T7 on the consumer's, so
  * the measurement is subject to cross-machine clock skew. Rather than clamp
  * (which would break the sum-equals-total property this decomposition exists
- * for), a non-monotonic boundary set drops the whole sample — see
+ * for), a non-monotonic boundary set drops the whole sample; see
  * {@link computeResumeTtrAttributes}.
  */
 /** What caused the resumption being measured. Only hooks are measured today. */
 export type ResumeTrigger = 'hook';
-/** Which `resumeHook()` dispatch path produced this resume. */
-export type ResumeStrategy = 'parallel' | 'sequential';
+/**
+ * Which `resumeHook()` dispatch path produced this resume.
+ *
+ * `parallel` is only ever received from an older producer, which raced its own
+ * `hook_received` write against the publish. Current producers send `lazy` (no
+ * producer write: the consumer materializes the event from `hookInput`) or
+ * `sequential`.
+ */
+export type ResumeStrategy = 'lazy' | 'parallel' | 'sequential';
 /**
  * How the consuming invocation initialized its replay state:
  *
- * - `hook_preload` — the hoisted `hook_received` write returned a usable
+ * - `hook_preload`: the hoisted `hook_received` write returned a usable
  *   replay preload, so neither `run_started` nor the initial `events.list` ran.
- * - `run_started` — the generic `run_started` setup ran (including the fast
+ * - `run_started`: the generic `run_started` setup ran (including the fast
  *   path's fallback, where the hoisted write succeeded but returned no usable
  *   preload).
- * - `event_load` — neither setup ran because the run arrived already loaded,
+ * - `event_load`: neither setup ran because the run arrived already loaded,
  *   so setup was a plain event load. No current path produces it (the one
  *   preloaded-run path, the background-step fall-through, consumes the
  *   tracking on its own step first); it is the honest default rather than a
@@ -62,7 +72,7 @@ export type ResumeStepExecution = 'inline' | 'dispatched';
  *
  * The runtime holds at most one of these per invocation and CONSUMES it when
  * it hands it to the execution that will attempt the next durable step, so a
- * later step in the same invocation — or a retry of the same step — never
+ * later step in the same invocation (or a retry of the same step) never
  * re-reports the same resumption. Within one inline batch the object is
  * shared by every step and the {@link ResumeTtrTracking.reported} latch picks
  * the single reporter.
@@ -71,19 +81,19 @@ export interface ResumeTtrTracking {
     trigger: ResumeTrigger;
     /** Absent only if an older producer omitted it from the queue message. */
     strategy?: ResumeStrategy;
-    /** T0 — entry into `resumeHook()`. */
+    /** T0: entry into `resumeHook()`. */
     resumeRequestedAtMs: number;
-    /** T1 — immediately before the queue publish was requested. */
+    /** T1: immediately before the queue publish was requested. */
     queuePublishRequestedAtMs: number;
     /**
-     * T2 — entry into the FINAL consumer's queue handler. A delivery that
+     * T2: entry into the FINAL consumer's queue handler. A delivery that
      * re-routes for deployment affinity never stamps this, so the re-routed hop
      * stays inside `queue_delivery` where it belongs.
      */
     consumerStartedAtMs: number;
-    /** T3 — this invocation's first replay pass. */
+    /** T3: this invocation's first replay pass. */
     replayStartedAtMs?: number;
-    /** T4 — replay first encountered a durable step after the resume. */
+    /** T4: replay first encountered a durable step after the resume. */
     nextStepEncounteredAtMs?: number;
     setupSource?: ResumeSetupSource;
     stepExecution: ResumeStepExecution;
@@ -91,7 +101,7 @@ export interface ResumeTtrTracking {
      * One-shot latch, set by the step executor once this resumption has been
      * reported. Every step of an inline batch is handed the SAME tracking
      * object, so the first one to reach user code takes the measurement and the
-     * rest see this and skip — one resumption, one sample, without pinning the
+     * rest see this and skip: one resumption, one sample, without pinning the
      * sample to a step that may lose its create-claim and never run.
      *
      * Deliberately not part of {@link HookResumeTiming}: it is invocation-local
@@ -101,8 +111,8 @@ export interface ResumeTtrTracking {
 }
 /**
  * Rebuild tracking from a queue message's timing object. Returns undefined for
- * a message that carries none (an older producer, or any non-hook delivery) —
- * the caller then simply reports no TTR.
+ * a message that carries none (an older producer, or any non-hook delivery);
+ * the caller then reports no TTR.
  */
 export declare function resumeTrackingFromMessage(timing: HookResumeTiming | undefined, stepExecution: ResumeStepExecution): ResumeTtrTracking | undefined;
 /**
@@ -114,7 +124,7 @@ export declare function resumeTrackingFromMessage(timing: HookResumeTiming | und
 export declare function resumeTimingForMessage(tracking: ResumeTtrTracking | undefined): HookResumeTiming | undefined;
 /**
  * Compute the TTR span attributes for a step that is the first durable step
- * following a hook resume. Returns undefined — emitting nothing at all — when
+ * following a hook resume. Returns undefined (emitting nothing at all) when
  * any of these hold:
  *
  * - the invocation carries no resume tracking (not a hook resume, or an older
@@ -133,11 +143,11 @@ export declare function computeResumeTtrAttributes(params: {
     tracking: ResumeTtrTracking | undefined;
     /** The attempt number of the execution about to run. */
     attempt: number;
-    /** T5 — `Date.now()` immediately before the `step_started` request. */
+    /** T5: `Date.now()` immediately before the `step_started` request. */
     stepClaimStartedAtMs: number | undefined;
-    /** T6 — `Date.now()` once the `step_started` response returned. */
+    /** T6: `Date.now()` once the `step_started` response returned. */
     stepClaimCompletedAtMs: number | undefined;
-    /** T7 — `Date.now()` immediately before `stepFn.apply()`. */
+    /** T7: `Date.now()` immediately before `stepFn.apply()`. */
     stepCodeStartedAtMs: number;
 }): Record<string, string | number> | undefined;
 //# sourceMappingURL=resume-latency.d.ts.map

package/dist/runtime/resume-latency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resume-latency.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-latency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,YAAY,CAAC;AAEvD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,aAAa,GAAG,YAAY,CAAC;AAE9E,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,sCAAsC;IACtC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,+DAA+D;IAC/D,yBAAyB,EAAE,MAAM,CAAC;IAClC;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gDAAgD;IAChD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qEAAqE;IACrE,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,aAAa,EAAE,mBAAmB,CAAC;IACnC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,aAAa,EAAE,mBAAmB,GACjC,iBAAiB,GAAG,SAAS,CAgC/B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GACtC,gBAAgB,GAAG,SAAS,CAkB9B;AA6CD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACxC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,mEAAmE;IACnE,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,6DAA6D;IAC7D,mBAAmB,EAAE,MAAM,CAAC;CAC7B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAoD9C"}
+{"version":3,"file":"resume-latency.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-latency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,GAAG,YAAY,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,aAAa,GAAG,YAAY,CAAC;AAE9E,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,qCAAqC;IACrC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,8DAA8D;IAC9D,yBAAyB,EAAE,MAAM,CAAC;IAClC;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oEAAoE;IACpE,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,aAAa,EAAE,mBAAmB,CAAC;IACnC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,aAAa,EAAE,mBAAmB,GACjC,iBAAiB,GAAG,SAAS,CAkC/B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GACtC,gBAAgB,GAAG,SAAS,CAkB9B;AA6CD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACxC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,kEAAkE;IAClE,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,4DAA4D;IAC5D,mBAAmB,EAAE,MAAM,CAAC;CAC7B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAoD9C"}

package/dist/runtime/resume-latency.js

@@ -1,8 +1,8 @@
 import * as Attribute from '../telemetry/semantic-conventions.js';
 /**
  * Rebuild tracking from a queue message's timing object. Returns undefined for
- * a message that carries none (an older producer, or any non-hook delivery) —
- * the caller then simply reports no TTR.
+ * a message that carries none (an older producer, or any non-hook delivery);
+ * the caller then reports no TTR.
  */
 export function resumeTrackingFromMessage(timing, stepExecution) {
     if (!timing)
@@ -13,7 +13,9 @@ export function resumeTrackingFromMessage(timing, stepExecution) {
     }
     return {
         trigger: 'hook',
-        ...(timing.strategy === 'parallel' || timing.strategy === 'sequential'
+        ...(timing.strategy === 'lazy' ||
+            timing.strategy === 'parallel' ||
+            timing.strategy === 'sequential'
             ? { strategy: timing.strategy }
             : {}),
         resumeRequestedAtMs: timing.resumeRequestedAtMs,
@@ -94,7 +96,7 @@ function validateBoundaries(b) {
 }
 /**
  * Compute the TTR span attributes for a step that is the first durable step
- * following a hook resume. Returns undefined — emitting nothing at all — when
+ * following a hook resume. Returns undefined (emitting nothing at all) when
  * any of these hold:
  *
  * - the invocation carries no resume tracking (not a hook resume, or an older
@@ -150,4 +152,4 @@ export function computeResumeTtrAttributes(params) {
         ...Attribute.ResumeStepExecution(tracking.stepExecution),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-latency.js","sourceRoot":"","sources":["../../src/runtime/resume-latency.ts"],"names":[],"mappings":"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","sourcesContent":["import type { HookResumeTiming } from '@workflow/world';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\n\n/**\n * Hook-triggered time-to-resume (TTR): wall-clock from entry into\n * `resumeHook()` (T0) to the first line of the next durable step (T7), plus a\n * decomposition into non-overlapping phases that sum exactly to it.\n *\n * ```text\n * T0 resumeHook() entered\n *      producer_prep   — hook lookup, serialization, encryption\n * T1 queue publish requested\n *      queue_delivery  — network + VQS delivery (incl. any affinity re-route)\n * T2 final consumer's queue handler entered\n *      resume_setup    — affinity check, hook_received re-ensure, replay preload\n * T3 replay begins\n *      replay          — VM/session creation and workflow replay\n * T4 next durable step encountered\n *      step_dispatch   — suspension handling, inline batch or queue dispatch\n * T5 step_started request begins\n *      step_claim      — the claim round trip\n * T6 step_started response returned\n *      step_prepare    — key resolution, argument hydration, context setup\n * T7 immediately before stepFn.apply()\n * ```\n *\n * The producer's direct `hook_received` POST races the queue publish on the\n * parallel fast path, so it deliberately has no phase of its own — the two\n * overlap, and representing both as additive phases would double-count. It\n * remains visible as a contextual span (`hook.resume`).\n *\n * T0/T1 are stamped on the producer's machine and T2..T7 on the consumer's, so\n * the measurement is subject to cross-machine clock skew. Rather than clamp\n * (which would break the sum-equals-total property this decomposition exists\n * for), a non-monotonic boundary set drops the whole sample — see\n * {@link computeResumeTtrAttributes}.\n */\n\n/** What caused the resumption being measured. Only hooks are measured today. */\nexport type ResumeTrigger = 'hook';\n\n/** Which `resumeHook()` dispatch path produced this resume. */\nexport type ResumeStrategy = 'parallel' | 'sequential';\n\n/**\n * How the consuming invocation initialized its replay state:\n *\n * - `hook_preload` — the hoisted `hook_received` write returned a usable\n *   replay preload, so neither `run_started` nor the initial `events.list` ran.\n * - `run_started` — the generic `run_started` setup ran (including the fast\n *   path's fallback, where the hoisted write succeeded but returned no usable\n *   preload).\n * - `event_load` — neither setup ran because the run arrived already loaded,\n *   so setup was a plain event load. No current path produces it (the one\n *   preloaded-run path, the background-step fall-through, consumes the\n *   tracking on its own step first); it is the honest default rather than a\n *   live value, and keeps the dimension total if such a path is added.\n */\nexport type ResumeSetupSource = 'hook_preload' | 'run_started' | 'event_load';\n\n/** Whether the measured step ran in the resuming invocation or a queued one. */\nexport type ResumeStepExecution = 'inline' | 'dispatched';\n\n/**\n * The resume boundaries observed so far, threaded from the queue handler into\n * `executeStep`. Producer fields arrive on the queue message\n * ({@link HookResumeTiming}); consumer fields are stamped by the invocation\n * that replays the resume.\n *\n * The runtime holds at most one of these per invocation and CONSUMES it when\n * it hands it to the execution that will attempt the next durable step, so a\n * later step in the same invocation — or a retry of the same step — never\n * re-reports the same resumption. Within one inline batch the object is\n * shared by every step and the {@link ResumeTtrTracking.reported} latch picks\n * the single reporter.\n */\nexport interface ResumeTtrTracking {\n  trigger: ResumeTrigger;\n  /** Absent only if an older producer omitted it from the queue message. */\n  strategy?: ResumeStrategy;\n  /** T0 — entry into `resumeHook()`. */\n  resumeRequestedAtMs: number;\n  /** T1 — immediately before the queue publish was requested. */\n  queuePublishRequestedAtMs: number;\n  /**\n   * T2 — entry into the FINAL consumer's queue handler. A delivery that\n   * re-routes for deployment affinity never stamps this, so the re-routed hop\n   * stays inside `queue_delivery` where it belongs.\n   */\n  consumerStartedAtMs: number;\n  /** T3 — this invocation's first replay pass. */\n  replayStartedAtMs?: number;\n  /** T4 — replay first encountered a durable step after the resume. */\n  nextStepEncounteredAtMs?: number;\n  setupSource?: ResumeSetupSource;\n  stepExecution: ResumeStepExecution;\n  /**\n   * One-shot latch, set by the step executor once this resumption has been\n   * reported. Every step of an inline batch is handed the SAME tracking\n   * object, so the first one to reach user code takes the measurement and the\n   * rest see this and skip — one resumption, one sample, without pinning the\n   * sample to a step that may lose its create-claim and never run.\n   *\n   * Deliberately not part of {@link HookResumeTiming}: it is invocation-local\n   * state, and a queue message carries the boundaries, not the claim.\n   */\n  reported?: boolean;\n}\n\n/**\n * Rebuild tracking from a queue message's timing object. Returns undefined for\n * a message that carries none (an older producer, or any non-hook delivery) —\n * the caller then simply reports no TTR.\n */\nexport function resumeTrackingFromMessage(\n  timing: HookResumeTiming | undefined,\n  stepExecution: ResumeStepExecution\n): ResumeTtrTracking | undefined {\n  if (!timing) return undefined;\n  if (\n    !Number.isFinite(timing.resumeRequestedAtMs) ||\n    !Number.isFinite(timing.queuePublishRequestedAtMs)\n  ) {\n    return undefined;\n  }\n  return {\n    trigger: 'hook',\n    ...(timing.strategy === 'parallel' || timing.strategy === 'sequential'\n      ? { strategy: timing.strategy }\n      : {}),\n    resumeRequestedAtMs: timing.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: timing.queuePublishRequestedAtMs,\n    // A dispatched step reads the resuming invocation's boundaries off the\n    // message; an inline one has them stamped locally by the caller, which\n    // overwrites this placeholder immediately after construction.\n    consumerStartedAtMs: timing.consumerStartedAtMs ?? Number.NaN,\n    ...(timing.replayStartedAtMs !== undefined\n      ? { replayStartedAtMs: timing.replayStartedAtMs }\n      : {}),\n    ...(timing.nextStepEncounteredAtMs !== undefined\n      ? { nextStepEncounteredAtMs: timing.nextStepEncounteredAtMs }\n      : {}),\n    ...(timing.setupSource === 'hook_preload' ||\n    timing.setupSource === 'run_started' ||\n    timing.setupSource === 'event_load'\n      ? { setupSource: timing.setupSource }\n      : {}),\n    stepExecution,\n  };\n}\n\n/**\n * Serialize tracking back onto a queue message, for the case where the\n * resuming invocation dispatches the next durable step to another invocation\n * instead of running it inline. Returns undefined when the tracking is not\n * complete enough to be worth forwarding.\n */\nexport function resumeTimingForMessage(\n  tracking: ResumeTtrTracking | undefined\n): HookResumeTiming | undefined {\n  if (!tracking) return undefined;\n  if (!Number.isFinite(tracking.consumerStartedAtMs)) return undefined;\n  return {\n    resumeRequestedAtMs: tracking.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,\n    ...(tracking.strategy !== undefined ? { strategy: tracking.strategy } : {}),\n    consumerStartedAtMs: tracking.consumerStartedAtMs,\n    ...(tracking.replayStartedAtMs !== undefined\n      ? { replayStartedAtMs: tracking.replayStartedAtMs }\n      : {}),\n    ...(tracking.nextStepEncounteredAtMs !== undefined\n      ? { nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs }\n      : {}),\n    ...(tracking.setupSource !== undefined\n      ? { setupSource: tracking.setupSource }\n      : {}),\n  };\n}\n\n/** Every boundary the emission gate requires, plus the optional claim end. */\ninterface ResumeBoundaries {\n  /** T0 */ resumeRequestedAtMs: number;\n  /** T1 */ queuePublishRequestedAtMs: number;\n  /** T2 */ consumerStartedAtMs: number;\n  /** T3 */ replayStartedAtMs: number;\n  /** T4 */ nextStepEncounteredAtMs: number;\n  /** T5 */ stepClaimStartedAtMs: number;\n  /** T6 — absent on the optimistic-start path; see below. */\n  stepClaimCompletedAtMs: number | undefined;\n  /** T7 */ stepCodeStartedAtMs: number;\n}\n\n/**\n * Validate that every required boundary is a finite epoch-ms value and that\n * the whole sequence is non-decreasing. Returns undefined otherwise, which\n * suppresses the metric entirely rather than reporting a phase that never\n * happened or a negative duration.\n */\nfunction validateBoundaries(\n  b: ResumeBoundaries\n): readonly number[] | undefined {\n  const ordered = [\n    b.resumeRequestedAtMs,\n    b.queuePublishRequestedAtMs,\n    b.consumerStartedAtMs,\n    b.replayStartedAtMs,\n    b.nextStepEncounteredAtMs,\n    b.stepClaimStartedAtMs,\n    ...(b.stepClaimCompletedAtMs !== undefined\n      ? [b.stepClaimCompletedAtMs]\n      : []),\n    b.stepCodeStartedAtMs,\n  ];\n  for (const value of ordered) {\n    if (typeof value !== 'number' || !Number.isFinite(value)) return undefined;\n  }\n  for (let i = 1; i < ordered.length; i++) {\n    if (ordered[i] < ordered[i - 1]) return undefined;\n  }\n  return ordered;\n}\n\n/**\n * Compute the TTR span attributes for a step that is the first durable step\n * following a hook resume. Returns undefined — emitting nothing at all — when\n * any of these hold:\n *\n * - the invocation carries no resume tracking (not a hook resume, or an older\n *   queue message with no timing);\n * - this is a retry (`attempt !== 1`), which measures a re-execution rather\n *   than the resumption;\n * - a required boundary is missing, non-finite, or out of order.\n *\n * `step_claim_ms` is the one phase that may be individually omitted. Under\n * optimistic inline start the `step_started` claim is deliberately NOT awaited\n * before the body runs, so its completion instant does not exist yet at T7;\n * rather than invent one, the claim phase is dropped and `step_prepare_ms`\n * spans T5→T7. The sum-equals-total property holds either way.\n */\nexport function computeResumeTtrAttributes(params: {\n  tracking: ResumeTtrTracking | undefined;\n  /** The attempt number of the execution about to run. */\n  attempt: number;\n  /** T5 — `Date.now()` immediately before the `step_started` request. */\n  stepClaimStartedAtMs: number | undefined;\n  /** T6 — `Date.now()` once the `step_started` response returned. */\n  stepClaimCompletedAtMs: number | undefined;\n  /** T7 — `Date.now()` immediately before `stepFn.apply()`. */\n  stepCodeStartedAtMs: number;\n}): Record<string, string | number> | undefined {\n  const { tracking } = params;\n  if (!tracking || params.attempt !== 1) return undefined;\n  if (\n    tracking.replayStartedAtMs === undefined ||\n    tracking.nextStepEncounteredAtMs === undefined ||\n    params.stepClaimStartedAtMs === undefined\n  ) {\n    return undefined;\n  }\n\n  const boundaries: ResumeBoundaries = {\n    resumeRequestedAtMs: tracking.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,\n    consumerStartedAtMs: tracking.consumerStartedAtMs,\n    replayStartedAtMs: tracking.replayStartedAtMs,\n    nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs,\n    stepClaimStartedAtMs: params.stepClaimStartedAtMs,\n    stepClaimCompletedAtMs: params.stepClaimCompletedAtMs,\n    stepCodeStartedAtMs: params.stepCodeStartedAtMs,\n  };\n  if (!validateBoundaries(boundaries)) return undefined;\n\n  const {\n    resumeRequestedAtMs: t0,\n    queuePublishRequestedAtMs: t1,\n    consumerStartedAtMs: t2,\n    replayStartedAtMs: t3,\n    nextStepEncounteredAtMs: t4,\n    stepClaimStartedAtMs: t5,\n    stepClaimCompletedAtMs: t6,\n    stepCodeStartedAtMs: t7,\n  } = boundaries;\n\n  return {\n    ...Attribute.ResumeTotalMs(t7 - t0),\n    ...Attribute.ResumeProducerPrepMs(t1 - t0),\n    ...Attribute.ResumeQueueDeliveryMs(t2 - t1),\n    ...Attribute.ResumeSetupMs(t3 - t2),\n    ...Attribute.ResumeReplayMs(t4 - t3),\n    ...Attribute.ResumeStepDispatchMs(t5 - t4),\n    ...(t6 !== undefined ? Attribute.ResumeStepClaimMs(t6 - t5) : {}),\n    ...Attribute.ResumeStepPrepareMs(t7 - (t6 ?? t5)),\n    ...Attribute.ResumeTrigger(tracking.trigger),\n    ...(tracking.strategy !== undefined\n      ? Attribute.ResumeStrategy(tracking.strategy)\n      : {}),\n    ...(tracking.setupSource !== undefined\n      ? Attribute.ResumeSetupSource(tracking.setupSource)\n      : {}),\n    ...Attribute.ResumeStepExecution(tracking.stepExecution),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-latency.js","sourceRoot":"","sources":["../../src/runtime/resume-latency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,sCAAsC,CAAC;AAsHlE;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAAoC,EACpC,aAAkC;IAElC,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAC9B,IACE,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,mBAAmB,CAAC;QAC5C,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,yBAAyB,CAAC,EAClD,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO;QACL,OAAO,EAAE,MAAM;QACf,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,MAAM;YAC9B,MAAM,CAAC,QAAQ,KAAK,UAAU;YAC9B,MAAM,CAAC,QAAQ,KAAK,YAAY;YAC9B,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE;YAC/B,CAAC,CAAC,EAAE,CAAC;QACP,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;QAC/C,yBAAyB,EAAE,MAAM,CAAC,yBAAyB;QAC3D,uEAAuE;QACvE,uEAAuE;QACvE,8DAA8D;QAC9D,mBAAmB,EAAE,MAAM,CAAC,mBAAmB,IAAI,MAAM,CAAC,GAAG;QAC7D,GAAG,CAAC,MAAM,CAAC,iBAAiB,KAAK,SAAS;YACxC,CAAC,CAAC,EAAE,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,EAAE;YACjD,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,MAAM,CAAC,uBAAuB,KAAK,SAAS;YAC9C,CAAC,CAAC,EAAE,uBAAuB,EAAE,MAAM,CAAC,uBAAuB,EAAE;YAC7D,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,MAAM,CAAC,WAAW,KAAK,cAAc;YACzC,MAAM,CAAC,WAAW,KAAK,aAAa;YACpC,MAAM,CAAC,WAAW,KAAK,YAAY;YACjC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE;YACrC,CAAC,CAAC,EAAE,CAAC;QACP,aAAa;KACd,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CACpC,QAAuC;IAEvC,IAAI,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAC;IAChC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,CAAC;QAAE,OAAO,SAAS,CAAC;IACrE,OAAO;QACL,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB;QACjD,yBAAyB,EAAE,QAAQ,CAAC,yBAAyB;QAC7D,GAAG,CAAC,QAAQ,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3E,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB;QACjD,GAAG,CAAC,QAAQ,CAAC,iBAAiB,KAAK,SAAS;YAC1C,CAAC,CAAC,EAAE,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB,EAAE;YACnD,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,QAAQ,CAAC,uBAAuB,KAAK,SAAS;YAChD,CAAC,CAAC,EAAE,uBAAuB,EAAE,QAAQ,CAAC,uBAAuB,EAAE;YAC/D,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,QAAQ,CAAC,WAAW,KAAK,SAAS;YACpC,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE;YACvC,CAAC,CAAC,EAAE,CAAC;KACR,CAAC;AACJ,CAAC;AAeD;;;;;GAKG;AACH,SAAS,kBAAkB,CACzB,CAAmB;IAEnB,MAAM,OAAO,GAAG;QACd,CAAC,CAAC,mBAAmB;QACrB,CAAC,CAAC,yBAAyB;QAC3B,CAAC,CAAC,mBAAmB;QACrB,CAAC,CAAC,iBAAiB;QACnB,CAAC,CAAC,uBAAuB;QACzB,CAAC,CAAC,oBAAoB;QACtB,GAAG,CAAC,CAAC,CAAC,sBAAsB,KAAK,SAAS;YACxC,CAAC,CAAC,CAAC,CAAC,CAAC,sBAAsB,CAAC;YAC5B,CAAC,CAAC,EAAE,CAAC;QACP,CAAC,CAAC,mBAAmB;KACtB,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;IAC7E,CAAC;IACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC;YAAE,OAAO,SAAS,CAAC;IACpD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,0BAA0B,CAAC,MAU1C;IACC,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;IAC5B,IAAI,CAAC,QAAQ,IAAI,MAAM,CAAC,OAAO,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACxD,IACE,QAAQ,CAAC,iBAAiB,KAAK,SAAS;QACxC,QAAQ,CAAC,uBAAuB,KAAK,SAAS;QAC9C,MAAM,CAAC,oBAAoB,KAAK,SAAS,EACzC,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,UAAU,GAAqB;QACnC,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB;QACjD,yBAAyB,EAAE,QAAQ,CAAC,yBAAyB;QAC7D,mBAAmB,EAAE,QAAQ,CAAC,mBAAmB;QACjD,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;QAC7C,uBAAuB,EAAE,QAAQ,CAAC,uBAAuB;QACzD,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;QACjD,sBAAsB,EAAE,MAAM,CAAC,sBAAsB;QACrD,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;KAChD,CAAC;IACF,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC;QAAE,OAAO,SAAS,CAAC;IAEtD,MAAM,EACJ,mBAAmB,EAAE,EAAE,EACvB,yBAAyB,EAAE,EAAE,EAC7B,mBAAmB,EAAE,EAAE,EACvB,iBAAiB,EAAE,EAAE,EACrB,uBAAuB,EAAE,EAAE,EAC3B,oBAAoB,EAAE,EAAE,EACxB,sBAAsB,EAAE,EAAE,EAC1B,mBAAmB,EAAE,EAAE,GACxB,GAAG,UAAU,CAAC;IAEf,OAAO;QACL,GAAG,SAAS,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,CAAC;QACnC,GAAG,SAAS,CAAC,oBAAoB,CAAC,EAAE,GAAG,EAAE,CAAC;QAC1C,GAAG,SAAS,CAAC,qBAAqB,CAAC,EAAE,GAAG,EAAE,CAAC;QAC3C,GAAG,SAAS,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,CAAC;QACnC,GAAG,SAAS,CAAC,cAAc,CAAC,EAAE,GAAG,EAAE,CAAC;QACpC,GAAG,SAAS,CAAC,oBAAoB,CAAC,EAAE,GAAG,EAAE,CAAC;QAC1C,GAAG,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACjE,GAAG,SAAS,CAAC,mBAAmB,CAAC,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QACjD,GAAG,SAAS,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC;QAC5C,GAAG,CAAC,QAAQ,CAAC,QAAQ,KAAK,SAAS;YACjC,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC7C,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,QAAQ,CAAC,WAAW,KAAK,SAAS;YACpC,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,QAAQ,CAAC,WAAW,CAAC;YACnD,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,SAAS,CAAC,mBAAmB,CAAC,QAAQ,CAAC,aAAa,CAAC;KACzD,CAAC;AACJ,CAAC","sourcesContent":["import type { HookResumeTiming } from '@workflow/world';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\n\n/**\n * Hook-triggered time-to-resume (TTR): wall-clock from entry into\n * `resumeHook()` (T0) to the first line of the next durable step (T7), plus a\n * decomposition into non-overlapping phases that sum exactly to it.\n *\n * ```text\n * T0 resumeHook() entered\n *      producer_prep   : hook lookup, serialization, encryption\n * T1 queue publish requested\n *      queue_delivery  : network + VQS delivery (incl. any affinity re-route)\n * T2 final consumer's queue handler entered\n *      resume_setup    : affinity check, hook_received re-ensure, replay preload\n * T3 replay begins\n *      replay          : VM/session creation and workflow replay\n * T4 next durable step encountered\n *      step_dispatch   : suspension handling, inline batch or queue dispatch\n * T5 step_started request begins\n *      step_claim      : the claim round trip\n * T6 step_started response returned\n *      step_prepare    : key resolution, argument hydration, context setup\n * T7 immediately before stepFn.apply()\n * ```\n *\n * On the lazy path the producer writes no `hook_received` at all (the\n * consumer materializes it from `hookInput`), so the window has no producer\n * write phase. On the sequential path that write is awaited inside\n * `producer_prep`, and for messages from an older producer, which raced the\n * write against the publish, it overlapped `producer_prep` rather than adding\n * to it. Either way it has no phase of its own; it remains visible as a\n * contextual span (`hook.resume`).\n *\n * T0/T1 are stamped on the producer's machine and T2..T7 on the consumer's, so\n * the measurement is subject to cross-machine clock skew. Rather than clamp\n * (which would break the sum-equals-total property this decomposition exists\n * for), a non-monotonic boundary set drops the whole sample; see\n * {@link computeResumeTtrAttributes}.\n */\n\n/** What caused the resumption being measured. Only hooks are measured today. */\nexport type ResumeTrigger = 'hook';\n\n/**\n * Which `resumeHook()` dispatch path produced this resume.\n *\n * `parallel` is only ever received from an older producer, which raced its own\n * `hook_received` write against the publish. Current producers send `lazy` (no\n * producer write: the consumer materializes the event from `hookInput`) or\n * `sequential`.\n */\nexport type ResumeStrategy = 'lazy' | 'parallel' | 'sequential';\n\n/**\n * How the consuming invocation initialized its replay state:\n *\n * - `hook_preload`: the hoisted `hook_received` write returned a usable\n *   replay preload, so neither `run_started` nor the initial `events.list` ran.\n * - `run_started`: the generic `run_started` setup ran (including the fast\n *   path's fallback, where the hoisted write succeeded but returned no usable\n *   preload).\n * - `event_load`: neither setup ran because the run arrived already loaded,\n *   so setup was a plain event load. No current path produces it (the one\n *   preloaded-run path, the background-step fall-through, consumes the\n *   tracking on its own step first); it is the honest default rather than a\n *   live value, and keeps the dimension total if such a path is added.\n */\nexport type ResumeSetupSource = 'hook_preload' | 'run_started' | 'event_load';\n\n/** Whether the measured step ran in the resuming invocation or a queued one. */\nexport type ResumeStepExecution = 'inline' | 'dispatched';\n\n/**\n * The resume boundaries observed so far, threaded from the queue handler into\n * `executeStep`. Producer fields arrive on the queue message\n * ({@link HookResumeTiming}); consumer fields are stamped by the invocation\n * that replays the resume.\n *\n * The runtime holds at most one of these per invocation and CONSUMES it when\n * it hands it to the execution that will attempt the next durable step, so a\n * later step in the same invocation (or a retry of the same step) never\n * re-reports the same resumption. Within one inline batch the object is\n * shared by every step and the {@link ResumeTtrTracking.reported} latch picks\n * the single reporter.\n */\nexport interface ResumeTtrTracking {\n  trigger: ResumeTrigger;\n  /** Absent only if an older producer omitted it from the queue message. */\n  strategy?: ResumeStrategy;\n  /** T0: entry into `resumeHook()`. */\n  resumeRequestedAtMs: number;\n  /** T1: immediately before the queue publish was requested. */\n  queuePublishRequestedAtMs: number;\n  /**\n   * T2: entry into the FINAL consumer's queue handler. A delivery that\n   * re-routes for deployment affinity never stamps this, so the re-routed hop\n   * stays inside `queue_delivery` where it belongs.\n   */\n  consumerStartedAtMs: number;\n  /** T3: this invocation's first replay pass. */\n  replayStartedAtMs?: number;\n  /** T4: replay first encountered a durable step after the resume. */\n  nextStepEncounteredAtMs?: number;\n  setupSource?: ResumeSetupSource;\n  stepExecution: ResumeStepExecution;\n  /**\n   * One-shot latch, set by the step executor once this resumption has been\n   * reported. Every step of an inline batch is handed the SAME tracking\n   * object, so the first one to reach user code takes the measurement and the\n   * rest see this and skip: one resumption, one sample, without pinning the\n   * sample to a step that may lose its create-claim and never run.\n   *\n   * Deliberately not part of {@link HookResumeTiming}: it is invocation-local\n   * state, and a queue message carries the boundaries, not the claim.\n   */\n  reported?: boolean;\n}\n\n/**\n * Rebuild tracking from a queue message's timing object. Returns undefined for\n * a message that carries none (an older producer, or any non-hook delivery);\n * the caller then reports no TTR.\n */\nexport function resumeTrackingFromMessage(\n  timing: HookResumeTiming | undefined,\n  stepExecution: ResumeStepExecution\n): ResumeTtrTracking | undefined {\n  if (!timing) return undefined;\n  if (\n    !Number.isFinite(timing.resumeRequestedAtMs) ||\n    !Number.isFinite(timing.queuePublishRequestedAtMs)\n  ) {\n    return undefined;\n  }\n  return {\n    trigger: 'hook',\n    ...(timing.strategy === 'lazy' ||\n    timing.strategy === 'parallel' ||\n    timing.strategy === 'sequential'\n      ? { strategy: timing.strategy }\n      : {}),\n    resumeRequestedAtMs: timing.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: timing.queuePublishRequestedAtMs,\n    // A dispatched step reads the resuming invocation's boundaries off the\n    // message; an inline one has them stamped locally by the caller, which\n    // overwrites this placeholder immediately after construction.\n    consumerStartedAtMs: timing.consumerStartedAtMs ?? Number.NaN,\n    ...(timing.replayStartedAtMs !== undefined\n      ? { replayStartedAtMs: timing.replayStartedAtMs }\n      : {}),\n    ...(timing.nextStepEncounteredAtMs !== undefined\n      ? { nextStepEncounteredAtMs: timing.nextStepEncounteredAtMs }\n      : {}),\n    ...(timing.setupSource === 'hook_preload' ||\n    timing.setupSource === 'run_started' ||\n    timing.setupSource === 'event_load'\n      ? { setupSource: timing.setupSource }\n      : {}),\n    stepExecution,\n  };\n}\n\n/**\n * Serialize tracking back onto a queue message, for the case where the\n * resuming invocation dispatches the next durable step to another invocation\n * instead of running it inline. Returns undefined when the tracking is not\n * complete enough to be worth forwarding.\n */\nexport function resumeTimingForMessage(\n  tracking: ResumeTtrTracking | undefined\n): HookResumeTiming | undefined {\n  if (!tracking) return undefined;\n  if (!Number.isFinite(tracking.consumerStartedAtMs)) return undefined;\n  return {\n    resumeRequestedAtMs: tracking.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,\n    ...(tracking.strategy !== undefined ? { strategy: tracking.strategy } : {}),\n    consumerStartedAtMs: tracking.consumerStartedAtMs,\n    ...(tracking.replayStartedAtMs !== undefined\n      ? { replayStartedAtMs: tracking.replayStartedAtMs }\n      : {}),\n    ...(tracking.nextStepEncounteredAtMs !== undefined\n      ? { nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs }\n      : {}),\n    ...(tracking.setupSource !== undefined\n      ? { setupSource: tracking.setupSource }\n      : {}),\n  };\n}\n\n/** Every boundary the emission gate requires, plus the optional claim end. */\ninterface ResumeBoundaries {\n  /** T0 */ resumeRequestedAtMs: number;\n  /** T1 */ queuePublishRequestedAtMs: number;\n  /** T2 */ consumerStartedAtMs: number;\n  /** T3 */ replayStartedAtMs: number;\n  /** T4 */ nextStepEncounteredAtMs: number;\n  /** T5 */ stepClaimStartedAtMs: number;\n  /** T6: absent on the optimistic-start path; see below. */\n  stepClaimCompletedAtMs: number | undefined;\n  /** T7 */ stepCodeStartedAtMs: number;\n}\n\n/**\n * Validate that every required boundary is a finite epoch-ms value and that\n * the whole sequence is non-decreasing. Returns undefined otherwise, which\n * suppresses the metric entirely rather than reporting a phase that never\n * happened or a negative duration.\n */\nfunction validateBoundaries(\n  b: ResumeBoundaries\n): readonly number[] | undefined {\n  const ordered = [\n    b.resumeRequestedAtMs,\n    b.queuePublishRequestedAtMs,\n    b.consumerStartedAtMs,\n    b.replayStartedAtMs,\n    b.nextStepEncounteredAtMs,\n    b.stepClaimStartedAtMs,\n    ...(b.stepClaimCompletedAtMs !== undefined\n      ? [b.stepClaimCompletedAtMs]\n      : []),\n    b.stepCodeStartedAtMs,\n  ];\n  for (const value of ordered) {\n    if (typeof value !== 'number' || !Number.isFinite(value)) return undefined;\n  }\n  for (let i = 1; i < ordered.length; i++) {\n    if (ordered[i] < ordered[i - 1]) return undefined;\n  }\n  return ordered;\n}\n\n/**\n * Compute the TTR span attributes for a step that is the first durable step\n * following a hook resume. Returns undefined (emitting nothing at all) when\n * any of these hold:\n *\n * - the invocation carries no resume tracking (not a hook resume, or an older\n *   queue message with no timing);\n * - this is a retry (`attempt !== 1`), which measures a re-execution rather\n *   than the resumption;\n * - a required boundary is missing, non-finite, or out of order.\n *\n * `step_claim_ms` is the one phase that may be individually omitted. Under\n * optimistic inline start the `step_started` claim is deliberately NOT awaited\n * before the body runs, so its completion instant does not exist yet at T7;\n * rather than invent one, the claim phase is dropped and `step_prepare_ms`\n * spans T5→T7. The sum-equals-total property holds either way.\n */\nexport function computeResumeTtrAttributes(params: {\n  tracking: ResumeTtrTracking | undefined;\n  /** The attempt number of the execution about to run. */\n  attempt: number;\n  /** T5: `Date.now()` immediately before the `step_started` request. */\n  stepClaimStartedAtMs: number | undefined;\n  /** T6: `Date.now()` once the `step_started` response returned. */\n  stepClaimCompletedAtMs: number | undefined;\n  /** T7: `Date.now()` immediately before `stepFn.apply()`. */\n  stepCodeStartedAtMs: number;\n}): Record<string, string | number> | undefined {\n  const { tracking } = params;\n  if (!tracking || params.attempt !== 1) return undefined;\n  if (\n    tracking.replayStartedAtMs === undefined ||\n    tracking.nextStepEncounteredAtMs === undefined ||\n    params.stepClaimStartedAtMs === undefined\n  ) {\n    return undefined;\n  }\n\n  const boundaries: ResumeBoundaries = {\n    resumeRequestedAtMs: tracking.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,\n    consumerStartedAtMs: tracking.consumerStartedAtMs,\n    replayStartedAtMs: tracking.replayStartedAtMs,\n    nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs,\n    stepClaimStartedAtMs: params.stepClaimStartedAtMs,\n    stepClaimCompletedAtMs: params.stepClaimCompletedAtMs,\n    stepCodeStartedAtMs: params.stepCodeStartedAtMs,\n  };\n  if (!validateBoundaries(boundaries)) return undefined;\n\n  const {\n    resumeRequestedAtMs: t0,\n    queuePublishRequestedAtMs: t1,\n    consumerStartedAtMs: t2,\n    replayStartedAtMs: t3,\n    nextStepEncounteredAtMs: t4,\n    stepClaimStartedAtMs: t5,\n    stepClaimCompletedAtMs: t6,\n    stepCodeStartedAtMs: t7,\n  } = boundaries;\n\n  return {\n    ...Attribute.ResumeTotalMs(t7 - t0),\n    ...Attribute.ResumeProducerPrepMs(t1 - t0),\n    ...Attribute.ResumeQueueDeliveryMs(t2 - t1),\n    ...Attribute.ResumeSetupMs(t3 - t2),\n    ...Attribute.ResumeReplayMs(t4 - t3),\n    ...Attribute.ResumeStepDispatchMs(t5 - t4),\n    ...(t6 !== undefined ? Attribute.ResumeStepClaimMs(t6 - t5) : {}),\n    ...Attribute.ResumeStepPrepareMs(t7 - (t6 ?? t5)),\n    ...Attribute.ResumeTrigger(tracking.trigger),\n    ...(tracking.strategy !== undefined\n      ? Attribute.ResumeStrategy(tracking.strategy)\n      : {}),\n    ...(tracking.setupSource !== undefined\n      ? Attribute.ResumeSetupSource(tracking.setupSource)\n      : {}),\n    ...Attribute.ResumeStepExecution(tracking.stepExecution),\n  };\n}\n"]}

package/dist/runtime/run-id-time.d.ts

@@ -5,8 +5,8 @@
  * `@workflow/world-vercel`'s region-tagged run IDs mark an ID as carrying
  * metadata by setting the most-significant bit of the ULID's 48-bit
  * timestamp, which would otherwise skew the decoded time past the year 6400.
- * The tag-bit handling is delegated to the scheme's own codec —
- * `decode()` returns the ULID with the tag bit cleared — so if the tagged
+ * The tag-bit handling is delegated to the scheme's own codec
+ * (`decode()` returns the ULID with the tag bit cleared), so if the tagged
  * layout ever evolves (the scheme carries a 5-bit version field for exactly
  * that), this anchor keeps tracking the codec instead of silently diverging.
  * For untagged input `decode()` is a passthrough.

package/dist/runtime/run-id-time.js

@@ -2,9 +2,9 @@ import { decode } from '@workflow/world-vercel/run-id';
 import { decodeTime } from 'ulid';
 /**
  * Run IDs are minted client-side in `start()` as `wrun_<ulid>` (via
- * `World.createRunId()` when the world provides one, else a plain ULID — see
+ * `World.createRunId()` when the world provides one, else a plain ULID; see
  * `runtime/helpers.ts`). A ULID encodes its creation time in its first 48 bits,
- * so the run's creation timestamp is recoverable from the run ID alone —
+ * so the run's creation timestamp is recoverable from the run ID alone,
  * without any server round-trip or run-snapshot load. This is the earliest
  * replay-stable timestamp a delivery has (the run ID arrives in the queue
  * payload), which lets the workflow VM be seeded and clock-initialized before
@@ -18,8 +18,8 @@ const RUN_ID_PREFIX = 'wrun_';
  * `@workflow/world-vercel`'s region-tagged run IDs mark an ID as carrying
  * metadata by setting the most-significant bit of the ULID's 48-bit
  * timestamp, which would otherwise skew the decoded time past the year 6400.
- * The tag-bit handling is delegated to the scheme's own codec —
- * `decode()` returns the ULID with the tag bit cleared — so if the tagged
+ * The tag-bit handling is delegated to the scheme's own codec
+ * (`decode()` returns the ULID with the tag bit cleared), so if the tagged
  * layout ever evolves (the scheme carries a 5-bit version field for exactly
  * that), this anchor keeps tracking the codec instead of silently diverging.
  * For untagged input `decode()` is a passthrough.
@@ -39,4 +39,4 @@ export function runIdCreatedAt(runId) {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLWlkLXRpbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnVudGltZS9ydW4taWQtdGltZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDdkQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUVsQzs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLGFBQWEsR0FBRyxPQUFPLENBQUM7QUFFOUI7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUFDLEtBQWE7SUFDMUMsTUFBTSxRQUFRLEdBQUcsS0FBSyxDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUM7UUFDOUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQztRQUNuQyxDQUFDLENBQUMsS0FBSyxDQUFDO0lBQ1YsSUFBSSxDQUFDO1FBQ0gsT0FBTyxVQUFVLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzNDLENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlY29kZSB9IGZyb20gJ0B3b3JrZmxvdy93b3JsZC12ZXJjZWwvcnVuLWlkJztcbmltcG9ydCB7IGRlY29kZVRpbWUgfSBmcm9tICd1bGlkJztcblxuLyoqXG4gKiBSdW4gSURzIGFyZSBtaW50ZWQgY2xpZW50LXNpZGUgaW4gYHN0YXJ0KClgIGFzIGB3cnVuXzx1bGlkPmAgKHZpYVxuICogYFdvcmxkLmNyZWF0ZVJ1bklkKClgIHdoZW4gdGhlIHdvcmxkIHByb3ZpZGVzIG9uZSwgZWxzZSBhIHBsYWluIFVMSUQ7IHNlZVxuICogYHJ1bnRpbWUvaGVscGVycy50c2ApLiBBIFVMSUQgZW5jb2RlcyBpdHMgY3JlYXRpb24gdGltZSBpbiBpdHMgZmlyc3QgNDggYml0cyxcbiAqIHNvIHRoZSBydW4ncyBjcmVhdGlvbiB0aW1lc3RhbXAgaXMgcmVjb3ZlcmFibGUgZnJvbSB0aGUgcnVuIElEIGFsb25lLFxuICogd2l0aG91dCBhbnkgc2VydmVyIHJvdW5kLXRyaXAgb3IgcnVuLXNuYXBzaG90IGxvYWQuIFRoaXMgaXMgdGhlIGVhcmxpZXN0XG4gKiByZXBsYXktc3RhYmxlIHRpbWVzdGFtcCBhIGRlbGl2ZXJ5IGhhcyAodGhlIHJ1biBJRCBhcnJpdmVzIGluIHRoZSBxdWV1ZVxuICogcGF5bG9hZCksIHdoaWNoIGxldHMgdGhlIHdvcmtmbG93IFZNIGJlIHNlZWRlZCBhbmQgY2xvY2staW5pdGlhbGl6ZWQgYmVmb3JlXG4gKiBgcnVuX3N0YXJ0ZWRgLlxuICovXG5jb25zdCBSVU5fSURfUFJFRklYID0gJ3dydW5fJztcblxuLyoqXG4gKiBFeHRyYWN0cyB0aGUgcnVuJ3MgY3JlYXRpb24gdGltZXN0YW1wIChlcG9jaCBtaWxsaXNlY29uZHMpIGZyb20gYSBgd3J1bl9gXG4gKiBydW4gSUQgYnkgZGVjb2RpbmcgdGhlIGVtYmVkZGVkIFVMSUQgdGltZSBjb21wb25lbnQuXG4gKlxuICogYEB3b3JrZmxvdy93b3JsZC12ZXJjZWxgJ3MgcmVnaW9uLXRhZ2dlZCBydW4gSURzIG1hcmsgYW4gSUQgYXMgY2FycnlpbmdcbiAqIG1ldGFkYXRhIGJ5IHNldHRpbmcgdGhlIG1vc3Qtc2lnbmlmaWNhbnQgYml0IG9mIHRoZSBVTElEJ3MgNDgtYml0XG4gKiB0aW1lc3RhbXAsIHdoaWNoIHdvdWxkIG90aGVyd2lzZSBza2V3IHRoZSBkZWNvZGVkIHRpbWUgcGFzdCB0aGUgeWVhciA2NDAwLlxuICogVGhlIHRhZy1iaXQgaGFuZGxpbmcgaXMgZGVsZWdhdGVkIHRvIHRoZSBzY2hlbWUncyBvd24gY29kZWNcbiAqIChgZGVjb2RlKClgIHJldHVybnMgdGhlIFVMSUQgd2l0aCB0aGUgdGFnIGJpdCBjbGVhcmVkKSwgc28gaWYgdGhlIHRhZ2dlZFxuICogbGF5b3V0IGV2ZXIgZXZvbHZlcyAodGhlIHNjaGVtZSBjYXJyaWVzIGEgNS1iaXQgdmVyc2lvbiBmaWVsZCBmb3IgZXhhY3RseVxuICogdGhhdCksIHRoaXMgYW5jaG9yIGtlZXBzIHRyYWNraW5nIHRoZSBjb2RlYyBpbnN0ZWFkIG9mIHNpbGVudGx5IGRpdmVyZ2luZy5cbiAqIEZvciB1bnRhZ2dlZCBpbnB1dCBgZGVjb2RlKClgIGlzIGEgcGFzc3Rocm91Z2guXG4gKlxuICogUmV0dXJucyBgdW5kZWZpbmVkYCB3aGVuIGBydW5JZGAgaXMgbm90IGEgZGVjb2RhYmxlIGB3cnVuXzx1bGlkPmAgKGUuZy4gYVxuICogbGVnYWN5L25vbi1VTElEIGlkLCBvciBhIHRlc3QgZml4dHVyZSBsaWtlIGB3cnVuX3Rlc3RgKTsgY2FsbGVycyBmYWxsIGJhY2sgdG9cbiAqIGFuIGF1dGhvcml0YXRpdmUgdGltZXN0YW1wIGZyb20gdGhlIHJ1biBzbmFwc2hvdCAoYGNyZWF0ZWRBdGApIGluIHRoYXQgY2FzZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJ1bklkQ3JlYXRlZEF0KHJ1bklkOiBzdHJpbmcpOiBudW1iZXIgfCB1bmRlZmluZWQge1xuICBjb25zdCB1bGlkUGFydCA9IHJ1bklkLnN0YXJ0c1dpdGgoUlVOX0lEX1BSRUZJWClcbiAgICA/IHJ1bklkLnNsaWNlKFJVTl9JRF9QUkVGSVgubGVuZ3RoKVxuICAgIDogcnVuSWQ7XG4gIHRyeSB7XG4gICAgcmV0dXJuIGRlY29kZVRpbWUoZGVjb2RlKHVsaWRQYXJ0KS51bGlkKTtcbiAgfSBjYXRjaCB7XG4gICAgcmV0dXJuIHVuZGVmaW5lZDtcbiAgfVxufVxuIl19

package/dist/runtime/run.d.ts

@@ -1,8 +1,25 @@
 import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
-import { type WorkflowRunStatus } from '@workflow/world';
+import type { WorkflowRunStatus } from '@workflow/world';
 import { type CancelRunOptions, type StopSleepOptions, type StopSleepResult } from './runs.js';
 /** @internal */
 export declare function getReturnValuePollIntervalMs(): number;
+/** @internal */
+export declare function getReturnValueWaitTimeoutMs(): number;
+/** @internal */
+export declare function getReturnValueMaxLongPolls(): number;
+/**
+ * Whether `await run.returnValue` may use the World's long poll
+ * (`runs.waitForTerminalStatus`) instead of interval-polling `runs.get`.
+ *
+ * Default **ON** wherever the World implements the method; a World that does
+ * not is already on the interval path with nothing to switch off. Reads
+ * `process.env.WORKFLOW_RETURN_VALUE_LONG_POLL` lazily; an explicit `'0'` /
+ * `'false'` is the kill switch, restoring the fixed-interval poll exactly as
+ * it behaved before the fast path existed.
+ *
+ * @internal
+ */
+export declare function isReturnValueLongPollEnabled(): boolean;
 /**
  * A `ReadableStream` extended with workflow-specific helpers.
  */
@@ -10,7 +27,7 @@ export type WorkflowReadableStream<R = any> = ReadableStream<R> & {
     /**
      * Returns the tail index (index of the last known chunk, 0-based) of the
      * underlying workflow stream. Useful for resolving a negative `startIndex`
-     * into an absolute position — for example, when building reconnection
+     * into an absolute position, for example, when building reconnection
      * endpoints that need to inform the client where the stream starts.
      *
      * Returns `-1` when no chunks have been written yet.
@@ -32,8 +49,8 @@ export interface WorkflowReadableStreamOptions {
      */
     startIndex?: number;
     /**
-     * Any asynchronous operations that need to be performed before the execution
-     * environment is paused / terminated
+     * Any asynchronous operations to complete before pausing or terminating the
+     * execution environment
      * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).
      */
     ops?: Promise<any>[];
@@ -90,7 +107,7 @@ export declare class Run<TResult> {
     get status(): Promise<WorkflowRunStatus>;
     /**
      * The return value of the workflow run.
-     * Polls the workflow return value until it is completed.
+     * Polls the workflow return value until the workflow run completes.
      */
     get returnValue(): Promise<TResult>;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAIL,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AAYzB,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAErB,MAAM,WAAW,CAAC;AAQnB,gBAAgB;AAChB,wBAAgB,4BAA4B,IAAI,MAAM,CAMrD;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,GAAG,GAAG,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG;IAChE;;;;;;;OAOG;IACH,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,qBAAa,GAAG,CAAC,OAAO;;IACtB,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;;;;IAIlD,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;IAID;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;gBA4BF,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE;IAiC9D;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAKlE;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAa7B;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAOvC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAGlC;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAKlC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAKzC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAK3C;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,sBAAsB,CAErC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,GAAG,GAAG,EACjB,OAAO,GAAE,6BAAkC,GAC1C,sBAAsB,CAAC,CAAC,CAAC;CAqI7B;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,CAE3D"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,KAAK,EAAe,iBAAiB,EAAS,MAAM,iBAAiB,CAAC;AAc7E,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAErB,MAAM,WAAW,CAAC;AAQnB,gBAAgB;AAChB,wBAAgB,4BAA4B,IAAI,MAAM,CAMrD;AAiBD,gBAAgB;AAChB,wBAAgB,2BAA2B,IAAI,MAAM,CAMpD;AAqBD,gBAAgB;AAChB,wBAAgB,0BAA0B,IAAI,MAAM,CAMnD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAItD;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,GAAG,GAAG,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG;IAChE;;;;;;;OAOG;IACH,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,qBAAa,GAAG,CAAC,OAAO;;IACtB,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;;;;IAIlD,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;IAID;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;gBA4BF,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE;IAiC9D;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAKlE;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAa7B;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAOvC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAGlC;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAKlC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAKzC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAK3C;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,sBAAsB,CAErC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,GAAG,GAAG,EACjB,OAAO,GAAE,6BAAkC,GAC1C,sBAAsB,CAAC,CAAC,CAAC;CA2K7B;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,CAE3D"}