deepline 0.3.408 → 0.3.410

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -481,6 +481,8 @@ export interface BatchRequest {
 }
 
 export interface MapStartResult {
+  /** Opt-in authoritative completed cells, separate from merged input rows. */
+  previousCells?: import('./dataset-row-input').DatasetPreviousCells[];
   /** Rows that need processing for this run. Previous values may be included for context. */
   pendingRows: Record<string, unknown>[];
   /** Rows already terminal for this run and safe to count as completed. */
@@ -825,6 +827,8 @@ export interface ContextOptions {
   authoringContractEdition?: PlayAuthoringContractEdition;
   /** Direct/local callers may opt into the new terminal Slack HITL outcome. */
   slackHitlTimeoutOutcome?: 'park' | 'error';
+  /** Artifact-pinned dataset input policy; missing retains legacy hydration. */
+  datasetRowInput?: 'current_run';
   /** Error shape pinned by the immutable play artifact; missing preserves legacy schema 0. */
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   /** Execute-result contract pinned by the immutable Play artifact. */
@@ -967,6 +971,8 @@ export interface ContextOptions {
       executorToken?: string;
       staticPipeline?: PlayStaticPipeline | null;
       forceRefresh?: boolean;
+      includePreviousCells?: boolean;
+      previousCellsBudgetBytes?: number;
       inputOffset?: number;
       mode?: RuntimeDatasetRunOptions['mode'];
       columnTypes?: PlayDatasetColumnTypes;

package/dist/bundling-sources/shared_libs/play-runtime/dataset-row-input.ts

@@ -0,0 +1,124 @@
+import { copyPlayDatasetSourceRowIdentity } from '../plays/dataset';
+import type { PreviousCell } from '../plays/cell-staleness';
+import { cloneCsvAliasedRow } from './csv-rename';
+import {
+  runtimeJsonByteLength,
+  type RuntimeMemoryLedger,
+  type RuntimeMemoryLedgerHandle,
+} from './memory-ledger';
+
+export type DatasetPreviousCells = {
+  key: string;
+  cells: Record<string, PreviousCell>;
+};
+
+// Match the ordinary runtime API decoded-response limit, including both the
+// legacy projection and opted-in history. Never truncate a historical cell.
+const MAX_ADMISSION_BYTES = 16 * 1024 * 1024;
+
+export function assertDatasetAdmissionHistory(
+  result: { previousCells?: DatasetPreviousCells[] },
+  budgetBytes = MAX_ADMISSION_BYTES,
+): Map<string, Record<string, PreviousCell>> {
+  if (!Array.isArray(result.previousCells)) {
+    throw new Error(
+      'Dataset admission did not return requested previous cells. Deploy dataset row input readers before activating new artifacts.',
+    );
+  }
+  const limit = Math.min(MAX_ADMISSION_BYTES, budgetBytes);
+  if (!Number.isFinite(limit) || limit < 1) {
+    throw new Error(
+      'Dataset admission history requires a positive byte budget.',
+    );
+  }
+  if (runtimeJsonByteLength(result) > limit) {
+    throw new Error(
+      `Dataset admission with previous cells exceeds the ${limit} byte budget.`,
+    );
+  }
+  return new Map(result.previousCells.map(({ key, cells }) => [key, cells]));
+}
+
+export function persistedFieldsAbsentFromInputRow(
+  inputRow: Record<string, unknown>,
+  persisted: Record<string, unknown>,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(persisted).filter(
+      ([key]) => !Object.prototype.hasOwnProperty.call(inputRow, key),
+    ),
+  );
+}
+
+type RowHistory = {
+  cells: Record<string, PreviousCell>;
+  bytes: number;
+  memory?: RuntimeMemoryLedgerHandle;
+};
+
+/** Private execution context, copied at the runtime's row-cloning seam. */
+export class DatasetRowInputView {
+  private readonly history = new WeakMap<object, RowHistory>();
+
+  seed(
+    input: Record<string, unknown>,
+    persisted: Record<string, unknown> | undefined,
+    policy: 'legacy' | 'current_run',
+    cells: Record<string, PreviousCell> = {},
+  ): Record<string, unknown> {
+    const extra = persistedFieldsAbsentFromInputRow(input, persisted ?? {});
+    if (policy === 'legacy' && !persisted) return input;
+    const row = cloneCsvAliasedRow(
+      input,
+      policy === 'legacy'
+        ? extra
+        : Object.fromEntries(
+            Object.entries(extra).filter(([key]) =>
+              key.startsWith('__deepline'),
+            ),
+          ),
+    );
+    if (policy === 'current_run') {
+      copyPlayDatasetSourceRowIdentity(input, row);
+      this.history.set(row, { cells, bytes: runtimeJsonByteLength(cells) });
+    }
+    return row;
+  }
+
+  copy<T extends object>(source: object, target: T): T {
+    const history = this.history.get(source);
+    if (history) this.history.set(target, history);
+    return target;
+  }
+
+  previous(row: object, field: string): PreviousCell | undefined {
+    const cells = this.history.get(row)?.cells;
+    return cells && Object.prototype.hasOwnProperty.call(cells, field)
+      ? cells[field]
+      : undefined;
+  }
+
+  memoryValue(row: Record<string, unknown>): unknown {
+    const history = this.history.get(row);
+    return history ? { row, previousCells: history.cells } : row;
+  }
+
+  retain(row: object, ledger: RuntimeMemoryLedger): void {
+    const history = this.history.get(row);
+    if (history && !history.memory && history.bytes > 0) {
+      history.memory = ledger.register({
+        category: 'hydrationReadBack',
+        bytes: history.bytes,
+      });
+    }
+  }
+
+  release(row: object): void {
+    const history = this.history.get(row);
+    if (!history) return;
+    history.memory?.release();
+    history.memory = undefined;
+    history.cells = {};
+    history.bytes = 0;
+  }
+}

package/dist/bundling-sources/shared_libs/play-runtime/durable-call-cache.ts

@@ -1,3 +1,9 @@
+import { buildDurableToolReceiptPrefix } from './durable-tool-identity';
+export {
+  buildDurableToolCallAuthScopeDigest,
+  buildDurableToolReceiptPrefix,
+  buildDurableToolPayloadProviderIdempotencyKey,
+} from './durable-tool-identity';
 import {
   normalizeTableNamespace,
   sha256Hex,
@@ -200,32 +206,6 @@ export function buildDurableRunPlayInvocationScope(input: {
   );
 }
 
-export function buildDurableToolCallAuthScopeDigest(input: {
-  orgId?: string | null;
-  toolId: string;
-  executionAuthScopeDigest?: string | null;
-}): string {
-  return sha256Hex(
-    stableStringify({
-      orgId: input.orgId?.trim() || 'org',
-      toolId: input.toolId.trim(),
-      executionAuthScopeDigest: input.executionAuthScopeDigest?.trim() || null,
-    }),
-  );
-}
-
-export function buildDurableToolReceiptPrefix(input: {
-  orgId?: string | null;
-  toolId: string;
-}): string {
-  const orgId = input.orgId?.trim() || 'org';
-  const toolId = input.toolId.trim();
-  if (!toolId) {
-    throw new Error('Durable tool receipt prefix requires a non-empty toolId.');
-  }
-  return `ctx:${orgId}:call:tool:${normalizeTableNamespace(toolId)}:`;
-}
-
 /** Partition a completed-result receipt without changing its accepted wire
  * shape. The semantic key still includes payload/auth/action/presentation. */
 export function scopeToolReceiptToInvocation(input: {
@@ -302,39 +282,3 @@ function commonDurableToolReceiptPrefix(
   }
   return commonPrefix ?? '';
 }
-
-/**
- * Provider-native batch caching is keyed by the exact compiled provider
- * payload. Result-cache identities coordinate local publication; they never
- * stand in for a provider operation identity.
- *
- * An explicit force refresh is deliberately a separate namespace: it asks for
- * a fresh provider operation even when the payload itself is unchanged.
- */
-export function buildDurableToolPayloadProviderIdempotencyKey(input: {
-  orgId?: string | null;
-  toolId: string;
-  executionAuthScopeDigest?: string | null;
-  providerActionVersion?: string | null;
-  payload: Record<string, unknown>;
-  forceRefreshIdentities?: readonly string[];
-}): string {
-  const toolId = input.toolId.trim();
-  if (!toolId) {
-    throw new Error(
-      'Provider payload idempotency key needs a non-empty toolId.',
-    );
-  }
-  const forceRefreshIdentities = input.forceRefreshIdentities
-    ?.map((identity) => identity.trim())
-    .filter(Boolean);
-  const orgId = input.orgId?.trim() || 'org';
-  return `ctx:${orgId}:operation:tool:${normalizeTableNamespace(toolId)}:payload-v1:${sha256Hex(
-    stableStringify({
-      executionAuthScopeDigest: input.executionAuthScopeDigest?.trim() || null,
-      providerActionVersion: input.providerActionVersion?.trim() || null,
-      payload: input.payload,
-      ...(forceRefreshIdentities?.length ? { forceRefreshIdentities } : {}),
-    }),
-  )}`;
-}

package/dist/bundling-sources/shared_libs/play-runtime/durable-receipt-execution.ts

@@ -4,6 +4,7 @@ import {
   isToolExecuteResult,
   serializeToolExecuteResult,
 } from './tool-result';
+export { executeWithFreshnessReceipt } from './freshness-receipt-execution';
 import { assertNoSecretTaint } from './secret-capability';
 import type { RuntimeStepReceipt } from './ctx-types';
 import {

package/dist/bundling-sources/shared_libs/play-runtime/durable-tool-identity.ts

@@ -0,0 +1,67 @@
+import {
+  normalizeTableNamespace,
+  sha256Hex,
+  stableStringify,
+} from '../plays/row-identity';
+
+export function buildDurableToolCallAuthScopeDigest(input: {
+  orgId?: string | null;
+  toolId: string;
+  executionAuthScopeDigest?: string | null;
+}): string {
+  return sha256Hex(
+    stableStringify({
+      orgId: input.orgId?.trim() || 'org',
+      toolId: input.toolId.trim(),
+      executionAuthScopeDigest: input.executionAuthScopeDigest?.trim() || null,
+    }),
+  );
+}
+
+export function buildDurableToolReceiptPrefix(input: {
+  orgId?: string | null;
+  toolId: string;
+}): string {
+  const orgId = input.orgId?.trim() || 'org';
+  const toolId = input.toolId.trim();
+  if (!toolId) {
+    throw new Error('Durable tool receipt prefix requires a non-empty toolId.');
+  }
+  return `ctx:${orgId}:call:tool:${normalizeTableNamespace(toolId)}:`;
+}
+
+/**
+ * Provider-native batch caching is keyed by the exact compiled provider
+ * payload. Result-cache identities coordinate local publication; they never
+ * stand in for a provider operation identity.
+ *
+ * An explicit force refresh is deliberately a separate namespace: it asks for
+ * a fresh provider operation even when the payload itself is unchanged.
+ */
+export function buildDurableToolPayloadProviderIdempotencyKey(input: {
+  orgId?: string | null;
+  toolId: string;
+  executionAuthScopeDigest?: string | null;
+  providerActionVersion?: string | null;
+  payload: Record<string, unknown>;
+  forceRefreshIdentities?: readonly string[];
+}): string {
+  const toolId = input.toolId.trim();
+  if (!toolId) {
+    throw new Error(
+      'Provider payload idempotency key needs a non-empty toolId.',
+    );
+  }
+  const forceRefreshIdentities = input.forceRefreshIdentities
+    ?.map((identity) => identity.trim())
+    .filter(Boolean);
+  const orgId = input.orgId?.trim() || 'org';
+  return `ctx:${orgId}:operation:tool:${normalizeTableNamespace(toolId)}:payload-v1:${sha256Hex(
+    stableStringify({
+      executionAuthScopeDigest: input.executionAuthScopeDigest?.trim() || null,
+      providerActionVersion: input.providerActionVersion?.trim() || null,
+      payload: input.payload,
+      ...(forceRefreshIdentities?.length ? { forceRefreshIdentities } : {}),
+    }),
+  )}`;
+}

package/dist/bundling-sources/shared_libs/play-runtime/execute-server-timing.ts

@@ -10,21 +10,44 @@ export const EXECUTE_SERVER_TIMING_STAGES = [
   'auth',
   'rate_limit',
   'catalog',
+  // Local preparation accumulates compilation/hooks/pricing inside catalog
+  // and executor loading before the final provider permit. Do not add it to
+  // catalog or total. Credential selection excludes charge admission.
+  'credential_plan',
+  'provider_prepare',
   'charge_open',
   // Charge admission substages. `charge_open` keeps its original meaning — the
   // TOTAL of all charge-admission work — so an existing reader is unchanged and
-  // these four explain work inside it. RPC stages include their retry waits,
-  // so `charge_retry_wait` overlaps them; do not sum all four as disjoint time.
+  // these four explain work inside it. The authorization action adapter splits
+  // its wall into snapshot, remaining action time and application retry gaps.
   // Absent stages are unobserved, not confident zero durations.
   // - `charge_eligibility`    canonical wallet and cap authorization snapshot
   // - `charge_cap_preflight`  legacy standalone cap work (zero in current path)
-  // - `charge_open_mutation`  the `openCharge` mutation, its retries included
+  // - `charge_open_mutation`  remaining action wall, including transport and
+  //                           failed attempts; legacy name, not mutation CPU
   // - `charge_retry_wait`     elapsed gaps before application RPC retries;
   //                           native Convex logs attribute internal OCC retries
   'charge_eligibility',
   'charge_cap_preflight',
   'charge_open_mutation',
   'charge_retry_wait',
+  // Billing completion slices explain the full stage, including transport.
+  // Handoff headers/body are nested within billing_handoff, not additive.
+  'billing_settle',
+  'billing_price',
+  'billing_precision',
+  'billing_caps',
+  'billing_catalog',
+  'billing_witness',
+  'billing_handoff',
+  'billing_handoff_rpc',
+  'billing_handoff_headers',
+  'billing_handoff_after_headers',
+  // Process-wide activity over the RPC interval, including concurrent work.
+  // These overlap the wall clocks above; they are not request-attributed CPU.
+  'billing_handoff_process_cpu',
+  'billing_handoff_event_loop_active',
+  'billing_handoff_event_loop_idle',
   'fixture_load',
   'execute',
   'identity',
@@ -78,11 +101,44 @@ export const EXECUTE_SERVER_TIMING_STAGES = [
   'upstream_body',
 ] as const;
 
+// The public recovery handler surrounds the core: its total includes durable
+// response storage and receipt acknowledgement. Keep the core's total intact.
+export const PUBLIC_EXECUTE_SERVER_TIMING_STAGES = [
+  // Route total includes lazy execution-module loading. The handler's
+  // public_total keeps its existing meaning so older readers remain valid.
+  'public_load',
+  'public_route',
+  // Core and recovery initialization overlap authentication. Their wall is
+  // included in public_total; these stages are not additive.
+  'public_core_load',
+  'public_recovery_load',
+  'public_auth',
+  'public_claim',
+  'public_claim_headers',
+  'public_claim_after_headers',
+  'public_core',
+  'public_prepare',
+  'public_r2',
+  'public_complete',
+  'public_complete_headers',
+  'public_complete_after_headers',
+  'public_total',
+] as const;
+
+export type PublicExecuteServerTimingStage =
+  (typeof PUBLIC_EXECUTE_SERVER_TIMING_STAGES)[number];
+
+const ALL_EXECUTE_SERVER_TIMING_STAGES = /* @__PURE__ */ (() =>
+  [
+    ...EXECUTE_SERVER_TIMING_STAGES,
+    ...PUBLIC_EXECUTE_SERVER_TIMING_STAGES,
+  ] as const)();
+
 export type ExecuteServerTimingStage =
   (typeof EXECUTE_SERVER_TIMING_STAGES)[number];
 
 export type ExecuteServerTiming = Record<
-  ExecuteServerTimingStage,
+  ExecuteServerTimingStage | PublicExecuteServerTimingStage,
   number | null
 >;
 
@@ -118,12 +174,14 @@ export function parseExecuteServerTiming(
     }
   }
   const timing = Object.fromEntries(
-    EXECUTE_SERVER_TIMING_STAGES.map((stage) => [
+    ALL_EXECUTE_SERVER_TIMING_STAGES.map((stage) => [
       stage,
       durations.get(stage) ?? null,
     ]),
   ) as ExecuteServerTiming;
-  return EXECUTE_SERVER_TIMING_STAGES.some((stage) => timing[stage] !== null)
+  return ALL_EXECUTE_SERVER_TIMING_STAGES.some(
+    (stage) => timing[stage] !== null,
+  )
     ? timing
     : null;
 }

package/dist/bundling-sources/shared_libs/play-runtime/freshness-receipt-execution.ts

@@ -17,11 +17,7 @@ import {
 type CompletedCall = {
   completedAt: number;
   value?: unknown;
-  /**
-   * Large tool results already live in their canonical result receipt. Keep a
-   * receipt-key indirection here instead of copying the full result into each
-   * operation and reusable freshness receipt.
-   */
+  /** Reuse a result already stored by its canonical receipt without copying it. */
   valueReceiptKey?: string;
   undefinedValue?: true;
 };

package/dist/bundling-sources/shared_libs/play-runtime/ledger-safe-payload.ts

@@ -15,7 +15,7 @@ export const MAX_LEDGER_RESULT_PAYLOAD_BYTES = LEDGER_TERMINAL_RESULT_MAX_BYTES;
 export const MAX_LEDGER_LOG_LINES_PER_EVENT = 500;
 export const MAX_LEDGER_LOG_LINE_LENGTH = 2_000;
 
-const ledgerIngressRedactor = createSecretRedactionContext();
+const ledgerIngressRedactor = /* @__PURE__ */ createSecretRedactionContext();
 
 export function redactLedgerString(value: unknown): string | null {
   if (typeof value !== 'string' || !value.trim()) return null;

package/dist/bundling-sources/shared_libs/play-runtime/play-artifact-runtime-contract.ts

@@ -24,6 +24,7 @@ import {
  */
 export type PlayArtifactRuntimeContract = Readonly<{
   semantics: PlayRuntimeSemantics;
+  datasetRowInput: 'legacy' | 'current_run';
   /** Additive artifact fact; missing persisted fields resolve to `park`. */
   slackHitlTimeoutOutcome: 'park' | 'error';
   toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
@@ -33,6 +34,7 @@ export type PlayArtifactRuntimeContract = Readonly<{
 
 export type PlayArtifactRuntimeContractInput = {
   authoringContractEdition?: PlayAuthoringContractEdition | null;
+  datasetRowInput?: 'current_run';
   slackHitlTimeoutOutcome?: 'park' | 'error' | null;
   toolResponseContract?: ToolResponseContract | null;
   toolResponseReceiptRevision?: string | null;
@@ -50,6 +52,7 @@ export function resolvePlayArtifactRuntimeContract(
   const toolResponseReceiptRevision =
     input.toolResponseReceiptRevision ?? undefined;
   return Object.freeze({
+    datasetRowInput: input.datasetRowInput ?? 'legacy',
     semantics: resolvePlayRuntimeSemantics(
       input.authoringContractEdition ?? PLAY_AUTHORING_CONTRACT_EDITION,
     ),

package/dist/bundling-sources/shared_libs/play-runtime/play-http-request.ts

@@ -1,6 +1,7 @@
 import type { SafeFetchImplementation } from '../security/safe-fetch';
 import type { RuntimeResourceGovernor } from './resource-governor';
 import { CTX_FETCH_EGRESS_TOOL_ID } from './builtin-pacing';
+import { CtxFetchAmbiguousWriteError } from '../plays/ambiguous-write-error';
 import {
   positiveTimeoutMs,
   RUNTIME_RELIABILITY_POLICY,
@@ -216,6 +217,7 @@ export async function sendPlayHttpRequest(input: {
   timeouts?: { headersMs?: number; bodyMs?: number; totalMs?: number };
   fetchImpl?: SafeFetchImplementation;
   log: (message: string) => void;
+  reportAmbiguousWrite?: boolean;
 }): Promise<{ response: Response; bodyText: string }> {
   const { url, init } = input;
   const method = String(init.method ?? 'GET').toUpperCase();
@@ -244,6 +246,7 @@ export async function sendPlayHttpRequest(input: {
   const { safePublicFetch } = await loadSafeFetch();
   let transportAttempt = 1;
   let rateLimitAttempt = 0;
+  let writeDispatched = false;
   while (true) {
     const attemptController = new AbortController();
     let permit: Awaited<
@@ -309,6 +312,8 @@ export async function sendPlayHttpRequest(input: {
                 phase: 'headers',
                 run: () => {
                   dispatched = true;
+                  if (!['GET', 'HEAD', 'OPTIONS'].includes(method))
+                    writeDispatched = true;
                   return (input.fetchImpl ?? globalThis.fetch)(
                     physicalUrl,
                     physicalInit,
@@ -333,6 +338,11 @@ export async function sendPlayHttpRequest(input: {
       void response?.body?.cancel(error).catch(() => undefined);
       response = null;
       bodyText = null;
+      if (input.reportAmbiguousWrite && writeDispatched) {
+        throw new CtxFetchAmbiguousWriteError(method, new URL(url).origin, {
+          cause: error,
+        });
+      }
       if (error instanceof CtxFetchTimeoutError) throw error;
       if (init.signal?.aborted) {
         throw init.signal.reason ?? error;

package/dist/bundling-sources/shared_libs/play-runtime/query-result-dataset.ts

@@ -120,6 +120,9 @@ export function isQueryResultDatasetReadRequest(
   input: Record<string, unknown>,
 ): boolean {
   if (!isQueryResultDatasetTool(toolId)) return false;
+  // Absence keeps the historical live dataset behavior.
+  if (isCustomerDbDatasetTool(toolId) && input.result_mode === 'rows')
+    return false;
   if (
     (isSnowflakeQueryDatasetTool(toolId) ||
       isDatabricksQueryDatasetTool(toolId)) &&

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/egress-probe.ts

@@ -163,11 +163,14 @@ export const EGRESS_PROBE_BUDGET_MS = 3_000;
 const EGRESS_PROBE_REQUESTS_PER_TARGET = 6;
 
 export async function collectStartupEgressProbeLines(input: {
+  /** Network benchmarks are opt-in and must not delay ordinary Plays. */
+  enabled?: boolean;
   receiptGatewayBaseUrl: string | null;
   executionRelayBaseUrl: string | null;
   /** Bearer credential for the gateway's authenticated bandwidth sink. */
   executorToken?: string | null;
 }): Promise<string[]> {
+  if (input.enabled !== true) return [];
   const gateway = input.receiptGatewayBaseUrl?.trim().replace(/\/$/, '') || '';
   const relay = input.executionRelayBaseUrl?.trim().replace(/\/$/, '') || '';
   const targets: Array<{ target: EgressProbeTarget; baseUrl: string }> = [];

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

@@ -2378,6 +2378,7 @@ async function run(
   const artifactRuntimeContract = resolvePlayArtifactRuntimeContract({
     authoringContractEdition: artifactCompatibility.authoringContractEdition,
     slackHitlTimeoutOutcome: artifactCompatibility.slackHitlTimeoutOutcome,
+    datasetRowInput: artifactCompatibility.datasetRowInput,
     toolResponseContract: config.context.toolResponseContract,
     toolResponseReceiptRevision: config.context.toolResponseReceiptRevision,
   });
@@ -2819,6 +2820,8 @@ async function run(
               rows: items,
               stableWriteIntent: true,
               pendingRerunAdmission: true,
+              includePreviousCells: mapContext.includePreviousCells,
+              previousCellsBudgetBytes: mapContext.previousCellsBudgetBytes,
               inputOffset: mapContext.inputOffset,
               mode: mapContext.mode,
               runId,
@@ -3382,8 +3385,9 @@ async function run(
     options,
   );
   for (const line of await collectStartupEgressProbeLines({
+    enabled: process.env.DEEPLINE_RUNTIME_RECEIPT_TRACE === '1',
     // A local/direct executor can use baseUrl without a receipt gateway.
-    // Probe only the explicit data-plane hop.
+    // Probe only the explicit data-plane hop in explicit diagnostic mode.
     receiptGatewayBaseUrl: config.context.receiptGatewayBaseUrl ?? null,
     executionRelayBaseUrl: config.context.executionGatewayBaseUrl ?? null,
     executorToken: config.context.executorToken ?? null,
@@ -4236,23 +4240,26 @@ export async function waitForRunnerExecutionAcknowledgement(
   timeoutMs = RUNNER_EXECUTION_ACK_TIMEOUT_MS,
 ): Promise<void> {
   if (!heartbeat) return;
-  const deadline = Date.now() + Math.max(1, timeoutMs);
-  let retryDelayMs = 100;
-  while (Date.now() < deadline) {
-    heartbeat.requestHeartbeat();
-    const remainingMs = Math.max(1, deadline - Date.now());
-    const acknowledged = await Promise.race([
-      heartbeat.executionAcknowledged.then(() => true),
-      new Promise<false>((resolve) =>
-        setTimeout(resolve, Math.min(retryDelayMs, remainingMs), false),
-      ),
+  heartbeat.requestHeartbeat();
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      heartbeat.executionAcknowledged,
+      new Promise<never>((_resolve, reject) => {
+        timeout = setTimeout(
+          () =>
+            reject(
+              new Error(
+                `RUNTIME_SANDBOX_START_FAILED: scheduler did not acknowledge the detached runner park within ${Math.max(1, timeoutMs)}ms. Customer play code was not started.`,
+              ),
+            ),
+          Math.max(1, timeoutMs),
+        );
+      }),
     ]);
-    if (acknowledged) return;
-    retryDelayMs = Math.min(1_000, retryDelayMs * 2);
+  } finally {
+    if (timeout) clearTimeout(timeout);
   }
-  throw new Error(
-    `RUNTIME_SANDBOX_START_FAILED: scheduler did not acknowledge the detached runner park within ${Math.max(1, timeoutMs)}ms. Customer play code was not started.`,
-  );
 }
 
 /**
@@ -4384,6 +4391,8 @@ async function pushRunnerTerminalIfConfigured(
     executorToken: context.executorToken,
     runId: context.runId,
     result,
+    runtimeCompletedPath:
+      process.env.DEEPLINE_PLAY_RUNNER_RUNTIME_COMPLETED_PATH,
     ...options,
   });
 }
@@ -4433,6 +4442,7 @@ function startRunnerPushHeartbeatFromConfig(
     executorToken,
     runId: push.runId,
     leaseSeconds: push.leaseSeconds,
+    waitForSchedulerPark: true,
     onSelfTerminate: (stop) => {
       onSelfTerminate?.(stop);
       void terminateRunnerForHeartbeatStop(stop);