@workflow/core 5.0.0-beta.27 → 5.0.0-beta.29

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

@@ -0,0 +1,125 @@
+import type { Event } from '@workflow/world';
+/**
+ * Client-side latency measurement (TTFS / STSO) threaded from the
+ * orchestrator's inline execution path into `executeStep`.
+ *
+ * TTFS (time-to-first-step) measures run creation → the first step's body
+ * beginning to execute. STSO (step-to-step overhead) measures the previous
+ * step's terminal event → the next step's body beginning to execute. Both are
+ * attached to the step's terminal event so a backend can emit latency metrics
+ * from the event write alone, without extra event-log queries.
+ *
+ * Eligibility is decided by the orchestrator (which owns the event log) via
+ * {@link computeStepLatencyTracking}; the final values are computed by
+ * `executeStep` right before user code runs via
+ * {@link computeStepLatencyEventData}.
+ */
+export interface StepLatencyTracking {
+    /**
+     * Epoch ms of run creation (from the run-id ULID, falling back to the run
+     * snapshot's `createdAt`). Present only when the step qualifies for TTFS.
+     */
+    ttfsAnchorMs?: number;
+    /**
+     * Wall-clock ms this invocation spent committing `hook_created` events
+     * before the first step (fire-and-forget `createHook()` ahead of the first
+     * step commits in the same suspension batch). Subtracted from TTFS so the
+     * metric reflects runtime overhead rather than the user's hook writes.
+     */
+    preStepBlockingMs?: number;
+    /**
+     * Epoch ms the first pre-step `attr_set` write began (its client-stamped
+     * `occurredAt`, falling back to `createdAt`). When present, the TTFS
+     * measurement ENDS here instead of at the step's code start: a
+     * workflow-body `experimental_setAttributes` before the first step
+     * resolves through an extra replay (see the `hasAttributeEvents` branch in
+     * runtime.ts), so everything from this write until the step body runs is
+     * the duration of the setAttributes call — which is subtracted by ending
+     * the measurement at the point where the step would otherwise have been
+     * scheduled.
+     */
+    preStepAttrStartMs?: number;
+    /**
+     * Epoch ms the previous step's terminal event was recorded (its
+     * client-stamped `occurredAt`, falling back to `createdAt`). Present only
+     * when the step qualifies for STSO.
+     */
+    prevStepEndMs?: number;
+    /** Whether turbo mode is active for this invocation. */
+    turbo: boolean;
+}
+/** Latency telemetry attached to a step's terminal event's `eventData`. */
+export interface StepLatencyEventData {
+    ttfs?: number;
+    stso?: number;
+    optimizations?: string[];
+}
+/**
+ * Decide, from the orchestrator's view of the event log, whether the inline
+ * step batch about to execute qualifies for TTFS and/or STSO measurement.
+ * Returns undefined when neither applies. Called once per batch; the result
+ * is passed to the batch's first step only, so a parallel first batch emits a
+ * single sample rather than one per sibling.
+ */
+export declare function computeStepLatencyTracking(params: {
+    /** The orchestrator's current in-memory event log (ascending order). */
+    events: Event[];
+    /**
+     * Whether this invocation's initial event load contained nothing beyond
+     * run_created/run_started/attr_set. Pre-existing hook events were written
+     * by an earlier invocation, so the time they added (including the queue
+     * hop back to this invocation) is unmeasurable and disqualifies TTFS.
+     * attr_set is permitted: a redelivery can land after a committed pre-step
+     * attr_set, and the detour it marks is subtracted via `preStepAttrStartMs`
+     * regardless of which invocation wrote it.
+     */
+    invocationStartedClean: boolean;
+    /** Epoch ms of run creation, if recoverable. Absent disqualifies TTFS. */
+    runCreatedAtMs: number | undefined;
+    /** See {@link StepLatencyTracking.preStepBlockingMs}. */
+    preStepBlockingMs: number;
+    /**
+     * The accumulator's value as of the suspension that wrote the run's first
+     * attr_set (its hook phase runs before its attr writes). When the
+     * measurement ends at the attr write, only hook time from before that
+     * point may be subtracted — later hook writes fall outside the measured
+     * window. Undefined when no attr suspension happened in this invocation
+     * (e.g. the attr_set was loaded from a redelivery's snapshot, where no
+     * same-invocation hook time precedes it).
+     */
+    preStepBlockingBeforeAttrMs: number | undefined;
+    /**
+     * Whether the suspension that scheduled this batch also created waits.
+     * Those `wait_created` writes are not in `events` yet (they were committed
+     * by this very suspension pass), so they must be reported separately. A
+     * wait disqualifies both measurements.
+     */
+    suspensionHasWaits: boolean;
+    /**
+     * Whether the suspension that scheduled this batch also created hooks
+     * (also not in `events` yet). Hooks keep TTFS eligible — their measured
+     * write time is subtracted via `preStepBlockingMs` — but disqualify STSO,
+     * which is only meaningful for a pure back-to-back step gap.
+     */
+    suspensionCreatedHooks: boolean;
+    /** Whether turbo mode is active for this invocation. */
+    turbo: boolean;
+}): StepLatencyTracking | undefined;
+/**
+ * Compute the latency telemetry to attach to the step's terminal event.
+ * Called by `executeStep` with the wall-clock timestamp taken immediately
+ * before user step code runs. Returns undefined when there is nothing to
+ * report (no tracking, or a retry attempt — retries measure neither TTFS nor
+ * STSO).
+ */
+export declare function computeStepLatencyEventData(params: {
+    tracking: StepLatencyTracking | undefined;
+    /** `Date.now()` taken immediately before user step code began executing. */
+    stepCodeStartedAtMs: number;
+    attempt: number;
+    /** Whether this step was started lazily (no separate step_created write). */
+    lazyStepStart: boolean;
+    /** Whether the body ran optimistically, without awaiting step_started. */
+    optimisticStart: boolean;
+}): StepLatencyEventData | undefined;
+//# sourceMappingURL=step-latency.d.ts.map

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

@@ -0,0 +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,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,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,CA4DlC;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,CA2CnC"}

package/dist/runtime/step-latency.js

@@ -0,0 +1,135 @@
+/**
+ * Event types that disqualify TTFS when present in the event log at the time
+ * the run's first step batch is scheduled:
+ *
+ * - Any step event means this is not the run's first step execution.
+ * - `hook_received` / `wait_created` / `wait_completed` mean the run's path to
+ *   the first step depended on user-driven timing (a webhook arriving, a
+ *   sleep elapsing), so the measurement would not reflect runtime overhead.
+ *
+ * Deliberately absent, with their cost subtracted instead:
+ *
+ * - `hook_created`: a fire-and-forget `createHook()` before the first step
+ *   commits in the same invocation, whose measured duration is subtracted via
+ *   {@link StepLatencyTracking.preStepBlockingMs}.
+ * - `attr_set` (workflow-body `experimental_setAttributes`): resolves through
+ *   an extra replay before steps run. Subtracted by ending the measurement at
+ *   the first attr write's timestamp instead — see
+ *   {@link StepLatencyTracking.preStepAttrStartMs}.
+ */
+const TTFS_DISQUALIFYING_EVENT_TYPES = new Set([
+    'step_created',
+    'step_started',
+    'step_completed',
+    'step_failed',
+    'step_retrying',
+    'hook_received',
+    'wait_created',
+    'wait_completed',
+]);
+/**
+ * Decide, from the orchestrator's view of the event log, whether the inline
+ * step batch about to execute qualifies for TTFS and/or STSO measurement.
+ * Returns undefined when neither applies. Called once per batch; the result
+ * is passed to the batch's first step only, so a parallel first batch emits a
+ * single sample rather than one per sibling.
+ */
+export function computeStepLatencyTracking(params) {
+    const { events } = params;
+    let ttfsEligible = params.invocationStartedClean &&
+        params.runCreatedAtMs !== undefined &&
+        !params.suspensionHasWaits;
+    let preStepAttrStartMs;
+    if (ttfsEligible) {
+        for (const event of events) {
+            if (TTFS_DISQUALIFYING_EVENT_TYPES.has(event.eventType)) {
+                ttfsEligible = false;
+                break;
+            }
+            if (event.eventType === 'attr_set') {
+                const attrStartMs = +(event.occurredAt ?? event.createdAt);
+                preStepAttrStartMs =
+                    preStepAttrStartMs === undefined
+                        ? attrStartMs
+                        : Math.min(preStepAttrStartMs, attrStartMs);
+            }
+        }
+    }
+    // STSO: the two steps ran back-to-back — the newest known event is the
+    // previous step's terminal event, with nothing (hook_received, waits,
+    // attr_set, ...) in between and this suspension scheduling nothing but
+    // steps.
+    let prevStepEndMs;
+    const lastEvent = events[events.length - 1];
+    if (!params.suspensionHasWaits &&
+        !params.suspensionCreatedHooks &&
+        lastEvent &&
+        (lastEvent.eventType === 'step_completed' ||
+            lastEvent.eventType === 'step_failed')) {
+        prevStepEndMs = +(lastEvent.occurredAt ?? lastEvent.createdAt);
+    }
+    if (!ttfsEligible && prevStepEndMs === undefined) {
+        return undefined;
+    }
+    return {
+        ...(ttfsEligible
+            ? {
+                ttfsAnchorMs: params.runCreatedAtMs,
+                // When the measurement ends at the first attr write, only hook
+                // time from before that point is inside the measured window.
+                preStepBlockingMs: preStepAttrStartMs !== undefined
+                    ? (params.preStepBlockingBeforeAttrMs ?? 0)
+                    : params.preStepBlockingMs,
+                ...(preStepAttrStartMs !== undefined ? { preStepAttrStartMs } : {}),
+            }
+            : {}),
+        ...(prevStepEndMs !== undefined ? { prevStepEndMs } : {}),
+        turbo: params.turbo,
+    };
+}
+/**
+ * Compute the latency telemetry to attach to the step's terminal event.
+ * Called by `executeStep` with the wall-clock timestamp taken immediately
+ * before user step code runs. Returns undefined when there is nothing to
+ * report (no tracking, or a retry attempt — retries measure neither TTFS nor
+ * STSO).
+ */
+export function computeStepLatencyEventData(params) {
+    const { tracking } = 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.
+    //
+    // 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
+    // of the setAttributes call (resolved via an extra replay), which is
+    // subtracted rather than disqualifying the sample. In that case
+    // `tracking.preStepBlockingMs` already holds only the hook time from
+    // 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))
+        : undefined;
+    const stso = tracking.prevStepEndMs !== undefined
+        ? Math.max(0, params.stepCodeStartedAtMs - tracking.prevStepEndMs)
+        : undefined;
+    if (ttfs === undefined && stso === undefined) {
+        return undefined;
+    }
+    const optimizations = [];
+    if (tracking.turbo)
+        optimizations.push('turbo');
+    if (params.lazyStepStart)
+        optimizations.push('lazyStepStart');
+    if (params.optimisticStart)
+        optimizations.push('optimisticStart');
+    return {
+        ...(ttfs !== undefined ? { ttfs } : {}),
+        ...(stso !== undefined ? { stso } : {}),
+        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 `experimental_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  /** 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  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 `experimental_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  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  }\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 ? { prevStepEndMs } : {}),\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    optimizations,\n  };\n}\n"]}

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

@@ -77,6 +77,13 @@ export interface SuspensionHandlerResult {
      * inline start (a hook introduces later resume invocations that could race).
      */
     hasHookEvents: boolean;
+    /**
+     * Wall-clock ms spent committing this suspension's `hook_created` events
+     * (0 when it created none). The caller accumulates this across iterations
+     * and subtracts it from the TTFS latency measurement, so time spent
+     * durably creating the user's hooks doesn't count as runtime overhead.
+     */
+    hookCreationMs: number;
 }
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).

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;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,CAyd5D"}
+{"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"}