@workflow/core 5.0.0-beta.41 → 5.0.0-beta.42

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

@@ -0,0 +1,143 @@
+import type { HookResumeTiming } from '@workflow/world';
+/**
+ * Hook-triggered time-to-resume (TTR): wall-clock from entry into
+ * `resumeHook()` (T0) to the first line of the next durable step (T7), plus a
+ * decomposition into non-overlapping phases that sum exactly to it.
+ *
+ * ```text
+ * T0 resumeHook() entered
+ *      producer_prep   — hook lookup, serialization, encryption
+ * T1 queue publish requested
+ *      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
+ * T3 replay begins
+ *      replay          — VM/session creation and workflow replay
+ * T4 next durable step encountered
+ *      step_dispatch   — suspension handling, inline batch or queue dispatch
+ * T5 step_started request begins
+ *      step_claim      — the claim round trip
+ * T6 step_started response returned
+ *      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`).
+ *
+ * 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
+ * {@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';
+/**
+ * How the consuming invocation initialized its replay state:
+ *
+ * - `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
+ *   path's fallback, where the hoisted write succeeded but returned no usable
+ *   preload).
+ * - `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
+ *   live value, and keeps the dimension total if such a path is added.
+ */
+export type ResumeSetupSource = 'hook_preload' | 'run_started' | 'event_load';
+/** Whether the measured step ran in the resuming invocation or a queued one. */
+export type ResumeStepExecution = 'inline' | 'dispatched';
+/**
+ * The resume boundaries observed so far, threaded from the queue handler into
+ * `executeStep`. Producer fields arrive on the queue message
+ * ({@link HookResumeTiming}); consumer fields are stamped by the invocation
+ * that replays the resume.
+ *
+ * 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
+ * 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.
+ */
+export interface ResumeTtrTracking {
+    trigger: ResumeTrigger;
+    /** Absent only if an older producer omitted it from the queue message. */
+    strategy?: ResumeStrategy;
+    /** T0 — entry into `resumeHook()`. */
+    resumeRequestedAtMs: number;
+    /** T1 — immediately before the queue publish was requested. */
+    queuePublishRequestedAtMs: number;
+    /**
+     * 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. */
+    replayStartedAtMs?: number;
+    /** T4 — replay first encountered a durable step after the resume. */
+    nextStepEncounteredAtMs?: number;
+    setupSource?: ResumeSetupSource;
+    stepExecution: ResumeStepExecution;
+    /**
+     * 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
+     * sample to a step that may lose its create-claim and never run.
+     *
+     * Deliberately not part of {@link HookResumeTiming}: it is invocation-local
+     * state, and a queue message carries the boundaries, not the claim.
+     */
+    reported?: boolean;
+}
+/**
+ * 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.
+ */
+export declare function resumeTrackingFromMessage(timing: HookResumeTiming | undefined, stepExecution: ResumeStepExecution): ResumeTtrTracking | undefined;
+/**
+ * Serialize tracking back onto a queue message, for the case where the
+ * resuming invocation dispatches the next durable step to another invocation
+ * instead of running it inline. Returns undefined when the tracking is not
+ * complete enough to be worth forwarding.
+ */
+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
+ * any of these hold:
+ *
+ * - the invocation carries no resume tracking (not a hook resume, or an older
+ *   queue message with no timing);
+ * - this is a retry (`attempt !== 1`), which measures a re-execution rather
+ *   than the resumption;
+ * - a required boundary is missing, non-finite, or out of order.
+ *
+ * `step_claim_ms` is the one phase that may be individually omitted. Under
+ * optimistic inline start the `step_started` claim is deliberately NOT awaited
+ * before the body runs, so its completion instant does not exist yet at T7;
+ * rather than invent one, the claim phase is dropped and `step_prepare_ms`
+ * spans T5→T7. The sum-equals-total property holds either way.
+ */
+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. */
+    stepClaimStartedAtMs: number | undefined;
+    /** T6 — `Date.now()` once the `step_started` response returned. */
+    stepClaimCompletedAtMs: number | undefined;
+    /** 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

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

package/dist/runtime/resume-latency.js

@@ -0,0 +1,153 @@
+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.
+ */
+export function resumeTrackingFromMessage(timing, stepExecution) {
+    if (!timing)
+        return undefined;
+    if (!Number.isFinite(timing.resumeRequestedAtMs) ||
+        !Number.isFinite(timing.queuePublishRequestedAtMs)) {
+        return undefined;
+    }
+    return {
+        trigger: 'hook',
+        ...(timing.strategy === 'parallel' || timing.strategy === 'sequential'
+            ? { strategy: timing.strategy }
+            : {}),
+        resumeRequestedAtMs: timing.resumeRequestedAtMs,
+        queuePublishRequestedAtMs: timing.queuePublishRequestedAtMs,
+        // A dispatched step reads the resuming invocation's boundaries off the
+        // message; an inline one has them stamped locally by the caller, which
+        // overwrites this placeholder immediately after construction.
+        consumerStartedAtMs: timing.consumerStartedAtMs ?? Number.NaN,
+        ...(timing.replayStartedAtMs !== undefined
+            ? { replayStartedAtMs: timing.replayStartedAtMs }
+            : {}),
+        ...(timing.nextStepEncounteredAtMs !== undefined
+            ? { nextStepEncounteredAtMs: timing.nextStepEncounteredAtMs }
+            : {}),
+        ...(timing.setupSource === 'hook_preload' ||
+            timing.setupSource === 'run_started' ||
+            timing.setupSource === 'event_load'
+            ? { setupSource: timing.setupSource }
+            : {}),
+        stepExecution,
+    };
+}
+/**
+ * Serialize tracking back onto a queue message, for the case where the
+ * resuming invocation dispatches the next durable step to another invocation
+ * instead of running it inline. Returns undefined when the tracking is not
+ * complete enough to be worth forwarding.
+ */
+export function resumeTimingForMessage(tracking) {
+    if (!tracking)
+        return undefined;
+    if (!Number.isFinite(tracking.consumerStartedAtMs))
+        return undefined;
+    return {
+        resumeRequestedAtMs: tracking.resumeRequestedAtMs,
+        queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,
+        ...(tracking.strategy !== undefined ? { strategy: tracking.strategy } : {}),
+        consumerStartedAtMs: tracking.consumerStartedAtMs,
+        ...(tracking.replayStartedAtMs !== undefined
+            ? { replayStartedAtMs: tracking.replayStartedAtMs }
+            : {}),
+        ...(tracking.nextStepEncounteredAtMs !== undefined
+            ? { nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs }
+            : {}),
+        ...(tracking.setupSource !== undefined
+            ? { setupSource: tracking.setupSource }
+            : {}),
+    };
+}
+/**
+ * Validate that every required boundary is a finite epoch-ms value and that
+ * the whole sequence is non-decreasing. Returns undefined otherwise, which
+ * suppresses the metric entirely rather than reporting a phase that never
+ * happened or a negative duration.
+ */
+function validateBoundaries(b) {
+    const ordered = [
+        b.resumeRequestedAtMs,
+        b.queuePublishRequestedAtMs,
+        b.consumerStartedAtMs,
+        b.replayStartedAtMs,
+        b.nextStepEncounteredAtMs,
+        b.stepClaimStartedAtMs,
+        ...(b.stepClaimCompletedAtMs !== undefined
+            ? [b.stepClaimCompletedAtMs]
+            : []),
+        b.stepCodeStartedAtMs,
+    ];
+    for (const value of ordered) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return undefined;
+    }
+    for (let i = 1; i < ordered.length; i++) {
+        if (ordered[i] < ordered[i - 1])
+            return undefined;
+    }
+    return ordered;
+}
+/**
+ * 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
+ * any of these hold:
+ *
+ * - the invocation carries no resume tracking (not a hook resume, or an older
+ *   queue message with no timing);
+ * - this is a retry (`attempt !== 1`), which measures a re-execution rather
+ *   than the resumption;
+ * - a required boundary is missing, non-finite, or out of order.
+ *
+ * `step_claim_ms` is the one phase that may be individually omitted. Under
+ * optimistic inline start the `step_started` claim is deliberately NOT awaited
+ * before the body runs, so its completion instant does not exist yet at T7;
+ * rather than invent one, the claim phase is dropped and `step_prepare_ms`
+ * spans T5→T7. The sum-equals-total property holds either way.
+ */
+export function computeResumeTtrAttributes(params) {
+    const { tracking } = params;
+    if (!tracking || params.attempt !== 1)
+        return undefined;
+    if (tracking.replayStartedAtMs === undefined ||
+        tracking.nextStepEncounteredAtMs === undefined ||
+        params.stepClaimStartedAtMs === undefined) {
+        return undefined;
+    }
+    const boundaries = {
+        resumeRequestedAtMs: tracking.resumeRequestedAtMs,
+        queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,
+        consumerStartedAtMs: tracking.consumerStartedAtMs,
+        replayStartedAtMs: tracking.replayStartedAtMs,
+        nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs,
+        stepClaimStartedAtMs: params.stepClaimStartedAtMs,
+        stepClaimCompletedAtMs: params.stepClaimCompletedAtMs,
+        stepCodeStartedAtMs: params.stepCodeStartedAtMs,
+    };
+    if (!validateBoundaries(boundaries))
+        return undefined;
+    const { resumeRequestedAtMs: t0, queuePublishRequestedAtMs: t1, consumerStartedAtMs: t2, replayStartedAtMs: t3, nextStepEncounteredAtMs: t4, stepClaimStartedAtMs: t5, stepClaimCompletedAtMs: t6, stepCodeStartedAtMs: t7, } = boundaries;
+    return {
+        ...Attribute.ResumeTotalMs(t7 - t0),
+        ...Attribute.ResumeProducerPrepMs(t1 - t0),
+        ...Attribute.ResumeQueueDeliveryMs(t2 - t1),
+        ...Attribute.ResumeSetupMs(t3 - t2),
+        ...Attribute.ResumeReplayMs(t4 - t3),
+        ...Attribute.ResumeStepDispatchMs(t5 - t4),
+        ...(t6 !== undefined ? Attribute.ResumeStepClaimMs(t6 - t5) : {}),
+        ...Attribute.ResumeStepPrepareMs(t7 - (t6 ?? t5)),
+        ...Attribute.ResumeTrigger(tracking.trigger),
+        ...(tracking.strategy !== undefined
+            ? Attribute.ResumeStrategy(tracking.strategy)
+            : {}),
+        ...(tracking.setupSource !== undefined
+            ? Attribute.ResumeSetupSource(tracking.setupSource)
+            : {}),
+        ...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"]}

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

@@ -1,7 +1,8 @@
 import type { Event, SerializedData, World } from '@workflow/world';
 import type { PayloadKey } from '../serialization/encryption.js';
-import { type PreconditionSnapshotParams } from './helpers.js';
+import { type SlotSnapshotParams } from './helpers.js';
 import { ReplayRecoveryReporter } from './replay-recovery-reporter.js';
+import { type ResumeTtrTracking } from './resume-latency.js';
 import { type StepLatencyTracking } from './step-latency.js';
 export declare const DEFAULT_STEP_MAX_RETRIES = 3;
 export interface StepExecutorParams {
@@ -59,20 +60,25 @@ export interface StepExecutorParams {
      */
     inlineDeltaSinceCursor?: string;
     /**
-     * Precondition-guard snapshot of the event log the caller's replay loaded, to
-     * attach to this step's `step_started` claim. On the lazy inline path the
-     * claim is the step's FIRST durable write (its `step_created` is deferred),
-     * so without this the claim would bypass the optimistic-concurrency guard
-     * entirely: a replay working from a stale view could claim — and then commit
-     * — a step scheduled without observing an event it never loaded. A
-     * guard-enforcing World rejects a stale claim with `PreconditionFailedError`
+     * How much of the run's log the caller's replay had loaded when it scheduled
+     * this step, as the highest slot that log occupies. Seeds the snapshot every
+     * write this executor makes carries; each committed event advances it to its
+     * own slot, so a later write never names a position that predates an earlier
+     * one from the same step.
+     *
+     * It matters most on the lazy inline path, where the `step_started` claim is
+     * the step's FIRST durable write (its `step_created` is deferred): without a
+     * seed the claim would name no position at all, and a replay working from a
+     * stale view could claim — and then commit — a step scheduled without
+     * observing an event it never loaded.
+     *
+     * A World that fences rejects a stale claim with `PreconditionFailedError`
      * (412); executeStep does NOT translate that rejection (re-claiming in place
      * would still commit the stale schedule), so it propagates for the caller to
-     * abandon the batch and restart its replay. Undefined when the guard is
-     * disabled or the caller has no snapshot; Worlds that don't enforce the guard
-     * ignore it.
+     * abandon the batch and restart its replay. Undefined for a caller with
+     * nothing loaded.
      */
-    preconditionSnapshot?: PreconditionSnapshotParams;
+    slotSnapshot?: SlotSnapshotParams;
     /**
      * Suppress optimistic inline start for this step regardless of
      * `WORKFLOW_OPTIMISTIC_INLINE_START` / `forceOptimisticStart`: take the
@@ -111,6 +117,15 @@ export interface StepExecutorParams {
      * runtime/step-latency.ts.
      */
     latencyTracking?: StepLatencyTracking;
+    /**
+     * Hook-resume TTR telemetry: the boundaries of a hook resumption whose next
+     * durable step is the one this call is about to execute. When set, the
+     * executor closes the measurement against the `step_started` claim and the
+     * wall clock taken immediately before user code, and attaches the total plus
+     * its phase breakdown to this step's `step.execute` span. Set by the runtime
+     * for exactly one step per resumption — see runtime/resume-latency.ts.
+     */
+    resumeTracking?: ResumeTtrTracking;
     /**
      * Authoritative attempt number for this execution, used to bound retries
      * against `maxRetries` BEFORE the body runs. In order to also catch

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

@@ -1 +1 @@
-{"version":3,"file":"step-executor.d.ts","sourceRoot":"","sources":["../../src/runtime/step-executor.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAGV,KAAK,EAEL,cAAc,EAEd,KAAK,EACN,MAAM,iBAAiB,CAAC;AAOzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAuBjE,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAG3B,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAuB1C,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;OAQG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAAC,EAAE,0BAA0B,CAAC;IAClD;;;;;;;;;;OAUG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC;;;;;;;;;OASG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,wEAAwE;IACxE,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC,GACD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,mBAAmB,CAAC,CA8jC9B"}
+{"version":3,"file":"step-executor.d.ts","sourceRoot":"","sources":["../../src/runtime/step-executor.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAGV,KAAK,EAEL,cAAc,EAEd,KAAK,EACN,MAAM,iBAAiB,CAAC;AAQzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAuBjE,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAG3B,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAuB1C,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;OAQG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC;;;;;;;;;;OAUG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,iBAAiB,CAAC;IACnC;;;;;;;;;OASG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,wEAAwE;IACxE,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC,GACD;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAypC9B"}