deepline 0.3.316 → 0.3.318

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.316',
+  version: '0.3.318',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -385,9 +385,24 @@ export type WorkerRuntimeApiContext = {
    * gateway record that produced it.
    */
   onResponseMeta?: (meta: RuntimeApiResponseMeta) => void;
+  /**
+   * Observe each request attempt as it is sent. `onResponseMeta` only fires
+   * for a successful response, so an attempt that is aborted or times out
+   * names nothing there; this carries the per-attempt id that the request
+   * already sends in its transport-attempt header, which a receiver can log.
+   * Diagnostic only: log it, never persist it on a run, status, or receipt
+   * document.
+   */
+  onRequestAttempt?: (attempt: RuntimeApiRequestAttempt) => void;
   signal?: AbortSignal;
 };
 
+export type RuntimeApiRequestAttempt = {
+  action: RuntimeApiRequest['action'];
+  /** The value of this attempt's transport-attempt request header. */
+  transportAttemptId: string;
+};
+
 /**
  * The receipt gateway's own account of a request, from its `Server-Timing`
  * response header. Its `runtime.gateway.action.finished` durationMs starts
@@ -423,6 +438,19 @@ export type RuntimeApiResponseMeta = {
   roundTripMs?: number | null;
   /** Absent when the gateway sent no `Server-Timing` header. */
   serverTiming?: RuntimeGatewayServerTiming | null;
+  /**
+   * The hosting platform's id for the responding request (`x-vercel-id`), so a
+   * slow app-runtime hop can be matched to its platform request log. Null when
+   * the receiver is not fronted by one. Diagnostic only: log it, never persist
+   * it on a run, status, or receipt document.
+   */
+  platformRequestId?: string | null;
+  /**
+   * The raw `Server-Timing` header, truncated. App routes name their own
+   * entries, which `serverTiming` (the gateway's schema) does not parse.
+   * Diagnostic only, under the same rule as `platformRequestId`.
+   */
+  serverTimingHeader?: string | null;
   /**
    * Serialized JSON bytes of the request body, before compression. Set on
    * every request, so `wire / raw` across a run is the compression ratio the
@@ -447,6 +475,27 @@ export type RuntimeApiResponseMeta = {
   requestBodyPackMs?: number | null;
 };
 
+const RUNTIME_API_DIAGNOSTIC_HEADER_MAX_CHARS = 256;
+
+/**
+ * Read one response header for a log line: trimmed, bounded, and total. A
+ * receiver controls this value, so it is capped before it reaches a record.
+ */
+export function readRuntimeApiDiagnosticHeader(
+  headers: Pick<Headers, 'get'> | null | undefined,
+  name: string,
+): string | null {
+  try {
+    const value = headers?.get(name)?.trim();
+    return value
+      ? value.slice(0, RUNTIME_API_DIAGNOSTIC_HEADER_MAX_CHARS)
+      : null;
+  } catch {
+    // Observation must never affect durable delivery.
+    return null;
+  }
+}
+
 const RUNTIME_GATEWAY_AUTH_SESSION_VALUES = new Set([
   'hit',
   'miss',
@@ -1519,6 +1568,13 @@ async function postAppRuntimeApi<TResponse>(
     // would show up as network cost that no round trip explains.
     const attemptStartedAt = Date.now();
     const transportAttemptId = randomUUID();
+    if (context.onRequestAttempt) {
+      try {
+        context.onRequestAttempt({ action: body.action, transportAttemptId });
+      } catch {
+        // Observation must never affect durable delivery.
+      }
+    }
     const requestSignal = context.signal
       ? AbortSignal.any([context.signal, AbortSignal.timeout(requestTimeoutMs)])
       : AbortSignal.timeout(requestTimeoutMs);
@@ -1680,6 +1736,14 @@ async function postAppRuntimeApi<TResponse>(
               serverTiming: parseRuntimeGatewayServerTiming(
                 response.headers.get('server-timing'),
               ),
+              platformRequestId: readRuntimeApiDiagnosticHeader(
+                response.headers,
+                'x-vercel-id',
+              ),
+              serverTimingHeader: readRuntimeApiDiagnosticHeader(
+                response.headers,
+                'server-timing',
+              ),
               requestBodyRawBytes: wireBody.rawBytes,
               requestBodyWireBytes: wireBody.wireBytes,
               requestBodySerializeMs,

package/dist/bundling-sources/shared_libs/play-runtime/output-size-limits.ts

@@ -1302,36 +1302,43 @@ function terminalFailureSummary(
 export function ledgerTerminalResultRefForValue(
   value: unknown,
   reason: LedgerTerminalResultRefReason,
-  options: { content?: 'full' } = {},
+  options: { content?: 'full'; deriveMetadata?: boolean } = {},
 ): LedgerTerminalResultRef {
+  // Fallbacks after a rejected projection must not serialize the same payload
+  // again just to derive optional metadata.
+  const { content, deriveMetadata = true } = options;
   let bytes: number | undefined;
-  try {
-    bytes = jsonByteLengthUpTo(value, LEDGER_TERMINAL_RESULT_MAX_BYTES).bytes;
-  } catch {
-    // The bounded reason is the useful diagnostic. Never serialize the
-    // customer payload again merely to populate reference metadata.
-  }
   let preview: BoundedRunListOutputPreview | undefined;
   let responsePreview: LedgerStoredRunOutputPreview | undefined;
-  if (options.content && isPlainObject(value)) {
+  let failure: LedgerTerminalFailureSummary | undefined;
+  if (deriveMetadata) {
     try {
-      preview = buildBoundedRunListOutputPreview(value);
-      responsePreview = reuseRunListValuesInOutputPreview(
-        buildBoundedRunOutputPreview(value),
-        preview,
-      );
+      bytes = jsonByteLengthUpTo(value, LEDGER_TERMINAL_RESULT_MAX_BYTES).bytes;
     } catch {
-      // The terminal reference is the durable fallback. A hostile/non-JSON
-      // value must not turn optional list-preview derivation into a terminal
-      // persistence failure.
+      // The bounded reason is the useful diagnostic. Never serialize the
+      // customer payload again merely to populate reference metadata.
+    }
+    if (content && isPlainObject(value)) {
+      try {
+        preview = buildBoundedRunListOutputPreview(value);
+        responsePreview = reuseRunListValuesInOutputPreview(
+          buildBoundedRunOutputPreview(value),
+          preview,
+        );
+      } catch {
+        // The terminal reference is the durable fallback. A hostile/non-JSON
+        // value must not turn optional list-preview derivation into a terminal
+        // persistence failure.
+      }
     }
+    failure = terminalFailureSummary(value);
   }
   return ledgerTerminalResultRef(reason, {
-    ...options,
+    ...(content ? { content } : {}),
     bytes,
     preview,
     responsePreview,
-    failure: terminalFailureSummary(value),
+    failure,
   });
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -161,7 +161,10 @@ import {
   loadArtifactFromAppRuntime,
   loadStagedFileFromAppRuntime,
   projectRunCreatedViaAppRuntime,
+  readRuntimeApiDiagnosticHeader,
   startRunViaAppRuntime,
+  type RuntimeApiRequestAttempt,
+  type RuntimeApiResponseMeta,
   type StoredPlayArtifactPayload,
   type WorkerRuntimeApiContext,
 } from '../app-runtime-api';
@@ -19723,6 +19726,14 @@ export type RunLedgerOutboxDispatchInput = {
    * can take the same row immediately under the same idempotency key.
    */
   signal?: AbortSignal;
+  /**
+   * Told once when an attempt abandoned by `signal` has handed back the lease
+   * it took: `true` when the owner-fenced release statement completed (a
+   * release that matched no row counts, since nothing is then held), `false`
+   * when it could not run and the lease is left to expire. Not called when
+   * the attempt never took a lease. Never affects delivery.
+   */
+  onAbortedLeaseRelease?: (released: boolean) => void;
   /**
    * Observation hook for acknowledged rows (event type and commit-to-ack lag
    * measured on the database clock). Never affects delivery.
@@ -20079,7 +20090,45 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       });
     }
   };
+  // The claim can be invoked more than once for one dispatch: the pool
+  // re-runs a checkout's operation after a connection failure, and the claim
+  // itself is retried once on the missing-marker compatibility path.
+  let claimInvocations = 0;
+  // An abandoned attempt that already handed its lease back on a checkout it
+  // held does not spend another checkout on the same release.
+  const abandonedLease = { released: false };
   const claimEvents = async (client: PostgresSchedulerQueryClient) => {
+    claimInvocations += 1;
+    const abandonedHeadEventId = input.headEventId?.trim();
+    if (
+      input.signal?.aborted &&
+      (claimInvocations === 1 || abandonedHeadEventId)
+    ) {
+      // The caller's deadline elapsed while this checkout was queued. Its
+      // attempt is already abandoned, so taking a lease now could only keep
+      // the durable projector off the row until that lease expires. Claim
+      // nothing: the row stays pending and unleased for its next owner.
+      if (claimInvocations > 1 && abandonedHeadEventId) {
+        // An earlier invocation's COMMIT may have reached the server before
+        // its connection failed, so this owner can already hold the named
+        // head. Hand it back here, fenced to this owner; returning empty
+        // would leave that lease with nobody to release it. After a rolled
+        // back invocation it matches no row. A failure propagates, so the
+        // attempt is never reported as settled.
+        await releasePostgresSchedulerOutboxLease(
+          client,
+          [abandonedHeadEventId],
+          { ...options, leaseOwner },
+        );
+      }
+      const unclaimed: {
+        events: PostgresSchedulerOutboxEvent[];
+        launchJson: unknown;
+      } = { events: [], launchJson: undefined };
+      return unclaimed;
+    }
+    // A re-invocation with no named head claims again under the same owner,
+    // as it always has; the abort check after the claim releases by id.
     // The checkout is exclusive. Hold the existing scheduler run's row lock
     // only while choosing/claiming its outbox prefix, never over HTTP. A
     // second statement takes a fresh READ COMMITTED snapshot after the lock:
@@ -20274,6 +20323,26 @@ async function dispatchRunLedgerOutboxBatchWithScope(
   let authorityReadyAtMs: number | null = null;
   let appendFinishedAtMs: number | null = null;
   let acknowledgedAtMs: number | null = null;
+  // How this delivery obtained its app authority, for the slow-delivery
+  // record only. `token` is set only when the dispatch-token endpoint was
+  // actually consulted; a token pre-minted at admission and an authority
+  // reused within the drain make no such request.
+  const authorityObserved: {
+    token: RunLedgerDispatchTokenObservation | null;
+    reusedWithinDrain: boolean;
+  } = { token: null, reusedWithinDrain: false };
+  // Platform identity of the slowest append response, for the same record.
+  // Null when no append was answered or its receiver sent no such header.
+  let appendResponse:
+    | (RunLedgerDispatchResponseTrace & { roundTripMs: number | null })
+    | null = null;
+  const callerOnResponseMeta = input.runtimeApi?.onResponseMeta;
+  // The last append attempt sent, named even when it never gets a response
+  // (an append aborted at the caller's deadline has no response to read).
+  const appendAttempt: { transportAttemptId: string | null } = {
+    transportAttemptId: null,
+  };
+  const callerOnRequestAttempt = input.runtimeApi?.onRequestAttempt;
   const materializeDeferredObservability = async () => {
     if (
       events.some(
@@ -20401,6 +20470,10 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     return null;
   };
   try {
+    // A deadline that elapsed during the claim abandons the attempt before
+    // any authority or renewal work. The abort branch below hands the lease
+    // straight back without charging a projection attempt.
+    input.signal?.throwIfAborted();
     // The ledger converter rejects raw deferred facts. Inline callers hand
     // them off; the background owner projects them before inspecting the
     // compact lifecycle payload or deciding that it needs no HTTP append.
@@ -20472,6 +20545,11 @@ async function dispatchRunLedgerOutboxBatchWithScope(
         ),
       ) + RUNTIME_RELIABILITY_POLICY.schedulerDatabase.queryTimeoutMs;
     const cachedAuthority = authorityScope.authority;
+    const observeDispatchTokenResponse = (
+      observation: RunLedgerDispatchTokenObservation,
+    ) => {
+      authorityObserved.token = observation;
+    };
     const resolveRunRuntimeApi = () =>
       launchJson !== null
         ? resolvePostgresSchedulerRuntimeApiForRun(
@@ -20484,6 +20562,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
             options,
             input.runtimeApi?.signal,
             reuseMarginMs,
+            observeDispatchTokenResponse,
           )
         : loadPostgresSchedulerRuntimeApiForRun(
             withClient,
@@ -20495,6 +20574,7 @@ async function dispatchRunLedgerOutboxBatchWithScope(
             options,
             input.runtimeApi?.signal,
             reuseMarginMs,
+            observeDispatchTokenResponse,
           );
     const gatewayRuntimeApi =
       needsRuntimeApi && tokenAuthority === 'gateway'
@@ -20505,6 +20585,11 @@ async function dispatchRunLedgerOutboxBatchWithScope(
           ? cachedAuthority.runtimeApi
           : await resolveRunRuntimeApi()
         : null;
+    // Read-only: an authority carried over from an earlier prefix of this
+    // drain made no request for this delivery.
+    authorityObserved.reusedWithinDrain =
+      gatewayRuntimeApi !== null &&
+      gatewayRuntimeApi === cachedAuthority?.runtimeApi;
     if (
       gatewayRuntimeApi &&
       cachedAuthority?.runId === first.runId &&
@@ -20542,6 +20627,27 @@ async function dispatchRunLedgerOutboxBatchWithScope(
                 : {}),
             }
           : {}),
+        // Keep the slowest append response's platform identity for the
+        // slow-delivery record, then hand the caller's own observer the same
+        // meta it always received. Observation never affects delivery.
+        onResponseMeta: (meta: RuntimeApiResponseMeta) => {
+          const roundTripMs = meta.roundTripMs ?? null;
+          if (
+            appendResponse === null ||
+            (roundTripMs ?? 0) >= (appendResponse.roundTripMs ?? 0)
+          ) {
+            appendResponse = {
+              platformRequestId: meta.platformRequestId ?? null,
+              serverTimingHeader: meta.serverTimingHeader ?? null,
+              roundTripMs,
+            };
+          }
+          callerOnResponseMeta?.(meta);
+        },
+        onRequestAttempt: (attempt: RuntimeApiRequestAttempt) => {
+          appendAttempt.transportAttemptId = attempt.transportAttemptId;
+          callerOnRequestAttempt?.(attempt);
+        },
         retryPolicy: 'none' as const,
         // The caller-owned admission deadline (see `signal` above) wins.
         ...(input.signal ? { signal: input.signal } : {}),
@@ -20669,11 +20775,22 @@ async function dispatchRunLedgerOutboxBatchWithScope(
           expiresAtMs: runtimeApiTokenExpiresAtMs(runtimeApi.executorToken),
         };
       }
-      await withClient((client) =>
-        renewPostgresRunLedgerDelivery(
+      const renewed = await withClient(async (client) => {
+        const eventIds = events.map((event) => event.eventId);
+        if (input.signal?.aborted) {
+          // The caller's deadline elapsed while this checkout was queued.
+          // Renewing now would extend an abandoned attempt's lease by a full
+          // term. Hand it back on this same checkout instead.
+          await releasePostgresSchedulerOutboxLease(client, eventIds, {
+            ...options,
+            leaseOwner,
+          });
+          return false;
+        }
+        await renewPostgresRunLedgerDelivery(
           client,
           {
-            eventIds: events.map((event) => event.eventId),
+            eventIds,
             leaseOwner,
             leaseSeconds: input.leaseSeconds ?? 120,
             freezeReceipt:
@@ -20684,8 +20801,14 @@ async function dispatchRunLedgerOutboxBatchWithScope(
               ),
           },
           options,
-        ),
-      );
+        );
+        return true;
+      });
+      if (!renewed) {
+        abandonedLease.released = true;
+        // Stop before the append; the abort branch below reports the outcome.
+        input.signal?.throwIfAborted();
+      }
     };
     if (needsRuntimeApi && runtimeApi) {
       const append = async (runtimeApi: WorkerRuntimeApiContext) => {
@@ -20832,28 +20955,41 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       // replay carries the same idempotency key and is a no-op there.
       const eventIds = events.map((event) => event.eventId);
       let released: string[];
-      try {
-        released = await withClient(
-          (client) =>
-            releasePostgresSchedulerOutboxLease(client, eventIds, {
-              ...options,
-              leaseOwner,
-            }),
-          {
-            runId: events[0]!.runId,
-            phase: 'run_ledger_outbox_lease_release',
-            priority: 'critical',
-          },
-        );
-      } catch (settlementError) {
-        logRunLedgerOutboxSettlementFailure({
-          runId: events[0]!.runId,
-          eventIds,
-          stage: 'aborted_release',
-          settlementError,
-          deliveryError: error,
-        });
+      let releaseLanded = abandonedLease.released;
+      if (releaseLanded) {
+        // The renewal checkout already handed the lease back.
         released = eventIds;
+      } else {
+        try {
+          released = await withClient(
+            (client) =>
+              releasePostgresSchedulerOutboxLease(client, eventIds, {
+                ...options,
+                leaseOwner,
+              }),
+            {
+              runId: events[0]!.runId,
+              phase: 'run_ledger_outbox_lease_release',
+              priority: 'critical',
+            },
+          );
+          releaseLanded = true;
+        } catch (settlementError) {
+          logRunLedgerOutboxSettlementFailure({
+            runId: events[0]!.runId,
+            eventIds,
+            stage: 'aborted_release',
+            settlementError,
+            deliveryError: error,
+          });
+          released = eventIds;
+        }
+      }
+      try {
+        // The caller must not read a failed release as a settled lease.
+        input.onAbortedLeaseRelease?.(releaseLanded);
+      } catch {
+        // Observation must never affect durable delivery.
       }
       return {
         attempted: events.length,
@@ -21036,6 +21172,19 @@ async function dispatchRunLedgerOutboxBatchWithScope(
         continuationMs:
           acknowledgedAtMs === null ? null : settledAtMs - acknowledgedAtMs,
         durationMs: settledAtMs - dispatchStartedAtMs,
+        // Which platform requests served the two app hops, so a slow
+        // authority or append stage can be found in the app's request log.
+        ...runLedgerSlowDeliveryResponseFields(
+          runLedgerDeliveryAuthoritySource({
+            authorityReady: authorityReadyAtMs !== null,
+            tokenAuthority,
+            reusedWithinDrain: authorityObserved.reusedWithinDrain,
+            token: authorityObserved.token,
+          }),
+          authorityObserved.token?.trace ?? null,
+          appendResponse,
+          appendAttempt.transportAttemptId,
+        ),
       });
     }
   }
@@ -21380,6 +21529,9 @@ async function resolvePostgresSchedulerRuntimeApiForRun(
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
   signal?: AbortSignal,
   tokenReuseMarginMs = 0,
+  onDispatchTokenResponse?: (
+    observation: RunLedgerDispatchTokenObservation,
+  ) => void,
 ): Promise<
   WorkerRuntimeApiContext & {
     refreshExecutorToken?: () => Promise<string>;
@@ -21441,6 +21593,14 @@ async function resolvePostgresSchedulerRuntimeApiForRun(
     } else {
       const dispatchAuthority =
         await requestRunLedgerDispatchToken(dispatchRequest);
+      try {
+        onDispatchTokenResponse?.({
+          reused: dispatchAuthority.reused,
+          trace: dispatchAuthority.responseTrace ?? null,
+        });
+      } catch {
+        // Observation must never affect durable delivery.
+      }
       invalidateExecutorToken = () =>
         runLedgerDispatchTokens.delete(dispatchAuthority.cacheKey);
       if (dispatchAuthority.reused) {
@@ -21475,6 +21635,9 @@ async function loadPostgresSchedulerRuntimeApiForRun(
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
   signal?: AbortSignal,
   tokenReuseMarginMs = 0,
+  onDispatchTokenResponse?: (
+    observation: RunLedgerDispatchTokenObservation,
+  ) => void,
 ): ReturnType<typeof resolvePostgresSchedulerRuntimeApiForRun> {
   // A continuation already owns its next event lease, so its launch context
   // is not part of the preclaim result. Load only the authority fields here.
@@ -21495,9 +21658,92 @@ async function loadPostgresSchedulerRuntimeApiForRun(
     options,
     signal,
     tokenReuseMarginMs,
+    onDispatchTokenResponse,
   );
 }
 
+/**
+ * Platform identity of one app response on the Run Ledger delivery path
+ * (`x-vercel-id` and the raw `Server-Timing` header, both bounded). It exists
+ * only to label the `[run-ledger-outbox.slow_delivery]` log record. It carries
+ * no credential and no run, org, or customer identifier, and it must never be
+ * written to a run, status, or receipt document.
+ */
+type RunLedgerDispatchResponseTrace = {
+  platformRequestId: string | null;
+  serverTimingHeader: string | null;
+};
+
+/**
+ * What one consultation of the dispatch-token endpoint returned: a token
+ * reused from this process's cache (`reused`, no request made, so no trace)
+ * or a fresh response. Reported only where that endpoint is consulted, never
+ * for a token pre-minted at admission.
+ */
+type RunLedgerDispatchTokenObservation = {
+  reused: boolean;
+  trace: RunLedgerDispatchResponseTrace | null;
+};
+
+/**
+ * Where a delivery's app authority came from, for the slow-delivery record:
+ * - `requested`: a dispatch-token request was made for this delivery, so
+ *   `authorityRequestId` names it when the receiver sent a platform id.
+ * - `cached`: a dispatch token reused from this process or this drain.
+ * - `pre_minted`: the run's admission-minted projection token.
+ * - `local`: signed in-process or supplied by the caller.
+ * Only `requested` makes an authority request; for every other source a null
+ * `authorityRequestId` means no request happened, not a missing header.
+ * `null` means the delivery ended before it had an authority.
+ */
+type RunLedgerDeliveryAuthoritySource =
+  | 'requested'
+  | 'cached'
+  | 'pre_minted'
+  | 'local';
+
+function runLedgerDeliveryAuthoritySource(input: {
+  authorityReady: boolean;
+  tokenAuthority: RunLedgerOutboxTokenAuthority;
+  reusedWithinDrain: boolean;
+  token: RunLedgerDispatchTokenObservation | null;
+}): RunLedgerDeliveryAuthoritySource | null {
+  if (!input.authorityReady) return null;
+  if (input.tokenAuthority !== 'gateway') return 'local';
+  if (input.token) return input.token.reused ? 'cached' : 'requested';
+  return input.reusedWithinDrain ? 'cached' : 'pre_minted';
+}
+
+function runLedgerSlowDeliveryResponseFields(
+  authoritySource: RunLedgerDeliveryAuthoritySource | null,
+  authority: RunLedgerDispatchResponseTrace | null,
+  append:
+    | (RunLedgerDispatchResponseTrace & { roundTripMs: number | null })
+    | null,
+  appendTransportAttemptId: string | null,
+): {
+  authoritySource: RunLedgerDeliveryAuthoritySource | null;
+  authorityRequestId: string | null;
+  authorityServerTiming: string | null;
+  appendRequestId: string | null;
+  appendServerTiming: string | null;
+  appendRoundTripMs: number | null;
+  appendTransportAttemptId: string | null;
+} {
+  return {
+    authoritySource,
+    authorityRequestId: authority?.platformRequestId ?? null,
+    authorityServerTiming: authority?.serverTimingHeader ?? null,
+    appendRequestId: append?.platformRequestId ?? null,
+    appendServerTiming: append?.serverTimingHeader ?? null,
+    appendRoundTripMs: append?.roundTripMs ?? null,
+    // The id this delivery sent in its last append request's
+    // transport-attempt header. Unlike the response fields above it is set
+    // even when that request was aborted or never answered.
+    appendTransportAttemptId,
+  };
+}
+
 /**
  * Admission persists an optional, run-scoped `run.ledger.project` token for the
  * worker's terminal fast path. Treat it as usable only when its decoded claims
@@ -21600,6 +21846,8 @@ async function requestRunLedgerDispatchToken(
   reused: boolean;
   cacheKey: string;
   runLedgerIngressPrefixBatching?: true;
+  /** Present only when this call made the request (never for a reused token). */
+  responseTrace?: RunLedgerDispatchResponseTrace;
 }> {
   const internalToken = process.env.DEEPLINE_INTERNAL_TOKEN?.trim();
   if (!internalToken || !input.eventId || !input.leaseOwner) {
@@ -21750,6 +21998,16 @@ async function requestRunLedgerDispatchToken(
     ...(body.runLedgerIngressPrefixBatching === true
       ? { runLedgerIngressPrefixBatching: true as const }
       : {}),
+    responseTrace: {
+      platformRequestId: readRuntimeApiDiagnosticHeader(
+        response.headers,
+        'x-vercel-id',
+      ),
+      serverTimingHeader: readRuntimeApiDiagnosticHeader(
+        response.headers,
+        'server-timing',
+      ),
+    },
   };
 }