@workflow/world-testing 5.0.0-beta.46 → 5.0.0-beta.48

package/dist/.well-known/workflow/v1/__step_registrations.mjs

@@ -370,6 +370,8 @@ var init_error_codes = __esm({
       MAX_EVENTS_EXCEEDED: "MAX_EVENTS_EXCEEDED",
       /** Workflow replay exceeded the maximum allowed duration */
       REPLAY_TIMEOUT: "REPLAY_TIMEOUT",
+      /** Workflow stream infrastructure failed while reading or writing data */
+      STREAM_ERROR: "STREAM_ERROR",
       /** World response violated the SDK contract and cannot be retried safely */
       WORLD_CONTRACT_ERROR: "WORLD_CONTRACT_ERROR",
       /** Run was delivered to a deployment other than the one it is pinned to */
@@ -410,12 +412,13 @@ function buildFramedDetails(hint2, slug) {
   });
   return out;
 }
-var BASE_URL, ERROR_SLUGS, WorkflowError, WorkflowWorldError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRuntimeError, RuntimeDecryptionError, SerializationError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRunNotFoundError, HookConflictError, HookNotFoundError, EntityConflictError, RunExpiredError, StreamExpiredError, ThrottleError, WorkflowRunCancelledError, FatalError, RetryableError, FATAL_ERROR_KEY, RETRYABLE_ERROR_KEY, HOOK_CONFLICT_ERROR_KEY, RUNTIME_DECRYPTION_ERROR_KEY;
+var BASE_URL, ERROR_SLUGS, WorkflowError, WorkflowWorldError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRuntimeError, RuntimeDecryptionError, SerializationError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRunNotFoundError, HookConflictError, HookNotFoundError, EntityConflictError, RunExpiredError, StreamError, StreamExpiredError, ThrottleError, WorkflowRunCancelledError, FatalError, RetryableError, FATAL_ERROR_KEY, RETRYABLE_ERROR_KEY, HOOK_CONFLICT_ERROR_KEY, RUNTIME_DECRYPTION_ERROR_KEY, STREAM_ERROR_KEY;
 var init_dist2 = __esm({
   "../errors/dist/index.js"() {
     "use strict";
     init_dist();
     init_error_codes();
+    init_error_codes();
     BASE_URL = "https://workflow-sdk.dev/err";
     __name(isError, "isError");
     __name(appendFramedDetails, "appendFramedDetails");
@@ -467,6 +470,12 @@ Caused by: ${options.cause.stack}`;
       url;
       /** Retry-After value in seconds, present on 429 and 425 responses */
       retryAfter;
+      /**
+       * The offending argument, present on client-side validation failures
+       * (`code: 'INVALID_ARGUMENT'`). Lets a caller correct the specific
+       * parameter without parsing the message.
+       */
+      field;
       constructor(message, options) {
         super(message, {
           cause: options?.cause
@@ -476,6 +485,7 @@ Caused by: ${options.cause.stack}`;
         this.code = options?.code;
         this.url = options?.url;
         this.retryAfter = options?.retryAfter;
+        this.field = options?.field;
       }
       static is(value) {
         return isError(value) && value.name === "WorkflowWorldError";
@@ -686,6 +696,23 @@ Caused by: ${options.cause.stack}`;
         return isError(value) && value.name === "RunExpiredError";
       }
     };
+    StreamError = class extends WorkflowWorldError {
+      static {
+        __name(this, "StreamError");
+      }
+      constructor(message, options) {
+        super(message, {
+          code: RUN_ERROR_CODES.STREAM_ERROR,
+          cause: options?.cause,
+          url: options?.url,
+          status: options?.status
+        });
+        this.name = "StreamError";
+      }
+      static is(value) {
+        return isError(value) && value.name === "StreamError";
+      }
+    };
     StreamExpiredError = class extends WorkflowWorldError {
       static {
         __name(this, "StreamExpiredError");
@@ -775,6 +802,7 @@ Caused by: ${options.cause.stack}`;
     RETRYABLE_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//RetryableError");
     HOOK_CONFLICT_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//HookConflictError");
     RUNTIME_DECRYPTION_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//RuntimeDecryptionError");
+    STREAM_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//StreamError");
     if (typeof globalThis !== "undefined") {
       if (!Object.hasOwn(globalThis, FATAL_ERROR_KEY)) {
         Object.defineProperty(globalThis, FATAL_ERROR_KEY, {
@@ -808,6 +836,14 @@ Caused by: ${options.cause.stack}`;
           configurable: false
         });
       }
+      if (!Object.hasOwn(globalThis, STREAM_ERROR_KEY)) {
+        Object.defineProperty(globalThis, STREAM_ERROR_KEY, {
+          value: StreamError,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+      }
     }
   }
 });
@@ -2804,6 +2840,7 @@ var RegisteredStepsKey, globalSymbols, registeredSteps, BUILTIN_RESPONSE_STEP_NA
 var init_private = __esm({
   "../core/dist/private.js"() {
     "use strict";
+    init_dist2();
     init_global();
     RegisteredStepsKey = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps");
     globalSymbols = globalThis;
@@ -19108,7 +19145,7 @@ var init_runs = __esm({
       // Completed state - output can be v1 or v2 format
       WorkflowRunBaseSchema.extend({
         status: external_exports.literal("completed"),
-        output: SerializedDataSchema,
+        output: SerializedDataSchema.optional(),
         error: external_exports.undefined().optional(),
         completedAt: external_exports.coerce.date()
       }),
@@ -19116,7 +19153,7 @@ var init_runs = __esm({
       WorkflowRunBaseSchema.extend({
         status: external_exports.literal("failed"),
         output: external_exports.undefined().optional(),
-        error: SerializedDataSchema,
+        error: SerializedDataSchema.optional(),
         completedAt: external_exports.coerce.date()
       })
     ]);
@@ -19372,8 +19409,8 @@ var init_analytics = __esm({
     AnalyticsAttributeKeySchema = external_exports.object({
       key: external_exports.string(),
       runCount: external_exports.coerce.number(),
-      firstSeenAt: external_exports.coerce.date(),
-      lastSeenAt: external_exports.coerce.date()
+      firstSeenAt: UTCDateSchema,
+      lastSeenAt: UTCDateSchema
     });
   }
 });
@@ -19509,8 +19546,9 @@ var init_queue = __esm({
       /** Epoch ms immediately before the queue publish was requested. */
       queuePublishRequestedAtMs: external_exports.number(),
       /**
-       * Which `resumeHook()` dispatch path ran: `lazy` or `sequential` (`parallel`
-       * from producers predating lazy-only resume).
+       * Which `resumeHook()` dispatch path ran. Current producers always report
+       * `sequential` (durable write, then wake); older producers may report
+       * `lazy` or `parallel`.
        */
       strategy: external_exports.string().optional(),
       /** Epoch ms the final consumer's queue handler was entered. */
@@ -19582,9 +19620,9 @@ var init_queue = __esm({
       /** Run creation data, only present on the first queue delivery from start() */
       runInput: RunInputSchema.optional(),
       /**
-       * Lazy hook resume data, only present when `resumeHook()` takes the parallel
-       * fast path. A consumer that understands this field idempotently ensures the
-       * `hook_received` event exists (keyed by `resumeId`) before replaying.
+       * Legacy lazy hook resume data. A consumer that understands this field
+       * idempotently ensures the `hook_received` event exists (keyed by `resumeId`)
+       * before replaying.
        */
       hookInput: HookResumeInputSchema.optional(),
       /**
@@ -19596,7 +19634,7 @@ var init_queue = __esm({
       stepInput: StepDispatchInputSchema.optional(),
       /**
        * Hook-resume TTR timing. Present on both `resumeHook()` dispatch paths
-       * (unlike `hookInput`, which only rides the lazy path), and
+       * (unlike legacy `hookInput`), and
        * forwarded onto a dispatched step message when the resuming invocation
        * hands the next durable step to another invocation. Purely observational.
        * See {@link HookResumeTimingSchema}.
@@ -19654,12 +19692,14 @@ var init_hooks = __esm({
       encryptionPublicKey: external_exports.string().optional(),
       // Feature marker: the version of the lazy-hook-resume consumer protocol the
       // run's creating deployment supports. Present (>= 1) means that deployment's
-      // `@workflow/core` re-ensures the `hook_received` event from the queue
-      // message's `hookInput` on replay, so `resumeHook()`'s lazy path is safe to
-      // use. Because a run is pinned to its creating deployment, this
-      // marker is a reliable per-run attestation, unlike inferring support from a
-      // version compare against a predicted release cutoff. Absent on runs created
-      // before the marker existed (fall back to the sequential path).
+      // `@workflow/core` re-ensures the `hook_received` event from a queue
+      // message's `hookInput` on replay. Current producers no longer send
+      // `hookInput` (the durable write happens before the wake is published), so
+      // they never read this marker; it remains stamped so OLDER producers, which
+      // still gate their lazy path on it, keep working against new runs. Because a
+      // run is pinned to its creating deployment, this marker is a reliable
+      // per-run attestation, unlike inferring support from a version compare
+      // against a predicted release cutoff.
       hookResumeInputVersion: external_exports.number().optional()
     });
     HOOK_RESUME_INPUT_VERSION = 1;
@@ -20438,6 +20478,18 @@ function getCommonReducers(_global = globalThis) {
       }
       return reduced;
     }, "RuntimeDecryptionError"),
+    StreamError: /* @__PURE__ */ __name((value) => {
+      const base = reduceNamedErrorSubclassBase("StreamError", value);
+      if (!base) return false;
+      const reduced = {
+        ...base
+      };
+      const status = readProperty(value, "status");
+      const url2 = readProperty(value, "url");
+      if (typeof status === "number") reduced.status = status;
+      if (typeof url2 === "string") reduced.url = url2;
+      return reduced;
+    }, "StreamError"),
     SyntaxError: makeErrorSubclassReducer("SyntaxError"),
     TypeError: makeErrorSubclassReducer("TypeError"),
     URIError: makeErrorSubclassReducer("URIError"),
@@ -20571,6 +20623,18 @@ function getCommonRevivers(global2 = globalThis) {
       if (value.stack !== void 0) error48.stack = value.stack;
       return error48;
     }, "RuntimeDecryptionError"),
+    StreamError: /* @__PURE__ */ __name((value) => {
+      const Ctor = global2[/* @__PURE__ */ Symbol.for("@workflow/errors//StreamError")] ?? StreamError;
+      const error48 = new Ctor(value.message, {
+        ..."cause" in value ? {
+          cause: value.cause
+        } : {},
+        status: value.status,
+        url: value.url
+      });
+      if (value.stack !== void 0) error48.stack = value.stack;
+      return error48;
+    }, "StreamError"),
     SyntaxError: makeErrorSubclassReviver(global2, "SyntaxError"),
     TypeError: makeErrorSubclassReviver(global2, "TypeError"),
     URIError: makeErrorSubclassReviver(global2, "URIError"),
@@ -21227,7 +21291,7 @@ function SemanticConvention(...names) {
     value
   ]));
 }
-var WorkflowName, WorkflowOperation, WorkflowRunId, WorkflowRunStatus, WorkflowStartedAt, WorkflowEventsCount, WorkflowExecutionMode, WorkflowParkedEventsCount, WorkflowParkedEventId, WorkflowParkedEventType, WorkflowArgumentsCount, WorkflowResultType, WorkflowTracePropagated, WorkflowVm, QuickJSOutcome, QuickJSEventsPreloaded, QuickJSEventsFetchedCount, QuickJSEventsFetchedPages, QuickJSPendingOpsCount, QuickJSInlineSteps, WorkflowTraceMode, WorkflowTurbo, WorkflowErrorName, WorkflowErrorMessage, WorkflowErrorCode, WorkflowStepsCreated, WorkflowHooksCreated, WorkflowWaitsCreated, WorkflowStepsFailedSerialization, WorkflowOwnedRecoverySteps, WorkflowBackstopWakesArmed, WorkflowRouteType, WorkflowRouteHandlerCached, WorkflowRouteInvocationCount, WorkflowRouteEntrypointAgeMs, WorkflowRouteModuleBodyInitMs, FaasInstance, StepName, StepId, StepAttempt, StepStatus, StepMaxRetries, StepTracePropagated, StepTtfsMs, StepStsoMs, StepRsfsMs, StepFinalSchedulingReplayMs, StepLatencyOptimizations, StepSkipped, StepSkipReason, StepArgumentsCount, StepResultType, StepErrorName, StepErrorMessage, StepFatalError, StepRetryExhausted, StepRetryTimeoutSeconds, StepRetryWillRetry, MessagingSystem, MessagingDestinationName, MessagingMessageId, MessagingOperationType, QueueOverheadMs, DeploymentId, WorkflowRunPinnedDeploymentId, WorkflowDeploymentMismatchRetryCount, WorkflowDeploymentMismatchRecovered, HookToken, HookId, HookFound, HookResilientResume, HookResilientResumeMaterialized, HookResumeSetupSource, StepResilientDispatchRecovered, StepResilientDispatchMaterialized, ResumeTotalMs, ResumeProducerPrepMs, ResumeQueueDeliveryMs, ResumeSetupMs, ResumeReplayMs, ResumeStepDispatchMs, ResumeStepClaimMs, ResumeStepPrepareMs, ResumeTrigger, ResumeStrategy, ResumeSetupSource, ResumeStepExecution, WebhookHandlersTriggered, WorkflowSuspensionState, WorkflowSuspensionHookCount, WorkflowSuspensionStepCount, WorkflowSuspensionWaitCount, HttpRequestMethod, HttpRoute, UrlFull, ServerAddress, ServerPort, HttpResponseStatusCode, ErrorType, WorldParseFormat, WorkflowEventsPagesLoaded, QueueDeserializeTimeMs, QueueExecutionTimeMs, QueueSerializeTimeMs, SerializationOperation, SerializationCompressed, SerializationCodec, SerializationUncompressedBytes, SerializationStoredBytes, SerializationCompressionRatio, SerializationGuestCodeExecutions, SerializationGuestCodeDetails, PeerService, RpcSystem, RpcService, RpcMethod, ErrorRetryable, ErrorCategory;
+var WorkflowName, WorkflowOperation, WorkflowRunId, WorkflowRunStatus, WorkflowStartedAt, WorkflowEventsCount, WorkflowExecutionMode, WorkflowBundleCompileCacheHit, WorkflowReplayLoadSource, WorkflowParkedEventsCount, WorkflowParkedEventId, WorkflowParkedEventType, WorkflowArgumentsCount, WorkflowResultType, WorkflowTracePropagated, WorkflowVm, QuickJSOutcome, QuickJSEventsPreloaded, QuickJSEventsFetchedCount, QuickJSEventsFetchedPages, QuickJSPendingOpsCount, QuickJSInlineSteps, WorkflowTraceMode, WorkflowTurbo, WorkflowErrorName, WorkflowErrorMessage, WorkflowErrorCode, WorkflowStepsCreated, WorkflowHooksCreated, WorkflowWaitsCreated, WorkflowStepsFailedSerialization, WorkflowOwnedRecoverySteps, WorkflowBackstopWakesArmed, WorkflowRouteType, WorkflowRouteHandlerCached, WorkflowRouteInvocationCount, WorkflowRouteEntrypointAgeMs, WorkflowRouteModuleBodyInitMs, FaasInstance, StepName, StepId, StepAttempt, StepStatus, StepMaxRetries, StepTracePropagated, StepTtfsMs, StepStsoMs, StepRsfsMs, StepFinalSchedulingReplayMs, StepLatencyOptimizations, StepSkipped, StepSkipReason, StepArgumentsCount, StepResultType, StepErrorName, StepErrorMessage, StepFatalError, StepRetryExhausted, StepRetryTimeoutSeconds, StepRetryWillRetry, MessagingSystem, MessagingDestinationName, MessagingMessageId, MessagingOperationType, QueueOverheadMs, DeploymentId, WorkflowRunPinnedDeploymentId, WorkflowDeploymentMismatchRetryCount, WorkflowDeploymentMismatchRecovered, HookToken, HookId, HookFound, HookResilientResume, HookResumeCommitted, HookWakePublished, HookResilientResumeMaterialized, HookResumeSetupSource, StepResilientDispatchRecovered, StepResilientDispatchMaterialized, ResumeTotalMs, ResumeProducerPrepMs, ResumeQueueDeliveryMs, ResumeSetupMs, ResumeReplayMs, ResumeStepDispatchMs, ResumeStepClaimMs, ResumeStepPrepareMs, ResumeTrigger, ResumeStrategy, ResumeSetupSource, ResumeStepExecution, WebhookHandlersTriggered, WorkflowSuspensionState, WorkflowSuspensionHookCount, WorkflowSuspensionStepCount, WorkflowSuspensionWaitCount, HttpRequestMethod, HttpRoute, UrlFull, ServerAddress, ServerPort, HttpResponseStatusCode, ErrorType, WorldParseFormat, WorkflowEventsPagesLoaded, QueueDeserializeTimeMs, QueueExecutionTimeMs, QueueSerializeTimeMs, SerializationOperation, SerializationCompressed, SerializationCodec, SerializationUncompressedBytes, SerializationStoredBytes, SerializationCompressionRatio, SerializationGuestCodeExecutions, SerializationGuestCodeDetails, PeerService, RpcSystem, RpcService, RpcMethod, ErrorRetryable, ErrorCategory;
 var init_semantic_conventions = __esm({
   "../core/dist/telemetry/semantic-conventions.js"() {
     "use strict";
@@ -21239,6 +21303,8 @@ var init_semantic_conventions = __esm({
     WorkflowStartedAt = SemanticConvention("workflow.started_at");
     WorkflowEventsCount = SemanticConvention("workflow.events.count");
     WorkflowExecutionMode = SemanticConvention("workflow.execution.mode");
+    WorkflowBundleCompileCacheHit = SemanticConvention("workflow.bundle.compile.cache_hit");
+    WorkflowReplayLoadSource = SemanticConvention("workflow.replay.load.source");
     WorkflowParkedEventsCount = SemanticConvention("workflow.events.parked.count");
     WorkflowParkedEventId = SemanticConvention("workflow.events.parked.event_id");
     WorkflowParkedEventType = SemanticConvention("workflow.events.parked.event_type");
@@ -21303,6 +21369,8 @@ var init_semantic_conventions = __esm({
     HookId = SemanticConvention("workflow.hook.id");
     HookFound = SemanticConvention("workflow.hook.found");
     HookResilientResume = SemanticConvention("workflow.hook.resilient_resume");
+    HookResumeCommitted = SemanticConvention("workflow.hook.resume_committed");
+    HookWakePublished = SemanticConvention("workflow.hook.wake_published");
     HookResilientResumeMaterialized = SemanticConvention("workflow.hook.resilient_resume_materialized");
     HookResumeSetupSource = SemanticConvention("workflow.resume_setup_source");
     StepResilientDispatchRecovered = SemanticConvention("workflow.step.resilient_dispatch_recovered");
@@ -23405,6 +23473,16 @@ async function deserializeTraceCarrier(traceCarrier) {
   if (!otel) return;
   return otel.propagation.extract(otel.context.active(), traceCarrier);
 }
+function describeThrownValue(value) {
+  try {
+    if (typeof value === "object" && value !== null && "message" in value && typeof value.message === "string") {
+      return value.message;
+    }
+    return String(value);
+  } catch {
+    return "Unknown error";
+  }
+}
 function logOtelDiagnosticOnce(otel, tracer) {
   const debugEnabled = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
   if (otelDiagLogged || !debugEnabled) return;
@@ -23459,7 +23537,7 @@ async function trace(spanName, ...args) {
       } else {
         span.setStatus({
           code: otel.SpanStatusCode.ERROR,
-          message: e.message
+          message: describeThrownValue(e)
         });
       }
       throw e;
@@ -23552,6 +23630,7 @@ var init_telemetry = __esm({
       });
     });
     otelDiagLogged = false;
+    __name(describeThrownValue, "describeThrownValue");
     __name(logOtelDiagnosticOnce, "logOtelDiagnosticOnce");
     __name(trace, "trace");
     __name(recordElapsedSpan, "recordElapsedSpan");
@@ -25963,7 +26042,7 @@ var version2;
 var init_version = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.46";
+    version2 = "5.0.0-beta.48";
   }
 });
 
@@ -31094,7 +31173,6 @@ var resume_hook_exports = {};
 __export(resume_hook_exports, {
   getHookByToken: () => getHookByToken,
   resumeHook: () => resumeHook,
-  resumeHookDurable: () => resumeHookDurable,
   resumeWebhook: () => resumeWebhook
 });
 async function computeResumePayloadDigest(bytes) {
@@ -31106,6 +31184,38 @@ async function computeResumePayloadDigest(bytes) {
   }
   return hex3;
 }
+function isRetryableWakeError(error48, isDeploymentUnavailableError) {
+  if (isDeploymentUnavailableError?.(error48)) return false;
+  const status = error48 ?? {};
+  const code2 = status.status ?? status.statusCode;
+  if (typeof code2 === "number") {
+    return code2 >= 500 || code2 === 408 || code2 === 429;
+  }
+  const name = error48?.name;
+  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
+}
+async function publishHookWakeWithRetry(publish, isDeploymentUnavailableError) {
+  let lastError;
+  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length; attempt++) {
+    try {
+      await publish();
+      return;
+    } catch (error48) {
+      lastError = error48;
+      if (!isRetryableWakeError(error48, isDeploymentUnavailableError)) break;
+      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];
+      if (delayMs !== void 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+  }
+  if (HookNotFoundError.is(lastError)) {
+    throw new WorkflowRuntimeError("The hook resume was committed, but its workflow wake could not be published", {
+      cause: lastError
+    });
+  }
+  throw lastError;
+}
 function resumeContextFromRun(run2) {
   const coreVersion = run2.executionContext?.workflowCoreVersion;
   const traceCarrier = run2.executionContext?.traceCarrier;
@@ -31163,12 +31273,9 @@ async function getHookByToken(token) {
   return hook;
 }
 async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now(), false);
-}
-async function resumeHookDurable(tokenOrHook, payload, encryptionKeyOverride) {
-  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now(), true);
+  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
-async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs, requireDurableWrite) {
+async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs) {
   return await waitedUntil(() => {
     return trace("hook.resume", async (span) => {
       const world = await getWorldLazy();
@@ -31205,11 +31312,15 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
         }
         const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION && capabilities.supportedFormats.has(SerializationFormat.GZIP);
         const ops = [];
+        const readbackOps = [];
         const v1Compat = isLegacySpecVersion(hook.specVersion);
-        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression);
-        safeWaitUntil(Promise.all(ops), (err) => {
+        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression, void 0, readbackOps);
+        await Promise.all(ops.map((op) => op.catch((error48) => {
+          if (error48 !== void 0) throw error48;
+        })));
+        safeWaitUntil(Promise.all(readbackOps), (err) => {
           if (err === void 0) return;
-          runtimeLogger.warn("Background flush of hook payload ops failed", {
+          runtimeLogger.warn("Background readback of hook payload failed", {
             workflowRunId: hook.runId,
             hookId: hook.hookId,
             error: err instanceof Error ? err.message : String(err)
@@ -31227,81 +31338,66 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
           deploymentId: resumeContext.deploymentId,
           specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY
         };
-        const lazyResumeDisabled = process.env.WORKFLOW_DISABLE_LAZY_HOOK_RESUME === "1";
         const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION || world.capabilities?.hookResumeDedup === true;
-        const fallbackReason = requireDurableWrite ? (
-          // resolves (an ordering barrier), which only the eager write
-          // provides. Checked first so the span names the real reason
-          // rather than whichever gate happens to fail alongside it.
-          "durable_required"
-        ) : lazyResumeDisabled ? "disabled" : !backendDedupSupported ? "backend_unsupported" : (resumeContext.hookResumeInputVersion ?? 0) < HOOK_RESUME_INPUT_VERSION ? "consumer_unsupported" : v1Compat ? "legacy" : (resumeContext.runSpecVersion ?? 0) < SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT ? "non_cbor_transport" : !(dehydratedPayload instanceof Uint8Array) ? "non_bytes" : dehydratedPayload.byteLength > MAX_INLINE_RESUME_PAYLOAD_BYTES ? "oversized" : null;
-        const useLazyResume = fallbackReason === null;
+        const canClaimResume = backendDedupSupported && !v1Compat && dehydratedPayload instanceof Uint8Array;
         span?.setAttributes({
-          "workflow.hook.resume_strategy": useLazyResume ? "lazy" : "sequential",
-          ...fallbackReason ? {
-            "workflow.hook.resume_fallback_reason": fallbackReason
-          } : {}
+          "workflow.hook.resume_strategy": "sequential"
         });
-        if (!useLazyResume) {
-          const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError.is(err) || EntityConflictError.is(err) || RunExpiredError.is(err), "isHookGoneError");
-          try {
-            await world.events.create(hook.runId, {
-              eventType: "hook_received",
-              specVersion: SPEC_VERSION_CURRENT,
-              correlationId: hook.hookId,
-              eventData: {
-                ...v1Compat ? {} : {
-                  token: hook.token
-                },
-                payload: dehydratedPayload
-              }
-            }, {
-              v1Compat
-            });
-          } catch (err) {
-            if (isHookGoneError(err)) {
-              throw new HookNotFoundError(hook.token);
-            }
-            throw err;
-          }
-          const queuePublishRequestedAtMs2 = Date.now();
-          await world.queue(queueName, {
-            runId: hook.runId,
-            traceCarrier: resumeContext.traceCarrier ?? void 0,
-            hookResumeTiming: {
-              resumeRequestedAtMs,
-              queuePublishRequestedAtMs: queuePublishRequestedAtMs2,
-              strategy: "sequential"
+        const resumeId = canClaimResume ? generateResumeId() : void 0;
+        const payloadDigest = canClaimResume ? await computeResumePayloadDigest(dehydratedPayload) : void 0;
+        if (resumeId) {
+          span?.setAttributes({
+            "workflow.hook.resume_id": resumeId
+          });
+        }
+        const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError.is(err) || RunExpiredError.is(err), "isHookGoneError");
+        try {
+          await world.events.create(hook.runId, {
+            eventType: "hook_received",
+            specVersion: SPEC_VERSION_CURRENT,
+            correlationId: hook.hookId,
+            eventData: {
+              ...v1Compat ? {} : {
+                token: hook.token
+              },
+              payload: dehydratedPayload
             }
-          }, queueOptions);
-          return hook;
+          }, {
+            v1Compat,
+            ...resumeId && payloadDigest ? {
+              resumeId,
+              resumePayloadDigest: payloadDigest
+            } : {}
+          });
+        } catch (err) {
+          if (isHookGoneError(err)) {
+            throw new HookNotFoundError(hook.token);
+          }
+          throw err;
         }
-        const resumeId = generateResumeId();
-        const payloadDigest = await computeResumePayloadDigest(dehydratedPayload);
-        span?.setAttributes({
-          "workflow.hook.resume_id": resumeId
-        });
+        span?.setAttributes(HookResumeCommitted(true));
         const queuePublishRequestedAtMs = Date.now();
-        await world.queue(queueName, {
+        await publishHookWakeWithRetry(() => world.queue(queueName, {
           runId: hook.runId,
           traceCarrier: resumeContext.traceCarrier ?? void 0,
-          hookInput: {
-            resumeId,
-            hookId: hook.hookId,
-            token: hook.token,
-            payload: dehydratedPayload,
-            payloadDigest,
-            // Deployment affinity for the consumer's cheap pre-write
-            // check: lets a misrouted delivery re-route before its
-            // hoisted hook_received write instead of after.
-            deploymentId: resumeContext.deploymentId
-          },
           hookResumeTiming: {
             resumeRequestedAtMs,
             queuePublishRequestedAtMs,
-            strategy: "lazy"
+            strategy: "sequential"
           }
-        }, queueOptions);
+        }, {
+          ...queueOptions,
+          // Dedup retried publishes whose response was lost: a
+          // duplicate wake is harmless for correctness (deterministic
+          // replay) but costs a full replay of the run, and the queue
+          // accepts a repeated idempotency key by delivering only one
+          // of the messages. Claim-less writes have no resumeId and
+          // keep the previous behavior.
+          ...resumeId ? {
+            idempotencyKey: `hook-${resumeId}`
+          } : {}
+        }), world.isDeploymentUnavailableError?.bind(world));
+        span?.setAttributes(HookWakePublished(true));
         return hook;
       } catch (err) {
         span?.setAttributes({
@@ -31338,7 +31434,7 @@ async function resumeWebhook(token, request) {
       status: 202
     });
   }
-  await resumeHookImpl(hook, request, encryptionKey, true, resumeRequestedAtMs, false);
+  await resumeHookImpl(hook, request, encryptionKey, true, resumeRequestedAtMs);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -31354,7 +31450,7 @@ async function resumeWebhook(token, request) {
   }
   return response;
 }
-var generateResumeId, MAX_INLINE_RESUME_PAYLOAD_BYTES;
+var generateResumeId, HOOK_WAKE_RETRY_DELAYS_MS;
 var init_resume_hook = __esm({
   "../core/dist/runtime/resume-hook.js"() {
     "use strict";
@@ -31374,15 +31470,19 @@ var init_resume_hook = __esm({
     init_helpers();
     init_wait_until();
     generateResumeId = monotonicFactory();
-    MAX_INLINE_RESUME_PAYLOAD_BYTES = 128 * 1024;
     __name(computeResumePayloadDigest, "computeResumePayloadDigest");
+    HOOK_WAKE_RETRY_DELAYS_MS = [
+      25,
+      100
+    ];
+    __name(isRetryableWakeError, "isRetryableWakeError");
+    __name(publishHookWakeWithRetry, "publishHookWakeWithRetry");
     __name(resumeContextFromRun, "resumeContextFromRun");
     __name(resolveHookResumeInfo, "resolveHookResumeInfo");
     __name(resolveHookEncryptionKey, "resolveHookEncryptionKey");
     __name(getHookByTokenWithKey, "getHookByTokenWithKey");
     __name(getHookByToken, "getHookByToken");
     __name(resumeHook, "resumeHook");
-    __name(resumeHookDurable, "resumeHookDurable");
     __name(resumeHookImpl, "resumeHookImpl");
     __name(resumeWebhook, "resumeWebhook");
   }
@@ -31650,6 +31750,18 @@ function recordReadTimeToFirstChunk(startEpochMs, runId, name, startIndex, conne
     });
   })();
 }
+function recordStreamReadKeyResolution(startEpochMs, runId, name, succeeded) {
+  void (async () => {
+    await recordElapsedSpan("workflow.stream.read.resolve_key", startEpochMs, {
+      kind: await getSpanKind("CLIENT"),
+      attributes: {
+        "workflow.run.id": runId,
+        "workflow.stream.name": name,
+        "workflow.stream.read.key_succeeded": succeeded
+      }
+    });
+  })();
+}
 function recordStreamReadComplete(startEpochMs, runId, name, chunkCount, byteCount, reconnects) {
   void (async () => {
     await recordElapsedSpan("workflow.stream.read.complete", startEpochMs, {
@@ -31668,26 +31780,46 @@ function recordStreamReadComplete(startEpochMs, runId, name, chunkCount, byteCou
     });
   })();
 }
-function createReconnectingFramedStream(runId, name, startIndex) {
+function createReconnectingFramedStream(runId, name, startIndex, prefetchEncryptionKey = async () => void 0) {
   const reconnectSupported = startIndex === void 0 || startIndex >= 0;
   let currentStartIndex = startIndex ?? 0;
   let consumedFrames = 0;
   let reconnectCount = 0;
   let totalReconnectCount = 0;
   let reader;
+  let canceled = false;
+  let cancelReason;
   let buffer2 = new Uint8Array(0);
   let readStart;
   let connectMs;
   let firstChunkReported = false;
   let chunksDelivered = 0;
   let bytesDelivered = 0;
+  let keyPrefetched = false;
+  function prefetchKey() {
+    if (keyPrefetched) return;
+    keyPrefetched = true;
+    const keyStart = Date.now();
+    void prefetchEncryptionKey().then((key) => {
+      if (key) recordStreamReadKeyResolution(keyStart, runId, name, true);
+    }, () => recordStreamReadKeyResolution(keyStart, runId, name, false));
+  }
+  __name(prefetchKey, "prefetchKey");
   async function connect() {
+    if (canceled) return false;
     const world = await getWorldLazy();
+    if (canceled) return false;
     const effectiveStartIndex = reconnectSupported ? currentStartIndex + consumedFrames : startIndex;
     const connectStart = Date.now();
     const stream = await world.streams.get(runId, name, effectiveStartIndex);
+    if (canceled) {
+      await stream.cancel(cancelReason).catch(() => {
+      });
+      return false;
+    }
     if (connectMs === void 0) connectMs = Date.now() - connectStart;
     reader = stream.getReader();
+    return true;
   }
   __name(connect, "connect");
   async function isVerifiedComplete() {
@@ -31701,11 +31833,13 @@ function createReconnectingFramedStream(runId, name, startIndex) {
   }
   __name(isVerifiedComplete, "isVerifiedComplete");
   async function reconnect() {
+    if (canceled) return false;
     if (reader) {
       await reader.cancel().catch(() => {
       });
       reader = void 0;
     }
+    if (canceled) return false;
     currentStartIndex += consumedFrames;
     consumedFrames = 0;
     buffer2 = new Uint8Array(0);
@@ -31715,15 +31849,16 @@ function createReconnectingFramedStream(runId, name, startIndex) {
       reconnectCount++;
       totalReconnectCount++;
       if (reconnectCount > maxReconnects) {
-        throw new Error(`Stream "${name}" exceeded maximum reconnection attempts (${maxReconnects})`);
+        throw new StreamError(`Stream "${name}" exceeded maximum reconnection attempts (${maxReconnects})`);
       }
       if (totalReconnectCount > maxTotalReconnects) {
-        throw new Error(`Stream "${name}" exceeded maximum total reconnection attempts (${maxTotalReconnects})`);
+        throw new StreamError(`Stream "${name}" exceeded maximum total reconnection attempts (${maxTotalReconnects})`);
       }
       try {
-        await connect();
-        return;
+        if (!await connect()) return false;
+        return true;
       } catch (error48) {
+        if (canceled) return false;
         if (StreamExpiredError.is(error48)) throw error48;
       }
     }
@@ -31731,12 +31866,15 @@ function createReconnectingFramedStream(runId, name, startIndex) {
   __name(reconnect, "reconnect");
   return new ReadableStream({
     pull: /* @__PURE__ */ __name(async (controller) => {
+      if (canceled) return;
       if (readStart === void 0) readStart = Date.now();
+      prefetchKey();
       for (; ; ) {
         if (!reader) {
           try {
-            await connect();
+            if (!await connect()) return;
           } catch (err) {
+            if (canceled) return;
             controller.error(err);
             return;
           }
@@ -31745,23 +31883,27 @@ function createReconnectingFramedStream(runId, name, startIndex) {
         try {
           result = await reader.read();
         } catch (err) {
+          if (canceled) return;
           if (!reconnectSupported) {
             controller.error(err);
             return;
           }
           try {
-            await reconnect();
+            if (!await reconnect()) return;
           } catch (reconnectErr) {
             controller.error(reconnectErr);
             return;
           }
           continue;
         }
+        if (canceled) return;
         if (result.done || !result.value) {
           reader = void 0;
-          if (reconnectSupported && !await isVerifiedComplete()) {
+          const verifiedComplete = !reconnectSupported || await isVerifiedComplete();
+          if (canceled) return;
+          if (!verifiedComplete) {
             try {
-              await reconnect();
+              if (!await reconnect()) return;
             } catch (reconnectErr) {
               controller.error(reconnectErr);
               return;
@@ -31803,12 +31945,15 @@ function createReconnectingFramedStream(runId, name, startIndex) {
         }
       }
     }, "pull"),
-    cancel: /* @__PURE__ */ __name(async () => {
-      if (reader) {
-        await reader.cancel().catch((err) => {
+    cancel: /* @__PURE__ */ __name(async (reason) => {
+      canceled = true;
+      cancelReason = reason;
+      const currentReader = reader;
+      reader = void 0;
+      if (currentReader) {
+        await currentReader.cancel(reason).catch((err) => {
           console.warn("Error closing ReadableStream reader:", err);
         });
-        reader = void 0;
       }
     }, "cancel")
   });
@@ -31945,7 +32090,7 @@ function attachAbortListenerOnce(signal, streamName, runId, cryptoKey, ops) {
     once: true
   });
 }
-function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
+function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier, readbackOps = ops) {
   return {
     ...getAllBaseReducers(global2),
     ReadableStream: /* @__PURE__ */ __name((value) => {
@@ -31966,7 +32111,7 @@ function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framed
           ops.push(value.pipeTo(writable));
         }
       } else {
-        ops.push(value.pipeThrough(getSerializeStream(getExternalReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey)).pipeTo(writable));
+        ops.push(value.pipeThrough(getSerializeStream(getExternalReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier, readbackOps), cryptoKey)).pipeTo(writable));
       }
       const s = {
         name
@@ -31997,7 +32142,7 @@ function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framed
       const streamId = (global2[STABLE_ULID] || defaultUlid)();
       const name = `strm_${streamId}`;
       const readable = new WorkflowServerReadableStream(runId, name);
-      ops.push(readable.pipeTo(value));
+      readbackOps.push(readable.pipeTo(value));
       return {
         name
       };
@@ -32096,7 +32241,7 @@ function getWorkflowReducers(global2 = globalThis) {
     }, "AbortSignal")
   };
 }
-function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier) {
+function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByteStreams = false, runReadyBarrier, readbackOps = ops) {
   return {
     ...getAllBaseReducers(global2),
     ReadableStream: /* @__PURE__ */ __name((value) => {
@@ -32122,7 +32267,7 @@ function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByte
             ops.push(value.pipeTo(writable));
           }
         } else {
-          ops.push(value.pipeThrough(getSerializeStream(getStepReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier), cryptoKey)).pipeTo(writable));
+          ops.push(value.pipeThrough(getSerializeStream(getStepReducers(global2, ops, runId, cryptoKey, framedByteStreams, runReadyBarrier, readbackOps), cryptoKey)).pipeTo(writable));
         }
       }
       const s = {
@@ -32139,7 +32284,7 @@ function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByte
       if (!name) {
         const streamId = (global2[STABLE_ULID] || defaultUlid)();
         name = `strm_${streamId}`;
-        ops.push(new WorkflowServerReadableStream(runId, name).pipeThrough(getDeserializeStream(getStepRevivers(global2, ops, runId, cryptoKey), cryptoKey)).pipeTo(value));
+        readbackOps.push(new WorkflowServerReadableStream(runId, name).pipeThrough(getDeserializeStream(getStepRevivers(global2, readbackOps, runId, cryptoKey), cryptoKey)).pipeTo(value));
       }
       const s = {
         name
@@ -32268,8 +32413,8 @@ function reviveAbortController(value, ops, runId) {
       if (value.hookToken) {
         const hookResume = (async () => {
           try {
-            const { resumeHookDurable: resumeHookDurable2 } = await Promise.resolve().then(() => (init_resume_hook(), resume_hook_exports));
-            await resumeHookDurable2(value.hookToken, {
+            const { resumeHook: resumeHook2 } = await Promise.resolve().then(() => (init_resume_hook(), resume_hook_exports));
+            await resumeHook2(value.hookToken, {
               aborted: true,
               reason
             });
@@ -32313,7 +32458,51 @@ async function getForwardedWritableEncryptionKey(runId, deploymentId, encryption
     "encrypt"
   ]) : void 0;
 }
-function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey) {
+function getRunReadableStream(global2, ops, runId, name, startIndex, cryptoKey) {
+  let reader;
+  let lockState;
+  let lockPollingStarted = false;
+  let userReadable;
+  userReadable = new ReadableStream(
+    {
+      async pull(controller) {
+        try {
+          if (!reader) {
+            const stream = getExternalRevivers(global2, ops, runId, cryptoKey, {
+              onReadableState: /* @__PURE__ */ __name((state) => {
+                lockState = state;
+              }, "onReadableState")
+            }).ReadableStream({
+              name,
+              startIndex
+            });
+            reader = stream.getReader();
+            if (lockState && !lockPollingStarted) {
+              lockPollingStarted = true;
+              pollReadableLock(userReadable, lockState);
+            }
+          }
+          const result = await reader.read();
+          if (result.done) controller.close();
+          else controller.enqueue(result.value);
+        } catch (error48) {
+          controller.error(error48);
+        }
+      },
+      async cancel(reason) {
+        await reader?.cancel(reason).catch(() => {
+        });
+      }
+    },
+    // A positive default high-water mark would run pull at construction to
+    // fill the queue, turning an unread Run.getReadable() into I/O.
+    {
+      highWaterMark: 0
+    }
+  );
+  return userReadable;
+}
+function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey, options) {
   return {
     ...getCommonRevivers2(global2),
     // StepFunction should not be returned from workflows to clients
@@ -32361,16 +32550,23 @@ function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey) {
         const { readable: userReadable, writable } = value.framing === "framed-v1" ? getByteUnframingStream() : new global2.TransformStream();
         flushablePipe(readable, writable, state).catch(() => {
         });
-        pollReadableLock(userReadable, state);
+        if (options?.onReadableState) options.onReadableState(state);
+        else pollReadableLock(userReadable, state);
         return userReadable;
       } else {
-        const readable = createReconnectingFramedStream(runId, value.name, value.startIndex);
-        const transform2 = getDeserializeStream(getExternalRevivers(global2, ops, runId, cryptoKey), cryptoKey);
+        let keyPromise;
+        const resolveKey = /* @__PURE__ */ __name(() => {
+          keyPromise ??= resolveEncryptionKey(cryptoKey);
+          return keyPromise;
+        }, "resolveKey");
+        const readable = createReconnectingFramedStream(runId, value.name, value.startIndex, resolveKey);
+        const transform2 = getDeserializeStream(getExternalRevivers(global2, ops, runId, resolveKey), resolveKey);
         const state = createFlushableState();
         ops.push(state.promise);
         flushablePipe(readable, transform2.writable, state).catch(() => {
         });
-        pollReadableLock(transform2.readable, state);
+        if (options?.onReadableState) options.onReadableState(state);
+        else pollReadableLock(transform2.readable, state);
         return transform2.readable;
       }
     }, "ReadableStream"),
@@ -32581,16 +32777,16 @@ function getStepRevivers(global2 = globalThis, ops, runId, cryptoKey, deployment
     AbortSignal: /* @__PURE__ */ __name((value) => reviveAbortSignal(value, ops, runId), "AbortSignal")
   };
 }
-async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
+async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, readbackOps = ops) {
   if (v1Compat) {
-    const str = stringify(value, getExternalReducers(global2, ops, runId, key, framedByteStreams));
+    const str = stringify(value, getExternalReducers(global2, ops, runId, key, framedByteStreams, void 0, readbackOps));
     return revive(str);
   }
   try {
     const compressionStats = {};
     const result = await serialize(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getExternalReducers(global2, ops, runId, key, framedByteStreams)),
+      extraReducers: getStreamAndRequestReducers(getExternalReducers(global2, ops, runId, key, framedByteStreams, void 0, readbackOps)),
       compression,
       compressionStats
     });
@@ -32660,16 +32856,16 @@ async function hydrateStepArguments(value, runId, key, ops = [], global2 = globa
   await recordCompression(compressionStats, "deserialize");
   return result;
 }
-async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier) {
+async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false, runReadyBarrier, readbackOps = ops) {
   if (v1Compat) {
-    const str = stringify(value, getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier));
+    const str = stringify(value, getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier, readbackOps));
     return revive(str);
   }
   try {
     const compressionStats = {};
     const result = await serialize2(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier)),
+      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams, runReadyBarrier, readbackOps)),
       compression,
       compressionStats
     });
@@ -32766,6 +32962,7 @@ var init_serialization2 = __esm({
     __name(getByteFramingStream, "getByteFramingStream");
     __name(getByteUnframingStream, "getByteUnframingStream");
     __name(recordReadTimeToFirstChunk, "recordReadTimeToFirstChunk");
+    __name(recordStreamReadKeyResolution, "recordStreamReadKeyResolution");
     __name(recordStreamReadComplete, "recordStreamReadComplete");
     WorkflowServerReadableStream = class extends ReadableStream {
       static {
@@ -33080,6 +33277,7 @@ var init_serialization2 = __esm({
     __name(reviveAbortSignal, "reviveAbortSignal");
     __name(getCommonRevivers2, "getCommonRevivers");
     __name(getForwardedWritableEncryptionKey, "getForwardedWritableEncryptionKey");
+    __name(getRunReadableStream, "getRunReadableStream");
     __name(getExternalRevivers, "getExternalRevivers");
     __name(getStepRevivers, "getStepRevivers");
     __name(dehydrateWorkflowArguments, "dehydrateWorkflowArguments");
@@ -33258,7 +33456,8 @@ var WORLD_CONTRACT_ERROR_CODES = /* @__PURE__ */ new Set([
 ]);
 var RETRYABLE_WORLD_ERROR_CODES = /* @__PURE__ */ new Set([
   "TRANSPORT",
-  "TIMEOUT"
+  "TIMEOUT",
+  RUN_ERROR_CODES.STREAM_ERROR
 ]);
 var RUNTIME_ERROR_CHECKS = [
   WorkflowRuntimeError.is,
@@ -33274,6 +33473,9 @@ function isRetryableWorldError(err) {
   if (ThrottleError.is(err)) {
     return true;
   }
+  if (StreamError.is(err)) {
+    return err.status === void 0 || err.status >= 500;
+  }
   if (!WorkflowWorldError.is(err)) {
     return false;
   }
@@ -33460,9 +33662,9 @@ async function start(workflow, argsOrOptions, options) {
         },
         // Attest that the *consumer* deployment's runtime re-ensures a
         // `hook_received` event from a queue message's `hookInput` on replay.
-        // A resume of this run reads the marker (mirrored onto the hook's
-        // resumeContext by the server) to decide whether the parallel fast
-        // path is safe. For a cross-deployment start the consumer is the
+        // An OLDER producer resuming this run reads the marker (mirrored onto
+        // the hook's resumeContext by the server) to decide whether its lazy
+        // fast path is safe. For a cross-deployment start the consumer is the
         // target deployment, so we stamp the *target's* value carried back on
         // the health-check probe, never the caller's. Omitted when we could
         // not attest the target (older target, timeout, or no probe channel),
@@ -33573,7 +33775,7 @@ __name(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.46//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.48//start");
 
 // ../core/dist/runtime/runs.js
 async function wakeUpRun(world, runId, options) {
@@ -33757,9 +33959,9 @@ var Run = class _Run {
     return this.#encryptionKeyPromise;
   }
   /**
-   * Defer fetching the run and its encryption key until serialized stream data
-   * is actually read. An empty or metadata-only stream must not start an
-   * unobserved run lookup.
+   * Defers fetching the run and its encryption key until a readable is first
+   * consumed. The first pull prefetches it so an encrypted first frame can join
+   * the lookup; this also applies to an empty consumed stream.
    * @internal
    */
   #getEncryptionKeyLazily() {
@@ -33870,10 +34072,7 @@ var Run = class _Run {
     const { ops = [], global: global2 = globalThis, startIndex, namespace } = options;
     const name = getWorkflowRunStreamId(this.runId, namespace);
     const encryptionKey = this.#getEncryptionKeyLazily();
-    const stream = getExternalRevivers(global2, ops, this.runId, encryptionKey).ReadableStream({
-      name,
-      startIndex
-    });
+    const stream = getRunReadableStream(global2, ops, this.runId, name, startIndex, encryptionKey);
     const worldPromise = this.#lazyWorldPromise;
     const runId = this.runId;
     return Object.assign(stream, {
@@ -33972,7 +34171,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#wakeUp");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -33981,7 +34180,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#cancel");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -33990,7 +34189,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#getReadable");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -33999,7 +34198,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#exists");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -34008,7 +34207,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#status");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -34017,7 +34216,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#returnValue");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -34026,7 +34225,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#workflowName");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -34035,7 +34234,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#createdAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -34044,7 +34243,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#startedAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -34053,7 +34252,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.46//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.48//Run#completedAt");
 (function(__wf_cls, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("workflow-class-registry"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_cls);
@@ -34063,7 +34262,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.46//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.48//Run");
 
 // ../workflow/dist/stdlib.js
 async function fetch2(...args) {