deepline 0.3.245 → 0.3.247

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

@@ -113,7 +113,10 @@ import type { MonitorFleetDefinition } from './monitor-fleets.js';
 import type { PlayStagedFileRef } from './plays/local-file-discovery.js';
 import type { PlayCompilerManifest } from '../../shared_libs/plays/compiler-manifest.js';
 import type { EnrichCompiledConfig } from './cli/enrich-play-compiler.js';
-import { RUNTIME_ENVIRONMENT_TOKEN_HEADER } from '../../shared_libs/play-runtime/coordinator-headers.js';
+import {
+  RUNTIME_ENVIRONMENT_TOKEN_HEADER,
+  RETAINED_PIPELINE_RECEIVERS_HEADER,
+} from '../../shared_libs/play-runtime/coordinator-headers.js';
 import {
   normalizePlayRuntimeEnvironment,
   normalizePlayRuntimeNamespace,
@@ -123,6 +126,7 @@ import {
 } from '../../shared_libs/play-runtime/runtime-environment.js';
 import {
   decodePlayRunPublicStatus,
+  isTerminalPlayRunLifecycleStatus,
   type PlayRunPublicStatus,
 } from '../../shared_libs/play-runtime/run-lifecycle-policy.js';
 export type SlackNotificationTarget =
@@ -209,7 +213,6 @@ function notificationObjectKey(kind: 'group' | 'destination') {
   return `${kind}.${globalThis.crypto.randomUUID()}`;
 }
 
-const TERMINAL_PLAY_STATUSES = new Set(['completed', 'failed', 'cancelled']);
 const MONITOR_NON_RETRYABLE_MUTATION_OPTIONS = {
   maxRetries: 0,
   exactUrlOnly: true,
@@ -403,7 +406,12 @@ function runtimeSelectionHeaders(
       'RUNTIME_ENVIRONMENT_TOKEN_REQUIRED',
     );
   }
-  return { [RUNTIME_ENVIRONMENT_TOKEN_HEADER]: token };
+  const receivers =
+    process.env.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim();
+  return {
+    [RUNTIME_ENVIRONMENT_TOKEN_HEADER]: token,
+    ...(receivers ? { [RETAINED_PIPELINE_RECEIVERS_HEADER]: receivers } : {}),
+  };
 }
 
 function normalizeTestPolicyOverrides(
@@ -2306,7 +2314,9 @@ function normalizePlayRunStart(raw: Record<string, unknown>): PlayRunStart {
     ...(runPackage.run.dashboardUrl
       ? { dashboardUrl: runPackage.run.dashboardUrl }
       : {}),
-    ...(TERMINAL_PLAY_STATUSES.has(status) ? { finalStatus: runPackage } : {}),
+    ...(isTerminalPlayRunLifecycleStatus(status)
+      ? { finalStatus: runPackage }
+      : {}),
     package: runPackage,
   };
 }
@@ -2469,18 +2479,22 @@ function getPlayLiveEventPayload(
     : {};
 }
 
-function normalizeLiveStatus(value: unknown): PlayStatus['status'] | null {
+/** Run lifecycle events are the only events that can finish a watch. */
+function playLiveRunStatus(event: PlayLiveEvent): PlayStatus['status'] | null {
   if (
-    value === 'queued' ||
-    value === 'running' ||
-    value === 'waiting' ||
-    value === 'completed' ||
-    value === 'failed' ||
-    value === 'cancelled'
+    event.type !== 'play.run.snapshot' &&
+    event.type !== 'play.run.status' &&
+    event.type !== 'play.run.final_status'
   ) {
-    return value;
+    return null;
   }
-  return null;
+  const payload = getPlayLiveEventPayload(event);
+  return (
+    decodePlayRunPublicStatus(payload.status) ??
+    (isPlayRunPackage(payload)
+      ? decodePlayRunPublicStatus(payload.run.status)
+      : null)
+  );
 }
 
 function appendPlayLiveLogLines(
@@ -2545,12 +2559,7 @@ function updatePlayLiveStatusState(
       : isPlayRunPackage(payload)
         ? payload.run.id
         : state.runId;
-  const status =
-    normalizeLiveStatus(payload.status) ??
-    (isPlayRunPackage(payload)
-      ? normalizeLiveStatus(payload.run.status)
-      : null) ??
-    state.status;
+  const status = playLiveRunStatus(event) ?? state.status;
   const progressPayload = isRecord(payload.progress) ? payload.progress : {};
   // Snapshots no longer REPLACE accumulated logs (ADR-0009): the snapshot
   // only retains a bounded tail, so replacing would clobber the seq-keyed
@@ -4221,13 +4230,8 @@ export class DeeplineClient {
     runId: string,
     options?: RunsWatchOptions,
   ): Promise<PlayStatus> {
-    const state: PlayLiveStatusState = {
-      runId,
-      status: 'running',
-      logs: [],
-      lastLogSeq: 0,
-      latest: null,
-    };
+    // Forward events without retaining their log history. Only lifecycle
+    // evidence is needed here; the final package comes from the durable read.
     let terminalObserved = false;
     for await (const event of this.watchRunEvents(runId, {
       signal: options?.signal,
@@ -4235,19 +4239,20 @@ export class DeeplineClient {
       onRetry: options?.onRetry ?? options?.onReconnect,
     })) {
       options?.onEvent?.(event);
-      const status = updatePlayLiveStatusState(state, event);
-      if (status && TERMINAL_PLAY_STATUSES.has(status.status)) {
+      if (isTerminalPlayRunLifecycleStatus(playLiveRunStatus(event))) {
         terminalObserved = true;
       }
     }
     if (options?.signal?.aborted) {
       throw new DeeplineError('Run watch aborted.', undefined, 'ABORTED');
     }
-    if (terminalObserved) {
-      return await this.getRunStatus(runId);
-    }
     const refreshed = await this.getRunStatus(runId);
-    if (TERMINAL_PLAY_STATUSES.has(refreshed.status)) return refreshed;
+    if (
+      terminalObserved ||
+      isTerminalPlayRunLifecycleStatus(refreshed.status)
+    ) {
+      return refreshed;
+    }
     throw new DeeplineError(
       `Run watch for ${runId} ended before a terminal status.`,
       undefined,
@@ -4474,23 +4479,7 @@ export class DeeplineClient {
       `/api/v2/runs/${encodeURIComponent(runId)}${query}`,
       { headers: { 'x-deepline-run-status': '1' } },
     );
-    const responseRunStatus = isPlayRunPackage(response)
-      ? response.runStatus
-      : isPlayRunPackage(response.package)
-        ? response.package.runStatus
-        : response.runStatus;
-    const responseOverview = isPlayRunPackage(response)
-      ? response.overview
-      : isPlayRunPackage(response.package)
-        ? response.package.overview
-        : response.overview;
     const status = normalizePlayStatus(response);
-    if (isRecord(responseRunStatus)) {
-      status.runStatus = responseRunStatus as unknown as RunGetStatus;
-    }
-    if (isRecord(responseOverview)) {
-      status.overview = responseOverview as unknown as RunLifecycleStatus;
-    }
     if (options?.failedLogs !== true || status.status !== 'failed') {
       return status;
     }
@@ -5796,7 +5785,7 @@ export class DeeplineClient {
         options?.onProgress?.(status);
       }
 
-      if (TERMINAL_PLAY_STATUSES.has(status.status)) {
+      if (isTerminalPlayRunLifecycleStatus(status.status)) {
         terminalObserved = status;
       }
     }

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

@@ -38,6 +38,7 @@ import { readSdkSkillsLocalVersion } from './skills-version.js';
 import { deploymentProtectionHeaders } from './deployment-protection.js';
 import {
   ABSURD_RELEASE_OVERRIDE_HEADER,
+  RETAINED_PIPELINE_RECEIVERS_HEADER,
   COORDINATOR_INTERNAL_TOKEN_HEADER,
   COORDINATOR_URL_OVERRIDE_HEADER,
   PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER,
@@ -345,6 +346,15 @@ export class HttpClient {
     if (runtimeTestFault?.trim()) {
       headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
     }
+    const retainedReceivers =
+      typeof process !== 'undefined'
+        ? process.env?.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim()
+        : undefined;
+    if (retainedReceivers && coordinatorInternalToken?.trim()) {
+      headers[RETAINED_PIPELINE_RECEIVERS_HEADER] = retainedReceivers;
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] =
+        coordinatorInternalToken.trim();
+    }
     if (absurdReleaseOverride?.trim() && coordinatorInternalToken?.trim()) {
       headers[ABSURD_RELEASE_OVERRIDE_HEADER] = absurdReleaseOverride.trim();
     }

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.245',
+  version: '0.3.247',
   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/sdk/src/runs/read-errors.ts

@@ -0,0 +1,19 @@
+import { DeeplineError } from '../errors.js';
+
+export function isTransientPlayRunReadError(error: unknown): boolean {
+  if (
+    error instanceof DeeplineError &&
+    error.code === 'PLAY_STREAM_NETWORK_ABORTED'
+  ) {
+    return true;
+  }
+  if (error instanceof DeeplineError && typeof error.statusCode === 'number') {
+    // 5xx responses and network-level failures may recover. Client errors,
+    // especially 404, stay visible instead of disappearing into a retry loop.
+    return error.statusCode >= 500 && error.statusCode < 600;
+  }
+  const text = error instanceof Error ? error.message : String(error);
+  return /auth validation backend timed out|coordinator \/submit(?:\?[^ ]*)? 5\d\d|Worker threw exception|Internal Server Error|Service Unavailable|fetch failed|eaddrnotavail|econnreset|etimedout|eai_again|socket hang up/i.test(
+    text,
+  );
+}

package/dist/bundling-sources/sdk/src/runs/watch-polling.ts

@@ -7,7 +7,7 @@ import {
   type PlayRunStreamDiffState,
   type PlayRunStreamEvent,
 } from '../../../shared_libs/play-runtime/run-snapshot-stream.js';
-import { isTransientPlayRunReadError } from '../stream-reconnect.js';
+import { isTransientPlayRunReadError } from './read-errors.js';
 
 /** The watch endpoint is a small authenticated REST read, polled every two seconds. */
 export const RUN_WATCH_POLL_INTERVAL_MS = 2_000;

package/dist/bundling-sources/shared_libs/observability/scheduled-jobs.json

@@ -849,6 +849,24 @@
     "failureAlert": "convex_action_wrapper",
     "domainReportRequired": true
   },
+  {
+    "id": "convex.cleanup-expired-org-day-usage-shards",
+    "name": "Cleanup expired org-day usage shards",
+    "scheduler": "convex_cron",
+    "cadence": "47 5 * * *",
+    "timezone": "UTC",
+    "source": "packages/convex/crons.ts",
+    "locator": "cleanup expired org-day usage shards",
+    "owner": "billing",
+    "criticality": "maintenance",
+    "purpose": "Delete expired org-day usage shards independently of display rollup folding.",
+    "successDefinition": "Each expired shard page is deleted and full pages schedule a continuation.",
+    "failureDefinition": "Expired shards cannot be deleted or a required continuation is not scheduled.",
+    "startGraceMs": 120000,
+    "runTimeoutMs": 1800000,
+    "failureAlert": "convex_action_wrapper",
+    "domainReportRequired": true
+  },
   {
     "id": "convex.record-neon-managed-project-usage",
     "name": "Record Neon managed project usage",

package/dist/bundling-sources/shared_libs/observability/scheduled-work-manual.ts

@@ -9,6 +9,7 @@
  */
 export const MANUALLY_RUNNABLE_CONVEX_CRON_JOB_IDS = [
   'convex.fold-usage-rollups',
+  'convex.cleanup-expired-org-day-usage-shards',
   'convex.record-neon-managed-project-usage',
   'convex.cleanup-expired-mcp-oauth-codes',
   'convex.cleanup-expired-api-key-claims',

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -19063,11 +19063,14 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
                 ambiguousTransportReplayAllowed ||
                 fixtureReplaySafe)
             ) {
-              // A transport retry has no gateway-qualified provider outcome
-              // to inherit. In particular, never carry a prior rate-limit
-              // claim across an ambiguous delivery retry.
-              providerRateLimitRetryFromInvocationAttempt = null;
-              invocationAttempt += 1;
+              // Redeliver a fenced request to the same saved outcome. Its
+              // attempt and any prior provider-429 proof belong to the logical
+              // invocation; only a definite retryable HTTP outcome advances it.
+              // Ordinary transport retries retain their physical attempt count.
+              if (!usesDurableInvocationFence) {
+                providerRateLimitRetryFromInvocationAttempt = null;
+                invocationAttempt += 1;
+              }
               await this.governor.chargeBudget('retry');
               const retryAfterMs =
                 TOOL_RETRY_AFTER_FALLBACK_MS * transportAttempt;

package/dist/bundling-sources/shared_libs/play-runtime/coordinator-headers.ts

@@ -22,6 +22,16 @@ export const RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER =
  */
 export const RUNTIME_ENVIRONMENT_TOKEN_HEADER =
   'x-deepline-runtime-environment-token';
+/** Authenticated target-owner assertion, issued only after deployment reproof. */
+export const RETAINED_PIPELINE_RECEIVERS_HEADER =
+  'x-deepline-retained-pipeline-receivers';
+export type RetainedPipelineReceivers = {
+  namespace: string;
+  schedulerSchema?: string;
+  backend: string;
+  callbackOrigin: string;
+  runtimeApiOrigin: string;
+};
 /**
  * Internal top-level `profile=absurd` launches, including deploy canaries, use
  * this header to pin an exact candidate release before activation. Public API

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/run-ledger-outbox-recovery.ts

@@ -41,7 +41,7 @@ const MAX_TIMEOUT_MS = 2_147_483_647;
  * therefore a network/projection concurrency budget, deliberately independent
  * of the projector's much smaller Postgres pool.
  *
- * A single successful probe starts a bounded wave; an idle projector still
+ * A single successful probe opens bounded delivery slots; an idle projector still
  * performs only one indexed head read per safety wake. `SKIP LOCKED` leases
  * distinct runs, retaining strict causal ordering within every run.
  */
@@ -130,6 +130,7 @@ export function startRunLedgerOutboxRecovery(
   let unsubscribeNotify: (() => void) | undefined;
   let unsubscribeState: (() => void) | undefined;
   let requestDrain: (reason: string) => void = () => undefined;
+  let wakeDrainer: (() => void) | null = null;
 
   const clearWakeTimer = () => {
     if (!timer) return;
@@ -162,7 +163,10 @@ export function startRunLedgerOutboxRecovery(
     requested = true;
     if (cooldownUntilMs !== null && now() < cooldownUntilMs) return;
     clearWakeTimer();
-    if (drainPromise) return;
+    if (drainPromise) {
+      wakeDrainer?.();
+      return;
+    }
     drainPromise = drain(reason)
       .catch((error) => {
         // drain() handles expected database/projection faults itself. This is a
@@ -179,7 +183,6 @@ export function startRunLedgerOutboxRecovery(
   };
 
   const recordProjectionRetry = (retrying: number) => {
-    failureCount += 1;
     logger.warn('[run-ledger-outbox.recovery_retry]', {
       stage: 'projection',
       retrying,
@@ -205,6 +208,7 @@ export function startRunLedgerOutboxRecovery(
       delayMs,
       error: error instanceof Error ? error.message : String(error),
     });
+    if (closed) return;
     clearWakeTimer();
     cooldownUntilMs = now() + delayMs;
     timer = setTimer(() => {
@@ -216,6 +220,7 @@ export function startRunLedgerOutboxRecovery(
   };
 
   const scheduleNextDue = async (): Promise<void> => {
+    if (closed) return;
     let dueAt: Date | null;
     try {
       dueAt = await deps.readNextDueAt();
@@ -246,7 +251,47 @@ export function startRunLedgerOutboxRecovery(
     timer.unref?.();
   };
 
+  type DeliveryOutcome = {
+    delivery: Promise<DeliveryOutcome>;
+  } & (
+    | { status: 'fulfilled'; value: PostgresSchedulerOutboxProjectionResult }
+    | { status: 'rejected' | 'skipped' }
+  );
+
   const drain = async (reason: string): Promise<void> => {
+    const volume = { attempted: 0, projected: 0, retrying: 0, blocked: 0 };
+    const reportVolume = () => {
+      if (volume.attempted === 0) return;
+      logger.info('[run-ledger-outbox.recovery_wave]', {
+        reason,
+        parallelism,
+        ...volume,
+      });
+      volume.attempted = 0;
+      volume.projected = 0;
+      volume.retrying = 0;
+      volume.blocked = 0;
+    };
+    const recordResult = (
+      result: PostgresSchedulerOutboxProjectionResult,
+      resetFailures = true,
+    ) => {
+      volume.attempted += result.attempted;
+      volume.projected += result.projected;
+      volume.retrying += result.retrying;
+      volume.blocked += result.failed;
+      if (result.retrying > 0) {
+        // Each retrying run owns its durable retry clock. Independent runs
+        // remain eligible; this is not a controller-wide delivery cooldown.
+        recordProjectionRetry(result.retrying);
+      } else if (resetFailures) {
+        failureCount = 0;
+      }
+      // Streaming delivery has no wave barrier at which to report progress.
+      // Keep logs bounded per committed volume, and flush at idle/shutdown.
+      if (volume.attempted >= parallelism) reportVolume();
+    };
+
     while (requested && !closed) {
       requested = false;
       // Probe first so an idle projector issues one small indexed read per
@@ -260,86 +305,81 @@ export function startRunLedgerOutboxRecovery(
         scheduleFailureRetry('dispatch', error);
         return;
       }
-      const settled = [
-        {
-          status: 'fulfilled' as const,
-          value: first,
-        },
-        ...(first.attempted === 0
-          ? []
-          : await Promise.allSettled(
-              Array.from({ length: parallelism - 1 }, () =>
-                deps.dispatchOnce(),
-              ),
-            )),
-      ];
-      const rejected = settled.find(
-        (result): result is PromiseRejectedResult =>
-          result.status === 'rejected',
-      );
-      if (rejected) {
-        scheduleFailureRetry('dispatch', rejected.reason);
-        return;
-      }
-
-      const results = settled.map(
-        (result) =>
-          (
-            result as PromiseFulfilledResult<PostgresSchedulerOutboxProjectionResult>
-          ).value,
-      );
-      const retrying = results.reduce(
-        (total, result) => total + result.retrying,
-        0,
-      );
-      const attempted = results.reduce(
-        (total, result) => total + result.attempted,
-        0,
-      );
-      const projected = results.reduce(
-        (total, result) => total + result.projected,
-        0,
-      );
-      const blocked = results.reduce(
-        (total, result) => total + result.failed,
-        0,
-      );
-
-      if (retrying > 0) {
-        // The failed row owns its own durable retry clock. Do NOT stop this
-        // drain: the claim query preserves causal order within a run, while
-        // independent runs are safe to project now. Returning here turns one
-        // transient projection failure into global head-of-line blocking when
-        // this is the only healthy projector replica.
-        recordProjectionRetry(retrying);
-      } else {
-        failureCount = 0;
+      recordResult(first);
+      if (first.attempted === 0) {
+        await scheduleNextDue();
+        continue;
       }
 
-      if (attempted > 0) {
-        // This is the durable queue's high-signal throughput event. It makes
-        // a delayed public Run observable as a projector/outbox problem,
-        // without emitting one noisy log line per normal database checkout.
-        logger.info('[run-ledger-outbox.recovery_wave]', {
-          reason,
-          parallelism,
-          attempted,
-          projected,
-          retrying,
-          blocked,
+      const active = new Set<Promise<DeliveryOutcome>>();
+      let dispatchFailed = false;
+      const startDelivery = () => {
+        const delivery: Promise<DeliveryOutcome> = Promise.resolve().then(
+          async (): Promise<DeliveryOutcome> => {
+            if (closed || dispatchFailed)
+              return { delivery, status: 'skipped' };
+            try {
+              return {
+                delivery,
+                status: 'fulfilled',
+                value: await deps.dispatchOnce(),
+              };
+            } catch (error) {
+              // Stop refills as soon as this rejection is observed, including
+              // when another already-completed slot wins Promise.race first.
+              if (!dispatchFailed) {
+                dispatchFailed = true;
+                scheduleFailureRetry('dispatch', error);
+              }
+              return { delivery, status: 'rejected' };
+            }
+          },
+        );
+        active.add(delivery);
+      };
+      const fillSlots = () => {
+        if (closed || dispatchFailed) return;
+        while (active.size < parallelism) {
+          startDelivery();
+        }
+      };
+      fillSlots();
+      while (active.size > 0) {
+        const wake = new Promise<null>((resolve) => {
+          wakeDrainer = () => resolve(null);
         });
+        const outcome = await Promise.race([...active, wake]);
+        wakeDrainer = null;
+        if (outcome !== null) {
+          active.delete(outcome.delivery);
+          if (outcome.status === 'fulfilled') {
+            recordResult(outcome.value, !dispatchFailed);
+            if (outcome.value.attempted > 0 && !closed && !dispatchFailed) {
+              // Refill this completed slot immediately. A slower independent
+              // run never owns another run's delivery capacity.
+              startDelivery();
+            }
+          }
+        }
+        if (
+          requested &&
+          !closed &&
+          !dispatchFailed &&
+          active.size < parallelism
+        ) {
+          // A new notification can use slots that previously found no work,
+          // even while another slot is still awaiting its gateway response.
+          // Keep the hint while all slots are occupied: an already-started
+          // empty claim does not establish idle after this notification.
+          requested = false;
+          fillSlots();
+        }
       }
-
-      // Continue until no event was claimable. A transient failure schedules
-      // its own durable retry, so the next pass naturally skips that run while
-      // moving unrelated runs forward. A permanent failure is settled once and
-      // likewise cannot block another run's causal prefix.
-      if (attempted > 0) {
-        requested = true;
-        continue;
-      }
+      reportVolume();
+      if (dispatchFailed || closed) return;
       await scheduleNextDue();
     }
+    reportVolume();
   };
 
   // Subscribe first, then scan. Notifications are lossy by design, so every
@@ -353,6 +393,7 @@ export function startRunLedgerOutboxRecovery(
     close: async () => {
       if (closed) return;
       closed = true;
+      wakeDrainer?.();
       clearWakeTimer();
       cooldownUntilMs = null;
       unsubscribeNotify?.();

package/dist/bundling-sources/shared_libs/play-runtime/transient-service-error.ts

@@ -20,12 +20,13 @@ export function transientServiceUnavailableDetail(
   ) {
     return detail;
   }
-  // Convex uses explicit ServiceUnavailable and ExpiredInQueue responses, as
+  // Convex uses explicit ServiceUnavailable, ExpiredInQueue and
+  // TooManyConcurrentRequests admission responses, as
   // well as this generic InternalServerError envelope for short control-plane
   // outages. The latter text is intentionally exact: application exceptions
   // must not become retryable merely because they mention an internal-server
   // error.
-  return /ServiceUnavailable|Service temporarily unavailable|temporarily unavailable \(Code:\s*\d+\)|"code"\s*:\s*"ExpiredInQueue"|"code"\s*:\s*"InternalServerError"[\s\S]*(?:Your request couldn't be completed\. Try again later\.|Your request timed out performing too many system operations\.)/i.test(
+  return /ServiceUnavailable|Service temporarily unavailable|temporarily unavailable \(Code:\s*\d+\)|"code"\s*:\s*"(?:ExpiredInQueue|TooManyConcurrentRequests)"|"code"\s*:\s*"InternalServerError"[\s\S]*(?:Your request couldn't be completed\. Try again later\.|Your request timed out performing too many system operations\.)/i.test(
     detail,
   )
     ? detail

package/dist/bundling-sources/shared_libs/plays/execution-pipeline.ts

@@ -4,9 +4,11 @@ import { staticPipelineStorageCodec } from './static-pipeline-storage-codec';
 
 export {
   retainedPlayPipelineFields,
+  WRITE_RETAINED_PIPELINE_GRAPHS,
   type RetainedPlayContract,
   type RetainedPipelineCarrier,
   encodeRetainedPlayPipelines,
+  createRetainedPlayPipelinesForTransport,
   hydrateRetainedPlayPipelines,
   prepareRetainedPlayPipelinesForTransport,
   type RetainedPipelineGraph,

package/dist/bundling-sources/shared_libs/plays/retained-pipeline-graph.ts

@@ -6,7 +6,7 @@
  * This is an additive named representation. Readers must be deployed before
  * WRITE_RETAINED_PIPELINE_GRAPHS is enabled in a separate release.
  */
-export const WRITE_RETAINED_PIPELINE_GRAPHS = false;
+export const WRITE_RETAINED_PIPELINE_GRAPHS = true;
 
 type Scalar = null | boolean | number | string;
 type GraphValue = Scalar | { ref: number };
@@ -255,12 +255,18 @@ function hydrateContractRoots(
   return result;
 }
 
-/** Production writers remain inert until the separate reader rollout completes. */
+/** Create a graph only when the owner has selected reader-capable receivers. */
+export function createRetainedPlayPipelinesForTransport<T>(input: T): T {
+  return WRITE_RETAINED_PIPELINE_GRAPHS
+    ? encodeRetainedPlayPipelines(input)
+    : prepareRetainedPlayPipelinesForTransport(input);
+}
+
+/** Forward an immutable launch in its original representation. */
 export function prepareRetainedPlayPipelinesForTransport<T>(input: T): T {
-  // Reader-only builds must preserve new representations when forwarding
-  // them. The rollout switch controls creation from legacy envelopes only.
-  return WRITE_RETAINED_PIPELINE_GRAPHS ||
-    (record(input) && input.retainedPipelineGraph !== undefined)
+  // A historical launch may still call an older pinned app after adoption.
+  // New workers and projectors must not upgrade that receiver's wire format.
+  return record(input) && input.retainedPipelineGraph !== undefined
     ? encodeRetainedPlayPipelines(input)
     : input;
 }

package/dist/bundling-sources/shared_libs/plays/static-pipeline-storage-codec.ts

@@ -10,7 +10,6 @@ import {
   retainedPlayPipelineFields,
   encodeRetainedPlayPipelines,
   hydrateRetainedPlayPipelines,
-  WRITE_RETAINED_PIPELINE_GRAPHS,
   type RetainedPipelineGraph,
   type RetainedPipelineCarrier,
 } from './retained-pipeline-graph';
@@ -29,7 +28,7 @@ function readExecutionPipeline(
   return readStoredStaticPipeline(record);
 }
 
-/** Runs use the shared graph after all storage readers have been deployed. */
+/** Preserve the representation selected by the immutable launch owner. */
 function executionStorageFields(
   pipeline: PlayStaticPipeline | null | undefined,
   carrier?: RetainedPipelineCarrier,
@@ -38,11 +37,7 @@ function executionStorageFields(
   staticPipelineV2?: ReturnType<typeof createStoredStaticPipelineV2>;
   retainedPipelineGraph?: RetainedPipelineGraph;
 } {
-  if (
-    (!WRITE_RETAINED_PIPELINE_GRAPHS &&
-      carrier?.retainedPipelineGraph === undefined) ||
-    pipeline === undefined
-  ) {
+  if (carrier?.retainedPipelineGraph === undefined || pipeline === undefined) {
     return createStaticPipelineStorageFields(pipeline);
   }
   const compact = encodeRetainedPlayPipelines(