@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/symbols.d.ts

@@ -1,4 +1,5 @@
 export declare const WORKFLOW_USE_STEP: unique symbol;
+export declare const WORKFLOW_SET_ATTRIBUTES: unique symbol;
 export declare const WORKFLOW_CREATE_HOOK: unique symbol;
 export declare const WORKFLOW_SLEEP: unique symbol;
 export declare const WORKFLOW_CONTEXT: unique symbol;
@@ -6,6 +7,55 @@ export declare const WORKFLOW_GET_STREAM_ID: unique symbol;
 export declare const STABLE_ULID: unique symbol;
 export declare const STREAM_NAME_SYMBOL: unique symbol;
 export declare const STREAM_TYPE_SYMBOL: unique symbol;
+export declare const STREAM_FRAMING_SYMBOL: unique symbol;
+/**
+ * Stamped on a real `WritableStream` (the user-visible `serialize.writable`
+ * returned from a step-side reviver or step-context `getWritable()`) to
+ * record the `runId` of the workflow run that owns the underlying server
+ * stream. Used together with `STREAM_NAME_SYMBOL`.
+ *
+ * When `getExternalReducers.WritableStream` (the dehydration path used by
+ * `start()`) sees both symbols on a writable, it includes the `runId` in
+ * the descriptor it emits. The child run's step-side reviver then opens
+ * a server writable against the original `(runId, name)` and resolves
+ * that run's encryption key directly, so the child's writes land on
+ * the parent's stream as-is, with no client process in the loop. That
+ * keeps the forwarding alive for the full lifetime of the child run,
+ * not just for the parent step that initiated `start()`.
+ */
+export declare const STREAM_SERVER_RUN_ID_SYMBOL: unique symbol;
+/**
+ * Stamped alongside `STREAM_SERVER_RUN_ID_SYMBOL` when the deployment that
+ * owns a forwarded writable stream is known. Cross-deployment consumers use
+ * it to resolve the owning run's encryption key without loading the run first.
+ */
+export declare const STREAM_SERVER_DEPLOYMENT_ID_SYMBOL: unique symbol;
+/**
+ * Stamped alongside `STREAM_SERVER_RUN_ID_SYMBOL` with the owning run's
+ * X25519 public key (base64), when the run has one.
+ *
+ * This is what lets a forwarded writable be written to across a deployment
+ * boundary at zero cost. The owning run derives its own public key locally
+ * when it creates the stream, so the key travels inside the serialized
+ * descriptor; a child on another deployment can then seal frames immediately.
+ * Without it the child would have to either fetch the owning run or fetch its
+ * symmetric key from the API, the round trip this whole mechanism exists to
+ * avoid.
+ */
+export declare const STREAM_SERVER_PUBLIC_KEY_SYMBOL: unique symbol;
+/**
+ * Stamped on a `WorkflowServerWritableStream` instance to expose its
+ * durability barrier: `() => Promise<void>` that resolves once every accepted
+ * chunk has durably reached the server (nothing buffered, nothing in flight)
+ * and rejects if any dispatch failed.
+ *
+ * The sink acks `write()` on buffer entry (group-commit batching), so
+ * durability tracking lives here instead: `flushablePipe` feature-detects
+ * this and awaits it before resolving its lock-release completion, keeping
+ * the invariant that a step cannot complete while stream data is still
+ * client-side. Sinks without it are fully durable per `write()` already.
+ */
+export declare const STREAM_DRAIN_SYMBOL: unique symbol;
 export declare const BODY_INIT_SYMBOL: unique symbol;
 export declare const WEBHOOK_RESPONSE_WRITABLE: unique symbol;
 /**

package/dist/symbols.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../src/symbols.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,eAAkC,CAAC;AACjE,eAAO,MAAM,oBAAoB,eAAqC,CAAC;AACvE,eAAO,MAAM,cAAc,eAA+B,CAAC;AAC3D,eAAO,MAAM,gBAAgB,eAAiC,CAAC;AAC/D,eAAO,MAAM,sBAAsB,eAAuC,CAAC;AAC3E,eAAO,MAAM,WAAW,eAAqC,CAAC;AAC9D,eAAO,MAAM,kBAAkB,eAAqC,CAAC;AACrE,eAAO,MAAM,kBAAkB,eAAqC,CAAC;AACrE,eAAO,MAAM,gBAAgB,eAA0B,CAAC;AACxD,eAAO,MAAM,yBAAyB,eAErC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,eAAwC,CAAC;AAE7E,eAAO,MAAM,iBAAiB,eAA2C,CAAC;AAC1E,eAAO,MAAM,gBAAgB,eAA0C,CAAC;AACxE,eAAO,MAAM,uBAAuB,eAEnC,CAAC;AACF,eAAO,MAAM,mBAAmB,eAA6C,CAAC"}
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../src/symbols.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,eAAkC,CAAC;AACjE,eAAO,MAAM,uBAAuB,eAAwC,CAAC;AAC7E,eAAO,MAAM,oBAAoB,eAAqC,CAAC;AACvE,eAAO,MAAM,cAAc,eAA+B,CAAC;AAC3D,eAAO,MAAM,gBAAgB,eAAiC,CAAC;AAC/D,eAAO,MAAM,sBAAsB,eAAuC,CAAC;AAC3E,eAAO,MAAM,WAAW,eAAqC,CAAC;AAC9D,eAAO,MAAM,kBAAkB,eAAqC,CAAC;AACrE,eAAO,MAAM,kBAAkB,eAAqC,CAAC;AACrE,eAAO,MAAM,qBAAqB,eAAwC,CAAC;AAC3E;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,2BAA2B,eAEvC,CAAC;AACF;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,eAE9C,CAAC;AACF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B,eAE3C,CAAC;AACF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,eAAsC,CAAC;AAEvE,eAAO,MAAM,gBAAgB,eAA0B,CAAC;AACxD,eAAO,MAAM,yBAAyB,eAErC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,eAAwC,CAAC;AAE7E,eAAO,MAAM,iBAAiB,eAA2C,CAAC;AAC1E,eAAO,MAAM,gBAAgB,eAA0C,CAAC;AACxE,eAAO,MAAM,uBAAuB,eAEnC,CAAC;AACF,eAAO,MAAM,mBAAmB,eAA6C,CAAC"}

package/dist/symbols.js

@@ -1,4 +1,5 @@
 export const WORKFLOW_USE_STEP = Symbol.for('WORKFLOW_USE_STEP');
+export const WORKFLOW_SET_ATTRIBUTES = Symbol.for('WORKFLOW_SET_ATTRIBUTES');
 export const WORKFLOW_CREATE_HOOK = Symbol.for('WORKFLOW_CREATE_HOOK');
 export const WORKFLOW_SLEEP = Symbol.for('WORKFLOW_SLEEP');
 export const WORKFLOW_CONTEXT = Symbol.for('WORKFLOW_CONTEXT');
@@ -6,6 +7,55 @@ export const WORKFLOW_GET_STREAM_ID = Symbol.for('WORKFLOW_GET_STREAM_ID');
 export const STABLE_ULID = Symbol.for('WORKFLOW_STABLE_ULID');
 export const STREAM_NAME_SYMBOL = Symbol.for('WORKFLOW_STREAM_NAME');
 export const STREAM_TYPE_SYMBOL = Symbol.for('WORKFLOW_STREAM_TYPE');
+export const STREAM_FRAMING_SYMBOL = Symbol.for('WORKFLOW_STREAM_FRAMING');
+/**
+ * Stamped on a real `WritableStream` (the user-visible `serialize.writable`
+ * returned from a step-side reviver or step-context `getWritable()`) to
+ * record the `runId` of the workflow run that owns the underlying server
+ * stream. Used together with `STREAM_NAME_SYMBOL`.
+ *
+ * When `getExternalReducers.WritableStream` (the dehydration path used by
+ * `start()`) sees both symbols on a writable, it includes the `runId` in
+ * the descriptor it emits. The child run's step-side reviver then opens
+ * a server writable against the original `(runId, name)` and resolves
+ * that run's encryption key directly, so the child's writes land on
+ * the parent's stream as-is, with no client process in the loop. That
+ * keeps the forwarding alive for the full lifetime of the child run,
+ * not just for the parent step that initiated `start()`.
+ */
+export const STREAM_SERVER_RUN_ID_SYMBOL = Symbol.for('WORKFLOW_STREAM_SERVER_RUN_ID');
+/**
+ * Stamped alongside `STREAM_SERVER_RUN_ID_SYMBOL` when the deployment that
+ * owns a forwarded writable stream is known. Cross-deployment consumers use
+ * it to resolve the owning run's encryption key without loading the run first.
+ */
+export const STREAM_SERVER_DEPLOYMENT_ID_SYMBOL = Symbol.for('WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID');
+/**
+ * Stamped alongside `STREAM_SERVER_RUN_ID_SYMBOL` with the owning run's
+ * X25519 public key (base64), when the run has one.
+ *
+ * This is what lets a forwarded writable be written to across a deployment
+ * boundary at zero cost. The owning run derives its own public key locally
+ * when it creates the stream, so the key travels inside the serialized
+ * descriptor; a child on another deployment can then seal frames immediately.
+ * Without it the child would have to either fetch the owning run or fetch its
+ * symmetric key from the API, the round trip this whole mechanism exists to
+ * avoid.
+ */
+export const STREAM_SERVER_PUBLIC_KEY_SYMBOL = Symbol.for('WORKFLOW_STREAM_SERVER_PUBLIC_KEY');
+/**
+ * Stamped on a `WorkflowServerWritableStream` instance to expose its
+ * durability barrier: `() => Promise<void>` that resolves once every accepted
+ * chunk has durably reached the server (nothing buffered, nothing in flight)
+ * and rejects if any dispatch failed.
+ *
+ * The sink acks `write()` on buffer entry (group-commit batching), so
+ * durability tracking lives here instead: `flushablePipe` feature-detects
+ * this and awaits it before resolving its lock-release completion, keeping
+ * the invariant that a step cannot complete while stream data is still
+ * client-side. Sinks without it are fully durable per `write()` already.
+ */
+export const STREAM_DRAIN_SYMBOL = Symbol.for('WORKFLOW_STREAM_DRAIN');
 export const BODY_INIT_SYMBOL = Symbol.for('BODY_INIT');
 export const WEBHOOK_RESPONSE_WRITABLE = Symbol.for('WEBHOOK_RESPONSE_WRITABLE');
 /**
@@ -17,4 +67,4 @@ export const ABORT_STREAM_NAME = Symbol.for('WORKFLOW_ABORT_STREAM_NAME');
 export const ABORT_HOOK_TOKEN = Symbol.for('WORKFLOW_ABORT_HOOK_TOKEN');
 export const ABORT_LISTENER_ATTACHED = Symbol.for('WORKFLOW_ABORT_LISTENER_ATTACHED');
 export const ABORT_READER_CANCEL = Symbol.for('WORKFLOW_ABORT_READER_CANCEL');
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/telemetry/semantic-conventions.d.ts

@@ -3,7 +3,7 @@
  *
  * This module provides standardized telemetry attributes following OpenTelemetry semantic conventions
  * for instrumenting workflow execution, step processing, and related operations. Each exported function
- * creates a properly formatted attribute object that can be used with OpenTelemetry spans.
+ * creates a properly formatted attribute object for use with OpenTelemetry spans.
  *
  * The semantic conventions are organized into several categories:
  * - **Workflow attributes**: Track workflow lifecycle, status, and metadata
@@ -11,7 +11,7 @@
  * - **Queue attributes**: Instrument message queue operations
  * - **Deployment attributes**: Capture deployment environment information
  *
- * All attribute functions are type-safe and leverage existing backend types to ensure
+ * All attribute functions are type-safe and use existing backend types to ensure
  * consistency between telemetry data and actual system state.
  *
  * @example
@@ -60,6 +60,42 @@ export declare const WorkflowStartedAt: (value: number) => {
 export declare const WorkflowEventsCount: (value: number) => {
     [k: string]: number;
 };
+/** Whether workflow execution starts with replay or resumes a retained VM */
+export declare const WorkflowExecutionMode: (value: "replay" | "retained") => {
+    [k: string]: "replay" | "retained";
+};
+/** Whether the compiled application workflow bundle was cached. */
+export declare const WorkflowBundleCompileCacheHit: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Operation that supplied events to the current replay. */
+export type WorkflowReplayLoadSource = 'run_started' | 'hook_preload' | 'events_list' | 'events_list_incremental';
+export declare const WorkflowReplayLoadSource: (value: WorkflowReplayLoadSource) => {
+    [k: string]: WorkflowReplayLoadSource;
+};
+/**
+ * Events the replay walked past that no consumer claimed, still held when the
+ * replay stopped.
+ *
+ * A non-zero count on a suspension is ordinary: an out-of-band delivery that
+ * landed ahead of the code that reads it waits for the replay that gets there.
+ * From inside one replay that is indistinguishable from an event no replay will
+ * ever claim, because the two differ only in what the next replay does. So the
+ * count goes on the span instead of failing the run, and the case worth acting
+ * on is a query across a run's spans: the same
+ * {@link WorkflowParkedEventId} held on suspension after suspension.
+ */
+export declare const WorkflowParkedEventsCount: (value: number) => {
+    [k: string]: number;
+};
+/** Oldest event still held unclaimed when the replay stopped. */
+export declare const WorkflowParkedEventId: (value: string) => {
+    [k: string]: string;
+};
+/** Type of the oldest event still held unclaimed when the replay stopped. */
+export declare const WorkflowParkedEventType: (value: string) => {
+    [k: string]: string;
+};
 /** Number of arguments passed to the workflow */
 export declare const WorkflowArgumentsCount: (value: number) => {
     [k: string]: number;
@@ -72,6 +108,42 @@ export declare const WorkflowResultType: (value: string) => {
 export declare const WorkflowTracePropagated: (value: boolean) => {
     [k: string]: boolean;
 };
+/** The VM engine executing the workflow function for this invocation */
+export declare const WorkflowVm: (value: "node" | "quickjs") => {
+    [k: string]: "node" | "quickjs";
+};
+/** Outcome of a QuickJS VM workflow invocation */
+export declare const QuickJSOutcome: (value: "completed" | "failed" | "suspended") => {
+    [k: string]: "completed" | "failed" | "suspended";
+};
+/** Whether preloaded events from `events.create('run_started')` were used */
+export declare const QuickJSEventsPreloaded: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Total number of events fetched from the world for this invocation */
+export declare const QuickJSEventsFetchedCount: (value: number) => {
+    [k: string]: number;
+};
+/** Number of pages required to fetch all events */
+export declare const QuickJSEventsFetchedPages: (value: number) => {
+    [k: string]: number;
+};
+/** Number of pending VM operations captured at suspension */
+export declare const QuickJSPendingOpsCount: (value: number) => {
+    [k: string]: number;
+};
+/** Number of steps executed inline (live-VM continuation) this invocation */
+export declare const QuickJSInlineSteps: (value: number) => {
+    [k: string]: number;
+};
+/** Active trace-correlation mode for this invocation (linked or continuous) */
+export declare const WorkflowTraceMode: (value: "linked" | "continuous") => {
+    [k: string]: "linked" | "continuous";
+};
+/** Whether this workflow invocation is using the turbo first-delivery path */
+export declare const WorkflowTurbo: (value: boolean) => {
+    [k: string]: boolean;
+};
 /** Name of the error that caused workflow failure */
 export declare const WorkflowErrorName: (value: string) => {
     [k: string]: string;
@@ -96,6 +168,68 @@ export declare const WorkflowHooksCreated: (value: number) => {
 export declare const WorkflowWaitsCreated: (value: number) => {
     [k: string]: number;
 };
+/**
+ * Number of steps this suspension finalized as failed because their
+ * arguments refused to serialize (step_created placeholder + step_failed
+ * carrying the SerializationError; see finalizeUnserializableStep).
+ */
+export declare const WorkflowStepsFailedSerialization: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Number of inline-owned steps this invocation re-executed because it is a
+ * redelivery of their owning queue message (crash recovery for inline
+ * steps; see the inline step ownership changelog, workflow#2780).
+ */
+export declare const WorkflowOwnedRecoverySteps: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Number of pending steps for which this replay suppressed the immediate
+ * requeue (another invocation inline-owns them under a live lease) and
+ * ensured a delayed backstop wake instead.
+ */
+export declare const WorkflowBackstopWakesArmed: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Number of pending steps whose immediate step-execution enqueue this replay
+ * pass skipped because THIS invocation already published that step's message
+ * on an earlier pass (a fan-out that ran inline steps and replayed again).
+ * Invocation-local knowledge only: a fresh delivery never skips.
+ */
+export declare const WorkflowDispatchRepublishSkipped: (value: number) => {
+    [k: string]: number;
+};
+/** The workflow runtime route being handled */
+export declare const WorkflowRouteType: (value: "flow") => {
+    [k: string]: "flow";
+};
+/** Whether this route invocation reused an already-created request handler */
+export declare const WorkflowRouteHandlerCached: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Number of times this in-memory route handler has been invoked */
+export declare const WorkflowRouteInvocationCount: (value: number) => {
+    [k: string]: number;
+};
+/** Time since this route entrypoint was constructed, in milliseconds */
+export declare const WorkflowRouteEntrypointAgeMs: (value: number) => {
+    [k: string]: number;
+};
+/** Time spent evaluating the generated route module body before creating the entrypoint */
+export declare const WorkflowRouteModuleBodyInitMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Compute instance handling this route: the synthesized `COMPUTE_INSTANCE_ID`.
+ * Uses OTEL `faas.instance` (execution-environment id, reused across
+ * invocations to the same function):
+ * https://opentelemetry.io/docs/specs/semconv/attributes-registry/faas/
+ */
+export declare const FaasInstance: (value: string) => {
+    [k: string]: string;
+};
 /** Name of the step function being executed */
 export declare const StepName: (value: string) => {
     [k: string]: string;
@@ -120,6 +254,64 @@ export declare const StepMaxRetries: (value: number) => {
 export declare const StepTracePropagated: (value: boolean) => {
     [k: string]: boolean;
 };
+/**
+ * Client-measured time-to-first-step latency in milliseconds: run creation →
+ * this step's body beginning to execute, minus pre-step hook-creation time.
+ * Only present on the run's first step execution when it qualified for
+ * measurement (see runtime/step-latency.ts).
+ */
+export declare const StepTtfsMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Client-measured step-to-step overhead in milliseconds: the previous step's
+ * terminal event → this step's body beginning to execute. Only present when
+ * the two steps ran back-to-back.
+ */
+export declare const StepStsoMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Client-measured run_started-to-first-step latency in milliseconds: the
+ * `run_started` response landing (or, under turbo, the local run synthesis
+ * instant) → this step's start POST being issued. A sub-window of ttfs that
+ * isolates replay overhead from the run-creation queue hop. Only present on
+ * the run's first step execution when it qualified for measurement (see
+ * runtime/step-latency.ts).
+ */
+export declare const StepRsfsMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Client-measured synchronous workflow-function replay duration in
+ * milliseconds, excluding awaited network I/O, of only the FINAL replay pass
+ * within the rsfs window: the pass that reached and scheduled the first
+ * step. Not accumulated across earlier pre-first-step passes (e.g. a
+ * workflow-body `setAttributes()` detour replays more than once, and a
+ * redelivery omits earlier invocations' work entirely), so this must not be
+ * read as "the replay portion of rsfs"; step.rsfs_ms covers the whole
+ * window. Only present alongside step.rsfs_ms and only for the run's first
+ * step (see runtime/step-latency.ts).
+ */
+export declare const StepFinalSchedulingReplayMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Runtime startup-latency optimizations active for the ttfs/stso measurement
+ * (e.g. 'turbo', 'lazyStepStart', 'optimisticStart').
+ */
+export declare const StepLatencyOptimizations: (value: string[]) => {
+    [k: string]: string[];
+};
+/**
+ * How the step's initial `step_started` claim was made. Only present for
+ * inline create claims; ordinary background starts and owned recovery remain
+ * unlabeled.
+ */
+export type StepStartStrategy = 'awaited' | 'optimistic' | 'batch_preclaimed';
+export declare const StepStartStrategy: (value: StepStartStrategy) => {
+    [k: string]: StepStartStrategy;
+};
 /** Whether the step was skipped during execution */
 export declare const StepSkipped: (value: boolean) => {
     [k: string]: boolean;
@@ -176,6 +368,14 @@ export declare const MessagingMessageId: (value: string & import("zod").$brand<"
 export declare const MessagingOperationType: (value: "publish" | "receive" | "process") => {
     [k: string]: "publish" | "receive" | "process";
 };
+/**
+ * Messages carried by one batched publish (standard OTEL:
+ * messaging.batch.message_count). Set only on the batch send, so a span
+ * without it is a single-message publish.
+ */
+export declare const MessagingBatchMessageCount: (value: number) => {
+    [k: string]: number;
+};
 /** Time taken to enqueue the message in milliseconds (workflow-specific) */
 export declare const QueueOverheadMs: (value: number) => {
     [k: string]: number;
@@ -184,6 +384,18 @@ export declare const QueueOverheadMs: (value: number) => {
 export declare const DeploymentId: (value: string) => {
     [k: string]: string;
 };
+/** The deployment a run is pinned to, set only on a misrouted delivery. */
+export declare const WorkflowRunPinnedDeploymentId: (value: string) => {
+    [k: string]: string;
+};
+/** Re-route attempts for this misrouted delivery, including this one. */
+export declare const WorkflowDeploymentMismatchRetryCount: (value: number) => {
+    [k: string]: number;
+};
+/** Whether the misrouted delivery was re-routed instead of failing the run. */
+export declare const WorkflowDeploymentMismatchRecovered: (value: boolean) => {
+    [k: string]: boolean;
+};
 /** Token identifying a specific hook */
 export declare const HookToken: (value: string) => {
     [k: string]: string;
@@ -196,6 +408,183 @@ export declare const HookId: (value: string) => {
 export declare const HookFound: (value: boolean) => {
     [k: string]: boolean;
 };
+/**
+ * Producer-side signal (on the `hook.resume` span) that the direct
+ * `hook_received` write failed transiently but the queue dispatch succeeded, so
+ * the resume is recovered via the consumer's re-ensure. Corresponds to
+ * `ResumedHook.resilientResume === true`.
+ *
+ * No longer emitted: current producers require the durable event write to
+ * succeed. Retained so dashboards and queries built on the attribute keep
+ * resolving while older producers are still deployed.
+ */
+export declare const HookResilientResume: (value: boolean) => {
+    [k: string]: boolean;
+};
+/**
+ * Producer-side signal (on the `hook.resume` span) that the durable
+ * `hook_received` write COMMITTED. Stamped after the write resolves, so it
+ * distinguishes a committed resume from an attempted one — an entry-time
+ * attribute cannot, because a span that later records an exception may have
+ * failed either before or after the commit.
+ */
+export declare const HookResumeCommitted: (value: boolean) => {
+    [k: string]: boolean;
+};
+/**
+ * Producer-side signal (on the `hook.resume` span) that the workflow wake was
+ * ACCEPTED by the queue, stamped after the publish resolves.
+ *
+ * Together with {@link HookResumeCommitted} this makes stranded resumes
+ * queryable: `resume_committed=true` with `wake_published` absent is a resume
+ * whose durable event exists but whose wake publish failed (the caller was
+ * told, but nothing re-drives it), and `resume_committed=true` +
+ * `wake_published=true` with no subsequent workflow execution for the run is
+ * a wake the queue accepted but never delivered. Both are detection-only
+ * signals — nothing recovers such a run automatically today beyond a later
+ * wake from any other source.
+ */
+export declare const HookWakePublished: (value: boolean) => {
+    [k: string]: boolean;
+};
+/**
+ * Consumer-side signal (on the workflow execution span) that this replay
+ * materialized the `hook_received` event from the queue message's `hookInput`
+ * because no committed event was found, which completes the recovery path
+ * {@link HookResilientResume} began.
+ *
+ * Legacy / non-atomic re-ensure signal only. Legacy atomic lazy resumes
+ * (resumeId + digest) go through the hoisted preload write instead, whose
+ * response cannot tell whether the producer or the consumer won the
+ * `(runId, resumeId)` claim, so this attribute is deliberately NOT emitted
+ * for them (emitting `true` unconditionally would count every producer-won
+ * resume as a recovery). The producer-begin ({@link HookResilientResume}) /
+ * consumer-materialized pairing is therefore no longer complete for atomic
+ * lazy resumptions; use {@link HookResumeSetupSource} to observe that path.
+ */
+export declare const HookResilientResumeMaterialized: (value: boolean) => {
+    [k: string]: boolean;
+};
+/**
+ * Consumer-side signal (on the workflow execution span) of how a lazy hook
+ * resume initialized its replay state:
+ *
+ * - `hook_received_stream`: the hoisted `hook_received` write returned a
+ *   usable replay preload (run + complete event log), so the invocation
+ *   skipped both the `run_started` write and the initial `events.list`.
+ * - `hook_received_fallback`: the hoisted write succeeded but returned no
+ *   usable preload (a CBOR response from an older server, a World that
+ *   ignored the opt-in, a bounded `hasMore` page, or a preload that failed
+ *   validation); the invocation fell back to the `run_started` setup without
+ *   re-posting the hook.
+ *
+ * Absent on legacy hook deliveries (no resumeId/digest) and on every other
+ * delivery kind, which take the `run_started` setup unconditionally.
+ *
+ * This is a latency/setup-path signal: it says which requests initialized
+ * the invocation, NOT that this consumer created the `hook_received` event
+ * (the hoisted write may equally have converged on the producer's, since
+ * claim ownership is not observable client-side; cf.
+ * {@link HookResilientResumeMaterialized}).
+ */
+export declare const HookResumeSetupSource: (value: string) => {
+    [k: string]: string;
+};
+/**
+ * Producer-side signal (on the suspension span) counting steps whose direct
+ * `step_created` write failed transiently while their `stepInput`-carrying
+ * queue publish succeeded, so step creation is recovered via the consumer's
+ * re-ensure. Mirrors {@link HookResilientResume}.
+ */
+export declare const StepResilientDispatchRecovered: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Consumer-side signal (on the workflow execution span) that this delivery
+ * materialized the `step_created` event from the queue message's `stepInput`
+ * because the producer's direct write had not landed, which completes the
+ * recovery path {@link StepResilientDispatchRecovered} began.
+ */
+export declare const StepResilientDispatchMaterialized: (value: boolean) => {
+    [k: string]: boolean;
+};
+/**
+ * How the queued-step consumer resolved the run identity for this execution:
+ * `run_context` — carried on the dispatch message, no `runs.get` before the
+ * step (the fetch-free prologue); `runs_get` — the legacy blocking fetch
+ * (message from an older producer). Distinguishes the two paths during
+ * version-skew windows and makes the saved round trip directly measurable.
+ */
+export declare const StepDispatchPrologue: (value: "run_context" | "runs_get") => {
+    [k: string]: "run_context" | "runs_get";
+};
+/** Total TTR: entry into `resumeHook()` → immediately before `stepFn.apply()`. */
+export declare const ResumeTotalMs: (value: number) => {
+    [k: string]: number;
+};
+/** Phase: `resumeHook()` entry → the queue publish being requested. */
+export declare const ResumeProducerPrepMs: (value: number) => {
+    [k: string]: number;
+};
+/** Phase: queue publish requested → the final consumer's handler being entered. */
+export declare const ResumeQueueDeliveryMs: (value: number) => {
+    [k: string]: number;
+};
+/** Phase: consumer entry → replay beginning. */
+export declare const ResumeSetupMs: (value: number) => {
+    [k: string]: number;
+};
+/** Phase: replay beginning → the next durable step being encountered. */
+export declare const ResumeReplayMs: (value: number) => {
+    [k: string]: number;
+};
+/** Phase: step encountered → the `step_started` request beginning. */
+export declare const ResumeStepDispatchMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Phase: `step_started` request beginning → its response returning. Omitted
+ * under optimistic inline start, where the claim is not awaited before the
+ * body runs and therefore has no completion instant at that point; the time
+ * is then reported entirely as {@link ResumeStepPrepareMs}.
+ */
+export declare const ResumeStepClaimMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Phase: claim returning → immediately before `stepFn.apply()`. Deliberately
+ * includes encryption-key resolution, argument hydration, and step-context
+ * setup; `workflow.queue.deserialize_time_ms` still isolates hydration.
+ */
+export declare const ResumeStepPrepareMs: (value: number) => {
+    [k: string]: number;
+};
+/** What triggered the measured resumption. */
+export declare const ResumeTrigger: (value: "hook") => {
+    [k: string]: "hook";
+};
+/**
+ * Which `resumeHook()` dispatch path produced this resume. `parallel` only
+ * appears for messages published by an older producer, which wrote
+ * `hook_received` itself in parallel with the publish.
+ */
+export declare const ResumeStrategy: (value: "lazy" | "parallel" | "sequential") => {
+    [k: string]: "lazy" | "parallel" | "sequential";
+};
+/**
+ * How the consuming invocation initialized replay state. Distinct from the
+ * pre-existing {@link HookResumeSetupSource} (`workflow.resume_setup_source`,
+ * on the workflow execution span), which reports the finer-grained
+ * hoisted-write outcome; this one is the TTR dimension and shares the metric's
+ * three-value vocabulary.
+ */
+export declare const ResumeSetupSource: (value: "run_started" | "hook_preload" | "event_load") => {
+    [k: string]: "run_started" | "hook_preload" | "event_load";
+};
+/** Whether the measured step ran in the resuming invocation or a queued one. */
+export declare const ResumeStepExecution: (value: "inline" | "dispatched") => {
+    [k: string]: "inline" | "dispatched";
+};
 /** Number of webhook handlers triggered */
 export declare const WebhookHandlersTriggered: (value: number) => {
     [k: string]: number;
@@ -216,6 +605,10 @@ export declare const WorkflowSuspensionWaitCount: (value: number) => {
 export declare const HttpRequestMethod: (value: string) => {
     [k: string]: string;
 };
+/** Route pattern for the request (standard OTEL: http.route) */
+export declare const HttpRoute: (value: string) => {
+    [k: string]: string;
+};
 /** Full URL of the request (standard OTEL: url.full) */
 export declare const UrlFull: (value: string) => {
     [k: string]: string;
@@ -256,6 +649,44 @@ export declare const QueueExecutionTimeMs: (value: number) => {
 export declare const QueueSerializeTimeMs: (value: number) => {
     [k: string]: number;
 };
+/** Whether this serialize/deserialize was a write or read. */
+export declare const SerializationOperation: (value: "serialize" | "deserialize") => {
+    [k: string]: "serialize" | "deserialize";
+};
+/** Whether a compression codec was applied (write) / present (read). */
+export declare const SerializationCompressed: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Which compression codec applied / was present (`zstd`, `gzip`, or `none`). */
+export declare const SerializationCodec: (value: "zstd" | "gzip" | "none") => {
+    [k: string]: "zstd" | "gzip" | "none";
+};
+/** Logical (uncompressed, devalue-prefixed) payload size in bytes. */
+export declare const SerializationUncompressedBytes: (value: number) => {
+    [k: string]: number;
+};
+/** Stored (post-compression, pre-encryption) payload size in bytes. */
+export declare const SerializationStoredBytes: (value: number) => {
+    [k: string]: number;
+};
+/** Fraction of bytes saved by compression (0..1); set only when compressed. */
+export declare const SerializationCompressionRatio: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Number of workflow (guest) code executions serialization could not avoid
+ * (getters, proxies, custom serializers); set only when non-zero.
+ */
+export declare const SerializationGuestCodeExecutions: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Deduplicated `kind (detail)` descriptions of the guest-code executions;
+ * set only when non-zero.
+ */
+export declare const SerializationGuestCodeDetails: (value: string[]) => {
+    [k: string]: string[];
+};
 /** The remote service name for Datadog service maps (Datadog-specific: peer.service) */
 export declare const PeerService: (value: string) => {
     [k: string]: string;