@workflow/core 5.0.0-beta.34 → 5.0.0-beta.36

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

@@ -1 +1 @@
-{"version":3,"file":"step-latency.d.ts","sourceRoot":"","sources":["../../src/runtime/step-latency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,2EAA2E;AAC3E,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAkCD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,wEAAwE;IACxE,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB;;;;;;;;OAQG;IACH,sBAAsB,EAAE,OAAO,CAAC;IAChC,0EAA0E;IAC1E,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,yDAAyD;IACzD,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;;;;OAQG;IACH,2BAA2B,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD;;;;;OAKG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;IAChC,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,mBAAmB,GAAG,SAAS,CA4ElC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,QAAQ,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAC1C,4EAA4E;IAC5E,mBAAmB,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,aAAa,EAAE,OAAO,CAAC;IACvB,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;CAC1B,GAAG,oBAAoB,GAAG,SAAS,CAiDnC"}
+{"version":3,"file":"step-latency.d.ts","sourceRoot":"","sources":["../../src/runtime/step-latency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAC;CAChB;AAYD,2EAA2E;AAC3E,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAkCD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,wEAAwE;IACxE,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB;;;;;;;;OAQG;IACH,sBAAsB,EAAE,OAAO,CAAC;IAChC,0EAA0E;IAC1E,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;;;;OAQG;IACH,2BAA2B,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD;;;;;OAKG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;IAChC,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,mBAAmB,GAAG,SAAS,CAuFlC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,QAAQ,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAC1C,4EAA4E;IAC5E,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,qBAAqB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,aAAa,EAAE,OAAO,CAAC;IACvB,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;CAC1B,GAAG,oBAAoB,GAAG,SAAS,CAoFnC"}

package/dist/runtime/step-latency.js

@@ -1,3 +1,12 @@
+/**
+ * Most negative raw duration still attributed to cross-machine clock skew
+ * (and clamped to 0). Anything more negative means a corrupt anchor — e.g. a
+ * mis-decoded run-ID timestamp — and the sample is dropped instead: a
+ * systematically corrupt anchor would otherwise report an exact-zero latency
+ * on every sample, silently dragging entire percentile distributions to 0
+ * rather than surfacing as missing data.
+ */
+const MAX_CLOCK_SKEW_MS = 60_000;
 /**
  * Event types that disqualify TTFS when present in the event log at the time
  * the run's first step batch is scheduled:
@@ -80,6 +89,9 @@ export function computeStepLatencyTracking(params) {
         stepCount = terminalStepIds.size;
         eventCount = events.length;
     }
+    // RSFS shares TTFS's eligibility exactly (same event-log/wait checks),
+    // plus its own anchor being recoverable.
+    const rsfsEligible = ttfsEligible && params.runStartedReceivedAtMs !== undefined;
     if (!ttfsEligible && prevStepEndMs === undefined) {
         return undefined;
     }
@@ -95,6 +107,12 @@ export function computeStepLatencyTracking(params) {
                 ...(preStepAttrStartMs !== undefined ? { preStepAttrStartMs } : {}),
             }
             : {}),
+        ...(rsfsEligible
+            ? {
+                rsfsAnchorMs: params.runStartedReceivedAtMs,
+                replayMs: params.replayMs,
+            }
+            : {}),
         ...(prevStepEndMs !== undefined
             ? { prevStepEndMs, stepCount, eventCount }
             : {}),
@@ -113,8 +131,11 @@ export function computeStepLatencyEventData(params) {
     if (!tracking || params.attempt !== 1) {
         return undefined;
     }
-    // Clamp at 0: cross-invocation timestamps can come from another machine's
-    // clock, so small skews must not produce negative durations.
+    // Small negative durations clamp to 0: cross-invocation timestamps can
+    // come from another machine's clock, so bounded skew must not produce
+    // negative values. Durations more negative than MAX_CLOCK_SKEW_MS are not
+    // skew but a corrupt anchor, and the sample is dropped (see the constant's
+    // doc comment).
     //
     // A pre-step setAttributes detour ends the measurement at the first attr
     // write instead of the step's code start — the remainder is the duration
@@ -124,11 +145,40 @@ export function computeStepLatencyEventData(params) {
     // BEFORE the attr write — hook writes after the window closed are excluded
     // by computeStepLatencyTracking (see preStepBlockingBeforeAttrMs).
     const ttfsEndMs = tracking.preStepAttrStartMs ?? params.stepCodeStartedAtMs;
-    const ttfs = tracking.ttfsAnchorMs !== undefined
-        ? Math.max(0, ttfsEndMs - tracking.ttfsAnchorMs - (tracking.preStepBlockingMs ?? 0))
+    const rawTtfs = tracking.ttfsAnchorMs !== undefined
+        ? ttfsEndMs - tracking.ttfsAnchorMs - (tracking.preStepBlockingMs ?? 0)
+        : undefined;
+    const ttfs = rawTtfs !== undefined && rawTtfs >= -MAX_CLOCK_SKEW_MS
+        ? Math.max(0, rawTtfs)
+        : undefined;
+    const rawStso = tracking.prevStepEndMs !== undefined
+        ? params.stepCodeStartedAtMs - tracking.prevStepEndMs
+        : undefined;
+    const stso = rawStso !== undefined && rawStso >= -MAX_CLOCK_SKEW_MS
+        ? Math.max(0, rawStso)
+        : undefined;
+    // RSFS ends at the actual start-POST instant, not at ttfsEndMs — unlike
+    // TTFS it is not subject to the pre-step attr-write shortcut, so a
+    // pre-step setAttributes detour (rare) makes RSFS include the detour
+    // while TTFS excludes it. `finalSchedulingReplay` is a direct passthrough
+    // of `tracking.replayMs` — the FINAL replay pass only (see
+    // StepLatencyTracking.replayMs) — so no further subtraction applies, but
+    // it also means it is NOT accumulated across any earlier pre-first-step
+    // passes (e.g. a setAttributes detour) and must not be read as "the
+    // replay portion of rsfs"; rsfs covers the whole window.
+    //
+    // finalSchedulingReplay duplicates what OTEL already captures on the run/invocation
+    // span, but is deliberately collected as client telemetry so the server
+    // can emit it as an UNSAMPLED, full-population metric: workflow-server's
+    // server spans are heavily sampled in production (~7%), and client spans
+    // can't be filtered by SDK version, so neither can serve as the
+    // dashboard's exact TTFS decomposition.
+    const rsfs = tracking.rsfsAnchorMs !== undefined &&
+        params.stepStartPostSentAtMs !== undefined
+        ? Math.max(0, params.stepStartPostSentAtMs - tracking.rsfsAnchorMs)
         : undefined;
-    const stso = tracking.prevStepEndMs !== undefined
-        ? Math.max(0, params.stepCodeStartedAtMs - tracking.prevStepEndMs)
+    const finalSchedulingReplay = tracking.replayMs !== undefined
+        ? Math.max(0, tracking.replayMs)
         : undefined;
     if (ttfs === undefined && stso === undefined) {
         return undefined;
@@ -149,7 +199,9 @@ export function computeStepLatencyEventData(params) {
         ...(stso !== undefined && tracking.eventCount !== undefined
             ? { eventCount: tracking.eventCount }
             : {}),
+        ...(rsfs !== undefined ? { rsfs } : {}),
+        ...(finalSchedulingReplay !== undefined ? { finalSchedulingReplay } : {}),
         optimizations,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-latency.js","sourceRoot":"","sources":["../../src/runtime/step-latency.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event } from '@workflow/world';\n\n/**\n * Client-side latency measurement (TTFS / STSO) threaded from the\n * orchestrator's inline execution path into `executeStep`.\n *\n * TTFS (time-to-first-step) measures run creation → the first step's body\n * beginning to execute. STSO (step-to-step overhead) measures the previous\n * step's terminal event → the next step's body beginning to execute. Both are\n * attached to the step's terminal event so a backend can emit latency metrics\n * from the event write alone, without extra event-log queries.\n *\n * Eligibility is decided by the orchestrator (which owns the event log) via\n * {@link computeStepLatencyTracking}; the final values are computed by\n * `executeStep` right before user code runs via\n * {@link computeStepLatencyEventData}.\n */\nexport interface StepLatencyTracking {\n  /**\n   * Epoch ms of run creation (from the run-id ULID, falling back to the run\n   * snapshot's `createdAt`). Present only when the step qualifies for TTFS.\n   */\n  ttfsAnchorMs?: number;\n  /**\n   * Wall-clock ms this invocation spent committing `hook_created` events\n   * before the first step (fire-and-forget `createHook()` ahead of the first\n   * step commits in the same suspension batch). Subtracted from TTFS so the\n   * metric reflects runtime overhead rather than the user's hook writes.\n   */\n  preStepBlockingMs?: number;\n  /**\n   * Epoch ms the first pre-step `attr_set` write began (its client-stamped\n   * `occurredAt`, falling back to `createdAt`). When present, the TTFS\n   * measurement ENDS here instead of at the step's code start: a\n   * workflow-body `setAttributes` before the first step\n   * resolves through an extra replay (see the `hasAttributeEvents` branch in\n   * runtime.ts), so everything from this write until the step body runs is\n   * the duration of the setAttributes call — which is subtracted by ending\n   * the measurement at the point where the step would otherwise have been\n   * scheduled.\n   */\n  preStepAttrStartMs?: number;\n  /**\n   * Epoch ms the previous step's terminal event was recorded (its\n   * client-stamped `occurredAt`, falling back to `createdAt`). Present only\n   * when the step qualifies for STSO.\n   */\n  prevStepEndMs?: number;\n  /** Number of unique terminal steps already in the event log. */\n  stepCount?: number;\n  /** Number of events already in the event log. */\n  eventCount?: number;\n  /** Whether turbo mode is active for this invocation. */\n  turbo: boolean;\n}\n\n/** Latency telemetry attached to a step's terminal event's `eventData`. */\nexport interface StepLatencyEventData {\n  ttfs?: number;\n  stso?: number;\n  stepCount?: number;\n  eventCount?: number;\n  optimizations?: string[];\n}\n\n/**\n * Event types that disqualify TTFS when present in the event log at the time\n * the run's first step batch is scheduled:\n *\n * - Any step event means this is not the run's first step execution.\n * - `hook_received` / `wait_created` / `wait_completed` mean the run's path to\n *   the first step depended on user-driven timing (a webhook arriving, a\n *   sleep elapsing), so the measurement would not reflect runtime overhead.\n *\n * Deliberately absent, with their cost subtracted instead:\n *\n * - `hook_created`: a fire-and-forget `createHook()` before the first step\n *   commits in the same invocation, whose measured duration is subtracted via\n *   {@link StepLatencyTracking.preStepBlockingMs}.\n * - `attr_set` (workflow-body `setAttributes`): resolves through\n *   an extra replay before steps run. Subtracted by ending the measurement at\n *   the first attr write's timestamp instead — see\n *   {@link StepLatencyTracking.preStepAttrStartMs}.\n */\nconst TTFS_DISQUALIFYING_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set(\n  [\n    'step_created',\n    'step_started',\n    'step_completed',\n    'step_failed',\n    'step_retrying',\n    'hook_received',\n    'wait_created',\n    'wait_completed',\n  ]\n);\n\n/**\n * Decide, from the orchestrator's view of the event log, whether the inline\n * step batch about to execute qualifies for TTFS and/or STSO measurement.\n * Returns undefined when neither applies. Called once per batch; the result\n * is passed to the batch's first step only, so a parallel first batch emits a\n * single sample rather than one per sibling.\n */\nexport function computeStepLatencyTracking(params: {\n  /** The orchestrator's current in-memory event log (ascending order). */\n  events: Event[];\n  /**\n   * Whether this invocation's initial event load contained nothing beyond\n   * run_created/run_started/attr_set. Pre-existing hook events were written\n   * by an earlier invocation, so the time they added (including the queue\n   * hop back to this invocation) is unmeasurable and disqualifies TTFS.\n   * attr_set is permitted: a redelivery can land after a committed pre-step\n   * attr_set, and the detour it marks is subtracted via `preStepAttrStartMs`\n   * regardless of which invocation wrote it.\n   */\n  invocationStartedClean: boolean;\n  /** Epoch ms of run creation, if recoverable. Absent disqualifies TTFS. */\n  runCreatedAtMs: number | undefined;\n  /** See {@link StepLatencyTracking.preStepBlockingMs}. */\n  preStepBlockingMs: number;\n  /**\n   * The accumulator's value as of the suspension that wrote the run's first\n   * attr_set (its hook phase runs before its attr writes). When the\n   * measurement ends at the attr write, only hook time from before that\n   * point may be subtracted — later hook writes fall outside the measured\n   * window. Undefined when no attr suspension happened in this invocation\n   * (e.g. the attr_set was loaded from a redelivery's snapshot, where no\n   * same-invocation hook time precedes it).\n   */\n  preStepBlockingBeforeAttrMs: number | undefined;\n  /**\n   * Whether the suspension that scheduled this batch also created waits.\n   * Those `wait_created` writes are not in `events` yet (they were committed\n   * by this very suspension pass), so they must be reported separately. A\n   * wait disqualifies both measurements.\n   */\n  suspensionHasWaits: boolean;\n  /**\n   * Whether the suspension that scheduled this batch also created hooks\n   * (also not in `events` yet). Hooks keep TTFS eligible — their measured\n   * write time is subtracted via `preStepBlockingMs` — but disqualify STSO,\n   * which is only meaningful for a pure back-to-back step gap.\n   */\n  suspensionCreatedHooks: boolean;\n  /** Whether turbo mode is active for this invocation. */\n  turbo: boolean;\n}): StepLatencyTracking | undefined {\n  const { events } = params;\n\n  let ttfsEligible =\n    params.invocationStartedClean &&\n    params.runCreatedAtMs !== undefined &&\n    !params.suspensionHasWaits;\n  let preStepAttrStartMs: number | undefined;\n  if (ttfsEligible) {\n    for (const event of events) {\n      if (TTFS_DISQUALIFYING_EVENT_TYPES.has(event.eventType)) {\n        ttfsEligible = false;\n        break;\n      }\n      if (event.eventType === 'attr_set') {\n        const attrStartMs = +(event.occurredAt ?? event.createdAt);\n        preStepAttrStartMs =\n          preStepAttrStartMs === undefined\n            ? attrStartMs\n            : Math.min(preStepAttrStartMs, attrStartMs);\n      }\n    }\n  }\n\n  // STSO: the two steps ran back-to-back — the newest known event is the\n  // previous step's terminal event, with nothing (hook_received, waits,\n  // attr_set, ...) in between and this suspension scheduling nothing but\n  // steps.\n  let prevStepEndMs: number | undefined;\n  let stepCount: number | undefined;\n  let eventCount: number | undefined;\n  const lastEvent = events[events.length - 1];\n  if (\n    !params.suspensionHasWaits &&\n    !params.suspensionCreatedHooks &&\n    lastEvent &&\n    (lastEvent.eventType === 'step_completed' ||\n      lastEvent.eventType === 'step_failed')\n  ) {\n    prevStepEndMs = +(lastEvent.occurredAt ?? lastEvent.createdAt);\n    const terminalStepIds = new Set<string>();\n    for (const event of events) {\n      if (\n        (event.eventType === 'step_completed' ||\n          event.eventType === 'step_failed') &&\n        event.correlationId !== undefined\n      ) {\n        terminalStepIds.add(event.correlationId);\n      }\n    }\n    stepCount = terminalStepIds.size;\n    eventCount = events.length;\n  }\n\n  if (!ttfsEligible && prevStepEndMs === undefined) {\n    return undefined;\n  }\n\n  return {\n    ...(ttfsEligible\n      ? {\n          ttfsAnchorMs: params.runCreatedAtMs,\n          // When the measurement ends at the first attr write, only hook\n          // time from before that point is inside the measured window.\n          preStepBlockingMs:\n            preStepAttrStartMs !== undefined\n              ? (params.preStepBlockingBeforeAttrMs ?? 0)\n              : params.preStepBlockingMs,\n          ...(preStepAttrStartMs !== undefined ? { preStepAttrStartMs } : {}),\n        }\n      : {}),\n    ...(prevStepEndMs !== undefined\n      ? { prevStepEndMs, stepCount, eventCount }\n      : {}),\n    turbo: params.turbo,\n  };\n}\n\n/**\n * Compute the latency telemetry to attach to the step's terminal event.\n * Called by `executeStep` with the wall-clock timestamp taken immediately\n * before user step code runs. Returns undefined when there is nothing to\n * report (no tracking, or a retry attempt — retries measure neither TTFS nor\n * STSO).\n */\nexport function computeStepLatencyEventData(params: {\n  tracking: StepLatencyTracking | undefined;\n  /** `Date.now()` taken immediately before user step code began executing. */\n  stepCodeStartedAtMs: number;\n  attempt: number;\n  /** Whether this step was started lazily (no separate step_created write). */\n  lazyStepStart: boolean;\n  /** Whether the body ran optimistically, without awaiting step_started. */\n  optimisticStart: boolean;\n}): StepLatencyEventData | undefined {\n  const { tracking } = params;\n  if (!tracking || params.attempt !== 1) {\n    return undefined;\n  }\n\n  // Clamp at 0: cross-invocation timestamps can come from another machine's\n  // clock, so small skews must not produce negative durations.\n  //\n  // A pre-step setAttributes detour ends the measurement at the first attr\n  // write instead of the step's code start — the remainder is the duration\n  // of the setAttributes call (resolved via an extra replay), which is\n  // subtracted rather than disqualifying the sample. In that case\n  // `tracking.preStepBlockingMs` already holds only the hook time from\n  // BEFORE the attr write — hook writes after the window closed are excluded\n  // by computeStepLatencyTracking (see preStepBlockingBeforeAttrMs).\n  const ttfsEndMs = tracking.preStepAttrStartMs ?? params.stepCodeStartedAtMs;\n  const ttfs =\n    tracking.ttfsAnchorMs !== undefined\n      ? Math.max(\n          0,\n          ttfsEndMs - tracking.ttfsAnchorMs - (tracking.preStepBlockingMs ?? 0)\n        )\n      : undefined;\n  const stso =\n    tracking.prevStepEndMs !== undefined\n      ? Math.max(0, params.stepCodeStartedAtMs - tracking.prevStepEndMs)\n      : undefined;\n\n  if (ttfs === undefined && stso === undefined) {\n    return undefined;\n  }\n\n  const optimizations: string[] = [];\n  if (tracking.turbo) optimizations.push('turbo');\n  if (params.lazyStepStart) optimizations.push('lazyStepStart');\n  if (params.optimisticStart) optimizations.push('optimisticStart');\n\n  return {\n    ...(ttfs !== undefined ? { ttfs } : {}),\n    ...(stso !== undefined ? { stso } : {}),\n    ...(stso !== undefined && tracking.stepCount !== undefined\n      ? { stepCount: tracking.stepCount }\n      : {}),\n    ...(stso !== undefined && tracking.eventCount !== undefined\n      ? { eventCount: tracking.eventCount }\n      : {}),\n    optimizations,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-latency.js","sourceRoot":"","sources":["../../src/runtime/step-latency.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event } from '@workflow/world';\n\n/**\n * Client-side latency measurement (TTFS / STSO / RSFS) threaded from the\n * orchestrator's inline execution path into `executeStep`.\n *\n * TTFS (time-to-first-step) measures run creation → the first step's body\n * beginning to execute. STSO (step-to-step overhead) measures the previous\n * step's terminal event → the next step's body beginning to execute. RSFS\n * (run-started-to-first-step) measures the `run_started` response landing →\n * the first step's start POST being issued — a sub-window of TTFS that\n * isolates replay overhead from the run-creation queue hop; `finalSchedulingReplay`\n * is the synchronous workflow-function-execution duration of only the FINAL\n * replay pass within that window (the pass that reached and scheduled the\n * first step) — it is NOT accumulated across earlier pre-first-step passes\n * (see {@link StepLatencyTracking.replayMs}), so it must not be read as \"the\n * replay portion of RSFS\". All are attached to the step's terminal\n * event so a backend can emit latency metrics from the event write alone,\n * without extra event-log queries.\n *\n * Eligibility is decided by the orchestrator (which owns the event log) via\n * {@link computeStepLatencyTracking}; the final values are computed by\n * `executeStep` right before user code runs via\n * {@link computeStepLatencyEventData}.\n */\nexport interface StepLatencyTracking {\n  /**\n   * Epoch ms of run creation (from the run-id ULID, falling back to the run\n   * snapshot's `createdAt`). Present only when the step qualifies for TTFS.\n   */\n  ttfsAnchorMs?: number;\n  /**\n   * Wall-clock ms this invocation spent committing `hook_created` events\n   * before the first step (fire-and-forget `createHook()` ahead of the first\n   * step commits in the same suspension batch). Subtracted from TTFS so the\n   * metric reflects runtime overhead rather than the user's hook writes.\n   */\n  preStepBlockingMs?: number;\n  /**\n   * Epoch ms the first pre-step `attr_set` write began (its client-stamped\n   * `occurredAt`, falling back to `createdAt`). When present, the TTFS\n   * measurement ENDS here instead of at the step's code start: a\n   * workflow-body `setAttributes` before the first step\n   * resolves through an extra replay (see the `hasAttributeEvents` branch in\n   * runtime.ts), so everything from this write until the step body runs is\n   * the duration of the setAttributes call — which is subtracted by ending\n   * the measurement at the point where the step would otherwise have been\n   * scheduled.\n   */\n  preStepAttrStartMs?: number;\n  /**\n   * Epoch ms the previous step's terminal event was recorded (its\n   * client-stamped `occurredAt`, falling back to `createdAt`). Present only\n   * when the step qualifies for STSO.\n   */\n  prevStepEndMs?: number;\n  /** Number of unique terminal steps already in the event log. */\n  stepCount?: number;\n  /** Number of events already in the event log. */\n  eventCount?: number;\n  /**\n   * Epoch ms the `run_started` response was received/parsed by the SDK.\n   * Present only when the step qualifies for RSFS — the same eligibility as\n   * TTFS (see {@link computeStepLatencyTracking}), plus a recoverable\n   * anchor. In turbo mode, `run_started` is backgrounded rather than\n   * awaited, so this is stamped at the point the runtime synthesizes the\n   * run locally and begins replay instead of at the real response; the\n   * first step's start POST is still chained on the real `run_started`\n   * promise (see step-executor.ts), so RSFS still ends up measuring the\n   * genuine run_started-to-first-step-POST stretch even though the two\n   * halves overlap under turbo.\n   */\n  rsfsAnchorMs?: number;\n  /**\n   * Wall-clock ms this invocation's synchronous workflow-function replay\n   * took: from calling `runWorkflow` to it throwing the suspension that\n   * scheduled this batch. Excludes awaited network I/O (the suspension's\n   * event commits, the step's own start POST). Present only alongside\n   * `rsfsAnchorMs`.\n   *\n   * This is the FINAL replay pass only — the invocation that reached and\n   * scheduled the first step. Valid RSFS paths can replay more than once\n   * before the first step (e.g. a workflow-body `setAttributes()` detour\n   * replays twice), and a redelivery omits earlier invocations' replay work\n   * entirely; this value is not accumulated across those earlier passes.\n   * Do not read it as \"the replay portion of RSFS\" — RSFS\n   * ({@link rsfsAnchorMs}) covers the whole run_started-to-first-step\n   * window, this covers only the last pass.\n   */\n  replayMs?: number;\n  /** Whether turbo mode is active for this invocation. */\n  turbo: boolean;\n}\n\n/**\n * Most negative raw duration still attributed to cross-machine clock skew\n * (and clamped to 0). Anything more negative means a corrupt anchor — e.g. a\n * mis-decoded run-ID timestamp — and the sample is dropped instead: a\n * systematically corrupt anchor would otherwise report an exact-zero latency\n * on every sample, silently dragging entire percentile distributions to 0\n * rather than surfacing as missing data.\n */\nconst MAX_CLOCK_SKEW_MS = 60_000;\n\n/** Latency telemetry attached to a step's terminal event's `eventData`. */\nexport interface StepLatencyEventData {\n  ttfs?: number;\n  stso?: number;\n  stepCount?: number;\n  eventCount?: number;\n  /** Client-measured run_started → first step's start POST, ms. */\n  rsfs?: number;\n  /**\n   * Client-measured wall-clock ms of the FINAL replay pass that scheduled\n   * the first step (see {@link StepLatencyTracking.replayMs}) — not\n   * accumulated across earlier pre-first-step passes, so it must not be\n   * read as \"the replay portion of `rsfs`\".\n   */\n  finalSchedulingReplay?: number;\n  optimizations?: string[];\n}\n\n/**\n * Event types that disqualify TTFS when present in the event log at the time\n * the run's first step batch is scheduled:\n *\n * - Any step event means this is not the run's first step execution.\n * - `hook_received` / `wait_created` / `wait_completed` mean the run's path to\n *   the first step depended on user-driven timing (a webhook arriving, a\n *   sleep elapsing), so the measurement would not reflect runtime overhead.\n *\n * Deliberately absent, with their cost subtracted instead:\n *\n * - `hook_created`: a fire-and-forget `createHook()` before the first step\n *   commits in the same invocation, whose measured duration is subtracted via\n *   {@link StepLatencyTracking.preStepBlockingMs}.\n * - `attr_set` (workflow-body `setAttributes`): resolves through\n *   an extra replay before steps run. Subtracted by ending the measurement at\n *   the first attr write's timestamp instead — see\n *   {@link StepLatencyTracking.preStepAttrStartMs}.\n */\nconst TTFS_DISQUALIFYING_EVENT_TYPES: ReadonlySet<Event['eventType']> = new Set(\n  [\n    'step_created',\n    'step_started',\n    'step_completed',\n    'step_failed',\n    'step_retrying',\n    'hook_received',\n    'wait_created',\n    'wait_completed',\n  ]\n);\n\n/**\n * Decide, from the orchestrator's view of the event log, whether the inline\n * step batch about to execute qualifies for TTFS and/or STSO measurement.\n * Returns undefined when neither applies. Called once per batch; the result\n * is passed to the batch's first step only, so a parallel first batch emits a\n * single sample rather than one per sibling.\n */\nexport function computeStepLatencyTracking(params: {\n  /** The orchestrator's current in-memory event log (ascending order). */\n  events: Event[];\n  /**\n   * Whether this invocation's initial event load contained nothing beyond\n   * run_created/run_started/attr_set. Pre-existing hook events were written\n   * by an earlier invocation, so the time they added (including the queue\n   * hop back to this invocation) is unmeasurable and disqualifies TTFS.\n   * attr_set is permitted: a redelivery can land after a committed pre-step\n   * attr_set, and the detour it marks is subtracted via `preStepAttrStartMs`\n   * regardless of which invocation wrote it.\n   */\n  invocationStartedClean: boolean;\n  /** Epoch ms of run creation, if recoverable. Absent disqualifies TTFS. */\n  runCreatedAtMs: number | undefined;\n  /**\n   * Epoch ms the `run_started` response was received/parsed by the SDK (or,\n   * under turbo, the instant the run was synthesized locally — see\n   * {@link StepLatencyTracking.rsfsAnchorMs}). Absent disqualifies RSFS.\n   */\n  runStartedReceivedAtMs: number | undefined;\n  /**\n   * Wall-clock ms this suspension's `runWorkflow` call spent executing\n   * synchronously before throwing — the FINAL replay pass only, not\n   * accumulated across earlier passes. See\n   * {@link StepLatencyTracking.replayMs}.\n   */\n  replayMs: number;\n  /** See {@link StepLatencyTracking.preStepBlockingMs}. */\n  preStepBlockingMs: number;\n  /**\n   * The accumulator's value as of the suspension that wrote the run's first\n   * attr_set (its hook phase runs before its attr writes). When the\n   * measurement ends at the attr write, only hook time from before that\n   * point may be subtracted — later hook writes fall outside the measured\n   * window. Undefined when no attr suspension happened in this invocation\n   * (e.g. the attr_set was loaded from a redelivery's snapshot, where no\n   * same-invocation hook time precedes it).\n   */\n  preStepBlockingBeforeAttrMs: number | undefined;\n  /**\n   * Whether the suspension that scheduled this batch also created waits.\n   * Those `wait_created` writes are not in `events` yet (they were committed\n   * by this very suspension pass), so they must be reported separately. A\n   * wait disqualifies both measurements.\n   */\n  suspensionHasWaits: boolean;\n  /**\n   * Whether the suspension that scheduled this batch also created hooks\n   * (also not in `events` yet). Hooks keep TTFS eligible — their measured\n   * write time is subtracted via `preStepBlockingMs` — but disqualify STSO,\n   * which is only meaningful for a pure back-to-back step gap.\n   */\n  suspensionCreatedHooks: boolean;\n  /** Whether turbo mode is active for this invocation. */\n  turbo: boolean;\n}): StepLatencyTracking | undefined {\n  const { events } = params;\n\n  let ttfsEligible =\n    params.invocationStartedClean &&\n    params.runCreatedAtMs !== undefined &&\n    !params.suspensionHasWaits;\n  let preStepAttrStartMs: number | undefined;\n  if (ttfsEligible) {\n    for (const event of events) {\n      if (TTFS_DISQUALIFYING_EVENT_TYPES.has(event.eventType)) {\n        ttfsEligible = false;\n        break;\n      }\n      if (event.eventType === 'attr_set') {\n        const attrStartMs = +(event.occurredAt ?? event.createdAt);\n        preStepAttrStartMs =\n          preStepAttrStartMs === undefined\n            ? attrStartMs\n            : Math.min(preStepAttrStartMs, attrStartMs);\n      }\n    }\n  }\n\n  // STSO: the two steps ran back-to-back — the newest known event is the\n  // previous step's terminal event, with nothing (hook_received, waits,\n  // attr_set, ...) in between and this suspension scheduling nothing but\n  // steps.\n  let prevStepEndMs: number | undefined;\n  let stepCount: number | undefined;\n  let eventCount: number | undefined;\n  const lastEvent = events[events.length - 1];\n  if (\n    !params.suspensionHasWaits &&\n    !params.suspensionCreatedHooks &&\n    lastEvent &&\n    (lastEvent.eventType === 'step_completed' ||\n      lastEvent.eventType === 'step_failed')\n  ) {\n    prevStepEndMs = +(lastEvent.occurredAt ?? lastEvent.createdAt);\n    const terminalStepIds = new Set<string>();\n    for (const event of events) {\n      if (\n        (event.eventType === 'step_completed' ||\n          event.eventType === 'step_failed') &&\n        event.correlationId !== undefined\n      ) {\n        terminalStepIds.add(event.correlationId);\n      }\n    }\n    stepCount = terminalStepIds.size;\n    eventCount = events.length;\n  }\n\n  // RSFS shares TTFS's eligibility exactly (same event-log/wait checks),\n  // plus its own anchor being recoverable.\n  const rsfsEligible =\n    ttfsEligible && params.runStartedReceivedAtMs !== undefined;\n\n  if (!ttfsEligible && prevStepEndMs === undefined) {\n    return undefined;\n  }\n\n  return {\n    ...(ttfsEligible\n      ? {\n          ttfsAnchorMs: params.runCreatedAtMs,\n          // When the measurement ends at the first attr write, only hook\n          // time from before that point is inside the measured window.\n          preStepBlockingMs:\n            preStepAttrStartMs !== undefined\n              ? (params.preStepBlockingBeforeAttrMs ?? 0)\n              : params.preStepBlockingMs,\n          ...(preStepAttrStartMs !== undefined ? { preStepAttrStartMs } : {}),\n        }\n      : {}),\n    ...(rsfsEligible\n      ? {\n          rsfsAnchorMs: params.runStartedReceivedAtMs,\n          replayMs: params.replayMs,\n        }\n      : {}),\n    ...(prevStepEndMs !== undefined\n      ? { prevStepEndMs, stepCount, eventCount }\n      : {}),\n    turbo: params.turbo,\n  };\n}\n\n/**\n * Compute the latency telemetry to attach to the step's terminal event.\n * Called by `executeStep` with the wall-clock timestamp taken immediately\n * before user step code runs. Returns undefined when there is nothing to\n * report (no tracking, or a retry attempt — retries measure neither TTFS nor\n * STSO).\n */\nexport function computeStepLatencyEventData(params: {\n  tracking: StepLatencyTracking | undefined;\n  /** `Date.now()` taken immediately before user step code began executing. */\n  stepCodeStartedAtMs: number;\n  /**\n   * `Date.now()` taken immediately before the first step's start POST\n   * (`step_started`) was issued. Present only for the lazy inline steps RSFS\n   * cares about; see the call sites in step-executor.ts.\n   */\n  stepStartPostSentAtMs: number | undefined;\n  attempt: number;\n  /** Whether this step was started lazily (no separate step_created write). */\n  lazyStepStart: boolean;\n  /** Whether the body ran optimistically, without awaiting step_started. */\n  optimisticStart: boolean;\n}): StepLatencyEventData | undefined {\n  const { tracking } = params;\n  if (!tracking || params.attempt !== 1) {\n    return undefined;\n  }\n\n  // Small negative durations clamp to 0: cross-invocation timestamps can\n  // come from another machine's clock, so bounded skew must not produce\n  // negative values. Durations more negative than MAX_CLOCK_SKEW_MS are not\n  // skew but a corrupt anchor, and the sample is dropped (see the constant's\n  // doc comment).\n  //\n  // A pre-step setAttributes detour ends the measurement at the first attr\n  // write instead of the step's code start — the remainder is the duration\n  // of the setAttributes call (resolved via an extra replay), which is\n  // subtracted rather than disqualifying the sample. In that case\n  // `tracking.preStepBlockingMs` already holds only the hook time from\n  // BEFORE the attr write — hook writes after the window closed are excluded\n  // by computeStepLatencyTracking (see preStepBlockingBeforeAttrMs).\n  const ttfsEndMs = tracking.preStepAttrStartMs ?? params.stepCodeStartedAtMs;\n  const rawTtfs =\n    tracking.ttfsAnchorMs !== undefined\n      ? ttfsEndMs - tracking.ttfsAnchorMs - (tracking.preStepBlockingMs ?? 0)\n      : undefined;\n  const ttfs =\n    rawTtfs !== undefined && rawTtfs >= -MAX_CLOCK_SKEW_MS\n      ? Math.max(0, rawTtfs)\n      : undefined;\n  const rawStso =\n    tracking.prevStepEndMs !== undefined\n      ? params.stepCodeStartedAtMs - tracking.prevStepEndMs\n      : undefined;\n  const stso =\n    rawStso !== undefined && rawStso >= -MAX_CLOCK_SKEW_MS\n      ? Math.max(0, rawStso)\n      : undefined;\n  // RSFS ends at the actual start-POST instant, not at ttfsEndMs — unlike\n  // TTFS it is not subject to the pre-step attr-write shortcut, so a\n  // pre-step setAttributes detour (rare) makes RSFS include the detour\n  // while TTFS excludes it. `finalSchedulingReplay` is a direct passthrough\n  // of `tracking.replayMs` — the FINAL replay pass only (see\n  // StepLatencyTracking.replayMs) — so no further subtraction applies, but\n  // it also means it is NOT accumulated across any earlier pre-first-step\n  // passes (e.g. a setAttributes detour) and must not be read as \"the\n  // replay portion of rsfs\"; rsfs covers the whole window.\n  //\n  // finalSchedulingReplay duplicates what OTEL already captures on the run/invocation\n  // span, but is deliberately collected as client telemetry so the server\n  // can emit it as an UNSAMPLED, full-population metric: workflow-server's\n  // server spans are heavily sampled in production (~7%), and client spans\n  // can't be filtered by SDK version, so neither can serve as the\n  // dashboard's exact TTFS decomposition.\n  const rsfs =\n    tracking.rsfsAnchorMs !== undefined &&\n    params.stepStartPostSentAtMs !== undefined\n      ? Math.max(0, params.stepStartPostSentAtMs - tracking.rsfsAnchorMs)\n      : undefined;\n  const finalSchedulingReplay =\n    tracking.replayMs !== undefined\n      ? Math.max(0, tracking.replayMs)\n      : undefined;\n\n  if (ttfs === undefined && stso === undefined) {\n    return undefined;\n  }\n\n  const optimizations: string[] = [];\n  if (tracking.turbo) optimizations.push('turbo');\n  if (params.lazyStepStart) optimizations.push('lazyStepStart');\n  if (params.optimisticStart) optimizations.push('optimisticStart');\n\n  return {\n    ...(ttfs !== undefined ? { ttfs } : {}),\n    ...(stso !== undefined ? { stso } : {}),\n    ...(stso !== undefined && tracking.stepCount !== undefined\n      ? { stepCount: tracking.stepCount }\n      : {}),\n    ...(stso !== undefined && tracking.eventCount !== undefined\n      ? { eventCount: tracking.eventCount }\n      : {}),\n    ...(rsfs !== undefined ? { rsfs } : {}),\n    ...(finalSchedulingReplay !== undefined ? { finalSchedulingReplay } : {}),\n    optimizations,\n  };\n}\n"]}

package/dist/runtime/suspension-handler.d.ts

@@ -1,12 +1,21 @@
 import type { Span } from '@opentelemetry/api';
 import { type SerializedData, type WorkflowRun, type World } from '@workflow/world';
 import type { StepInvocationQueueItem, WorkflowSuspension } from '../global.js';
+import { type MutableEventLog } from './helpers.js';
 export interface SuspensionHandlerParams {
     suspension: WorkflowSuspension;
     world: World;
     run: WorkflowRun;
     span?: Span;
     requestId?: string;
+    /**
+     * The runtime's loaded event log. Each event creation is sent with this
+     * snapshot's `stateUpdatedAt` and, if the backend rejects it as stale (412),
+     * the log is reloaded in place and the create is retried — see
+     * `withPreconditionRetry`. Guarding per-create (rather than the whole
+     * suspension) ensures a retry never re-issues an already-created event.
+     */
+    eventLog?: MutableEventLog;
     /**
      * Turbo mode only: a promise that resolves once the backgrounded
      * `run_started` has landed (the run exists). When present, every world write
@@ -94,5 +103,5 @@ export interface SuspensionHandlerResult {
  * 1. Hooks are processed first to prevent race conditions with webhook receivers
  * 2. Step events and wait events are created in parallel
  */
-export declare function handleSuspension({ suspension, world, run, span, requestId, runReadyBarrier, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
+export declare function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
 //# sourceMappingURL=suspension-handler.d.ts.map

package/dist/runtime/suspension-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAQ/C,OAAO,EAGL,KAAK,cAAc,EAGnB,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAGV,uBAAuB,EAEvB,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAOtB,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC;;;;;;;OAOG;IACH,yBAAyB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC;;;;;;;;;;;;OAYG;IACH,eAAe,EAAE,KAAK,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,cAAc,CAAC;KACjC,CAAC,CAAC;IACH;;;;;;OAMG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;IACzB,wFAAwF;IACxF,sBAAsB,EAAE,OAAO,CAAC;IAChC,wEAAwE;IACxE,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;CACxB;AAgED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,EACT,eAAe,GAChB,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA8e5D"}
+{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAQ/C,OAAO,EAKL,KAAK,cAAc,EAGnB,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAGV,uBAAuB,EAEvB,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAMtB,OAAO,EAAE,KAAK,eAAe,EAAyB,MAAM,cAAc,CAAC;AAE3E,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC;;;;;;;OAOG;IACH,yBAAyB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC;;;;;;;;;;;;OAYG;IACH,eAAe,EAAE,KAAK,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,cAAc,CAAC;KACjC,CAAC,CAAC;IACH;;;;;;OAMG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;IACzB,wFAAwF;IACxF,sBAAsB,EAAE,OAAO,CAAC;IAChC,wEAAwE;IACxE,kBAAkB,EAAE,OAAO,CAAC;IAC5B;;;;;;OAMG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;CACxB;AAmED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,eAAe,GAChB,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAigB5D"}