deepline 0.3.89 → 0.3.90

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/job.ts

@@ -0,0 +1,78 @@
+import {
+  resolvePlayRunTerminalAuthority,
+  type PlayRunTerminalInput,
+  type PlayRunTerminalJob,
+  type PlayRunTerminalOutcome,
+} from '../../play-runs/terminal/contracts';
+import type { PlayRunTerminalPorts } from '../../play-runs/terminal/ports';
+
+/**
+ * Play Run Terminal Job.
+ *
+ * The job owns the terminal transition law:
+ *
+ *   atomic direct transition → terminal outcome
+ *   otherwise durable compatibility receipt → wake
+ *
+ * Infrastructure only supplies the three capabilities. In particular, no
+ * caller can accidentally publish a wake before the compatibility receipt is
+ * durable, or publish after a stale fence rejected its write.
+ */
+export function createPlayRunTerminalJob(
+  ports: PlayRunTerminalPorts,
+): PlayRunTerminalJob {
+  return {
+    async accept(input: PlayRunTerminalInput): Promise<PlayRunTerminalOutcome> {
+      // The public compatibility facade historically accepted a manually
+      // constructed authority as well as the parsed ingress value. Normalize
+      // it again here so whitespace cannot turn an invalid lease into a direct
+      // terminal write when a caller bypasses the parser.
+      const authority = resolvePlayRunTerminalAuthority(input.authority ?? {});
+      const direct = authority
+        ? await ports.directCommitter.commit({
+            runId: input.runId,
+            attempt: input.attempt,
+            authority,
+            result: input.result,
+            queueName: input.queueName,
+            // An authority exists only for the one terminal contract this
+            // build recognizes, and that contract is what proves the durable
+            // compute-billing controller. An absent or unrecognized contract
+            // never reaches here: it resolves to null above and wakes instead.
+            allowCappedCompletion: true,
+          })
+        : 'wake_required';
+
+      if (direct === 'not_found') {
+        return { kind: 'not_found_or_fence_rejected' };
+      }
+      if (direct === 'completed') {
+        return { kind: 'direct_completed' };
+      }
+      if (direct === 'stale_cleaned') {
+        return { kind: 'stale_attempt_cleaned' };
+      }
+      if (direct === 'already_terminal') {
+        // Mixed-version recovery is first-write-wins. Re-emitting can retire a
+        // historical parked invocation whose prior transition predates atomic
+        // retirement-event recording.
+        await ports.wakePublisher.publish(input);
+        return { kind: 'already_terminal' };
+      }
+
+      const recorded = await ports.compatibilityRecorder.record({
+        runId: input.runId,
+        attempt: input.attempt,
+        result: input.result,
+      });
+      if (!recorded) {
+        return { kind: 'not_found_or_fence_rejected' };
+      }
+
+      // The event carries no terminal payload. A resumed attempt reads truth
+      // from its durable store rather than trusting a message body.
+      await ports.wakePublisher.publish(input);
+      return { kind: 'compatibility_wake_queued' };
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/ports.ts

@@ -0,0 +1,54 @@
+import type {
+  PlayRunTerminalAuthority,
+  PlayRunTerminalInput,
+} from '../../play-runs/terminal/contracts';
+
+/** The result of the atomic terminal-transition capability. */
+export type DirectTerminalCommitOutcome =
+  | 'completed'
+  | 'stale_cleaned'
+  | 'already_terminal'
+  | 'not_found'
+  | 'wake_required';
+
+/**
+ * Capability for the modern atomic terminal transition. An implementation
+ * commits run truth, cleanup/billing obligations, terminal log outbox, and
+ * retirement event as one transaction when it returns `completed`.
+ */
+export type DirectTerminalCommitter = {
+  commit(input: {
+    runId: string;
+    attempt: number;
+    authority: PlayRunTerminalAuthority;
+    result: unknown;
+    queueName: string;
+    allowCappedCompletion: boolean;
+  }): Promise<DirectTerminalCommitOutcome>;
+};
+
+/**
+ * Compatibility-only durable write. It persists a runner terminal before the
+ * wake is published; false means a stale/missing attempt won and no event may
+ * be emitted.
+ */
+export type CompatibilityTerminalRecorder = {
+  record(input: {
+    runId: string;
+    attempt: number;
+    result: unknown;
+  }): Promise<boolean>;
+};
+
+/** Publishes the wake only after terminal truth has become durable. */
+export type RunnerTerminalWakePublisher = {
+  publish(
+    input: Pick<PlayRunTerminalInput, 'queueName' | 'runId' | 'attempt'>,
+  ): Promise<void>;
+};
+
+export type PlayRunTerminalPorts = {
+  directCommitter: DirectTerminalCommitter;
+  compatibilityRecorder: CompatibilityTerminalRecorder;
+  wakePublisher: RunnerTerminalWakePublisher;
+};

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/terminal/postgres-adapter.ts

@@ -0,0 +1,71 @@
+import { ABSURD_WAKE_CHANNEL } from '@deepline/absurd/sdk';
+
+import { absurdRunnerTerminalEventName } from '../../scheduler-backends/absurd-shared';
+import {
+  directCompletePostgresSchedulerRunnerTerminal,
+  recordPostgresSchedulerRunnerTerminal,
+  type PostgresSchedulerQueryClient,
+} from '../../scheduler-backends/postgres';
+import type { PlayRunTerminalPorts } from '../../play-runs/terminal/ports';
+
+/**
+ * Postgres implementation of the Play Run Terminal capabilities.
+ *
+ * This adapter is intentionally the only place this module knows scheduler
+ * SQL, the Absurd event name, or PostgreSQL notification transport.
+ */
+export function createPostgresPlayRunTerminalPorts(input: {
+  client: PostgresSchedulerQueryClient;
+  schema?: string;
+}): PlayRunTerminalPorts {
+  const options = input.schema ? { schema: input.schema } : undefined;
+  return {
+    directCommitter: {
+      async commit(terminal) {
+        return await directCompletePostgresSchedulerRunnerTerminal(
+          input.client,
+          {
+            runId: terminal.runId,
+            attempt: terminal.attempt,
+            leaseToken: terminal.authority.leaseToken,
+            result: terminal.result,
+            terminalLogOutbox: 'ctx_log_tail',
+            allowCappedCompletion: terminal.allowCappedCompletion,
+            engineWake: {
+              queueName: terminal.queueName,
+              eventName: absurdRunnerTerminalEventName(
+                terminal.runId,
+                terminal.attempt,
+              ),
+              wakeChannel: ABSURD_WAKE_CHANNEL,
+            },
+          },
+          options,
+        );
+      },
+    },
+    compatibilityRecorder: {
+      async record(terminal) {
+        return await recordPostgresSchedulerRunnerTerminal(
+          input.client,
+          terminal,
+          options,
+        );
+      },
+    },
+    wakePublisher: {
+      async publish(terminal) {
+        await input.client.query(
+          `WITH emitted AS (
+             SELECT absurd.emit_event($1, $2, 'null'::jsonb)
+           )
+           SELECT pg_notify('${ABSURD_WAKE_CHANNEL}', $1) FROM emitted`,
+          [
+            terminal.queueName,
+            absurdRunnerTerminalEventName(terminal.runId, terminal.attempt),
+          ],
+        );
+      },
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/play-runtime-batching-registry.ts

@@ -1,8 +1,10 @@
+import { bouncebanBatchStrategies } from './/bounceban-batching';
 import type { AnyBatchOperationStrategy } from './batching-types';
 import { bettercontactBatchStrategies } from './bettercontact-batching';
 import { DEFAULT_PLAY_RUNTIME_BATCH_STRATEGIES } from './default-batch-strategies';
 import { fullenrichBatchStrategies } from './fullenrich-batching';
 import { opensosdataBatchStrategies } from './opensosdata-batching';
+import { zerobounceBatchStrategies } from './zerobounce-batching';
 import { testAsyncBatchStrategies } from './test-async-batching';
 
 export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
@@ -11,9 +13,11 @@ export const PLAY_RUNTIME_BATCH_OPERATION_REGISTRY: Record<
 > = {
   ...DEFAULT_PLAY_RUNTIME_BATCH_STRATEGIES,
   ...bettercontactBatchStrategies,
+  ...bouncebanBatchStrategies,
   ...fullenrichBatchStrategies,
   ...opensosdataBatchStrategies,
   ...testAsyncBatchStrategies,
+  ...zerobounceBatchStrategies,
 };
 
 export function getPlayRuntimeBatchStrategy(

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

@@ -152,6 +152,8 @@ export interface PlayRunnerContextConfig {
   workflowId?: string;
   playId?: string;
   runId?: string;
+  /** Original run for an explicit user-requested replay. */
+  replayedFromRunId?: string | null;
   /** Shared governance/billing root. Differs from runId for async children. */
   rootRunId?: string;
   runAttempt?: number | null;

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

@@ -1,13 +1,10 @@
 import type { WorkReceiptStatus } from './work-receipts';
+import { WORK_RECEIPT_STATUS_CODE } from './work-receipt-storage-contract';
 
-export const RECEIPT_STATUS_CODE = {
-  queued: 0,
-  pending: 0,
-  running: 1,
-  completed: 2,
-  failed: 3,
-  skipped: 4,
-} as const satisfies Record<WorkReceiptStatus, number>;
+export const RECEIPT_STATUS_CODE = WORK_RECEIPT_STATUS_CODE satisfies Record<
+  WorkReceiptStatus,
+  number
+>;
 
 export type ReceiptStatusCode =
   (typeof RECEIPT_STATUS_CODE)[keyof typeof RECEIPT_STATUS_CODE];

package/dist/bundling-sources/shared_libs/play-runtime/run-failure.ts

@@ -63,10 +63,10 @@ export const WORKSPACE_STORAGE_NOT_READY_CODE = 'WORKSPACE_STORAGE_NOT_READY';
 // postgres-URI passwords). The raw pg error goes in the Error `cause` for server
 // logs only, never into this message or the normalized public failure.
 export const WORKSPACE_STORAGE_NOT_READY_MESSAGE =
-  'Workspace storage for this organization is unavailable, so this operation could not start. ' +
+  'Deepline could not prepare your workspace storage in time, so this operation did not start. ' +
+  'Try again in a few moments. You do not need to run a database command. ' +
   'This blocked operation did not use Deepline credits. ' +
   'Earlier completed operations in the same run may already have used credits. ' +
-  'Re-run the command. If it fails again, ask an organization admin to run `deepline db repair` (POST /api/v2/ingestion/repair), then re-run. ' +
   'If this keeps happening, contact Deepline support with the run ID.';
 
 export class WorkspaceStorageNotReadyError extends Error {
@@ -177,9 +177,7 @@ export class ProviderExhaustedError extends Error {
  * `ToolExecutionError` shape. Treat those two representations as the same
  * typed exhaustion outcome; do not fall back based on a message substring.
  */
-export function isProviderExhaustedFailure(
-  error: unknown,
-): error is
+export function isProviderExhaustedFailure(error: unknown): error is
   | ProviderExhaustedError
   | (ToolExecutionError & {
       readonly origin: 'provider';

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

@@ -0,0 +1,168 @@
+import { sha256Hex, stableStringify } from '../plays/row-identity';
+function sanitizePlayNameForWorkflowSegment(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64);
+}
+
+export function buildPlayWorkflowFamilyKey(playName: string): string {
+  const normalized = playName
+    .split('/')
+    .map(sanitizePlayNameForWorkflowSegment)
+    .filter(Boolean)
+    .join('/');
+  return normalized || 'play';
+}
+
+export function buildPlayWorkflowRunSuffix(now: Date): string {
+  const pad = (value: number, size = 2) => String(value).padStart(size, '0');
+  return [
+    now.getUTCFullYear(),
+    pad(now.getUTCMonth() + 1),
+    pad(now.getUTCDate()),
+    't',
+    pad(now.getUTCHours()),
+    pad(now.getUTCMinutes()),
+    pad(now.getUTCSeconds()),
+    '-',
+    pad(now.getUTCMilliseconds(), 3),
+  ].join('');
+}
+
+const CANONICAL_PLAY_RUN_TIMESTAMP_RE =
+  /\/run\/(\d{4})(\d{2})(\d{2})t(\d{2})(\d{2})(\d{2})-(\d{3})(?:-|$)/;
+
+/** Read the UTC creation time embedded in a canonical root play-run id. */
+export function canonicalPlayRunStartedAtMs(runId: string): number | null {
+  const match = CANONICAL_PLAY_RUN_TIMESTAMP_RE.exec(runId);
+  if (!match) return null;
+  const [, year, month, day, hour, minute, second, millisecond] = match;
+  const value = Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second),
+    Number(millisecond),
+  );
+  if (!Number.isFinite(value)) return null;
+  const roundTrip = new Date(value);
+  return roundTrip.getUTCFullYear() === Number(year) &&
+    roundTrip.getUTCMonth() === Number(month) - 1 &&
+    roundTrip.getUTCDate() === Number(day) &&
+    roundTrip.getUTCHours() === Number(hour) &&
+    roundTrip.getUTCMinutes() === Number(minute) &&
+    roundTrip.getUTCSeconds() === Number(second) &&
+    roundTrip.getUTCMilliseconds() === Number(millisecond)
+    ? value
+    : null;
+}
+
+type BuildPlayWorkflowIdOptions = {
+  /**
+   * Add entropy for new run creation. Keep false for tests and explicit
+   * externally-owned ids that need deterministic reconstruction.
+   */
+  unique?: boolean;
+};
+
+function buildRunEntropySuffix(): string {
+  const randomUuid = globalThis.crypto?.randomUUID?.();
+  if (randomUuid) {
+    return randomUuid.replace(/-/g, '').slice(0, 8);
+  }
+  return Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+}
+
+export function buildPlayWorkflowId(
+  playName: string,
+  now?: Date,
+  options: BuildPlayWorkflowIdOptions = {},
+): string {
+  const familyKey = buildPlayWorkflowFamilyKey(playName);
+  const timestamp = now ?? new Date();
+  const unique = options.unique ?? now === undefined;
+  const entropy = unique ? `-${buildRunEntropySuffix()}` : '';
+  return `play/${familyKey}/run/${buildPlayWorkflowRunSuffix(timestamp)}${entropy}`;
+}
+
+export type PlayRunIdentity = {
+  workflowId: string;
+  runId: string;
+  workflowFamilyKey: string;
+};
+
+/**
+ * Convex and runtime schedulers share one run identity contract.
+ *
+ * - `workflowId` is the unique execution id.
+ * - `runId` is the same execution id surfaced in dashboard/API state.
+ * - `workflowFamilyKey` is the stable play-name-derived family/group key.
+ *
+ * Keeping these three values explicit removes the old ambiguity where one field
+ * pretended to mean both "this specific run" and "this play family".
+ */
+export function buildPlayRunIdentity(
+  playName: string,
+  now?: Date,
+  options: BuildPlayWorkflowIdOptions = {},
+): PlayRunIdentity {
+  const workflowId = buildPlayWorkflowId(playName, now, {
+    unique: options.unique ?? now === undefined,
+  });
+  return {
+    workflowId,
+    runId: workflowId,
+    workflowFamilyKey: buildPlayWorkflowFamilyKey(playName),
+  };
+}
+
+/**
+ * Build the replay-stable identity for one ctx.runPlayAsync invocation.
+ *
+ * The parent's embedded timestamp keeps ordinary run ordering useful while
+ * the digest makes retries converge on exactly one independently scheduled
+ * child. Input is deliberately excluded: a changed request must conflict with
+ * the first immutable launch rather than silently minting another Run.
+ */
+export function buildAsyncPlayRunIdentity(input: {
+  playName: string;
+  parentRunId: string;
+  invocationKey: string;
+}): PlayRunIdentity {
+  const digest = sha256Hex(
+    `${input.parentRunId}\0${input.invocationKey}`,
+  ).slice(0, 20);
+  const parentStartedAt = canonicalPlayRunStartedAtMs(input.parentRunId) ?? 0;
+  // The run id is the durable identity of the authored invocation, so it must
+  // be reconstructible before resolving a mutable live Play reference. The
+  // workflow family remains the resolved child Play for grouping and display.
+  const base = buildPlayWorkflowId('async-child', new Date(parentStartedAt), {
+    unique: false,
+  });
+  const workflowId = `${base}-async-${digest}`;
+  return {
+    workflowId,
+    runId: workflowId,
+    workflowFamilyKey: buildPlayWorkflowFamilyKey(input.playName),
+  };
+}
+
+/** Immutable authored request identity, separate from the resolved revision. */
+export function buildAsyncPlayRequestFingerprint(input: {
+  key: string;
+  playRef: string;
+  childInput: Record<string, unknown>;
+}): string {
+  return sha256Hex(
+    stableStringify({
+      key: input.key,
+      playRef: input.playRef,
+      input: input.childInput,
+    }),
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -92,6 +92,20 @@ export class DaytonaSandboxAcquisitionUnavailableError extends Error {
   }
 }
 
+/**
+ * A named Daytona create is still changing state after the client deadline.
+ * The scheduler must defer and resume this exact identity; falling back or
+ * creating another sandbox could execute the Play twice.
+ */
+export class DaytonaSandboxTransitionPendingError extends Error {
+  constructor(readonly sandboxName: string) {
+    super(
+      `Daytona sandbox ${sandboxName} is still transitioning after create timed out.`,
+    );
+    this.name = 'DaytonaSandboxTransitionPendingError';
+  }
+}
+
 export function resolveDaytonaSandboxAcquisitionUnavailableReason(
   errors: readonly string[],
 ): DaytonaSandboxAcquisitionUnavailableReason | null {
@@ -326,7 +340,8 @@ async function createOneShotDaytonaSandbox(input: {
 type TimedOutDaytonaSandboxReconciliation =
   | { kind: 'started'; sandbox: DaytonaSandbox }
   | { kind: 'deleted' }
-  | { kind: 'not_found' };
+  | { kind: 'not_found' }
+  | { kind: 'transition_pending' };
 
 async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
   daytona: DaytonaClient;
@@ -376,23 +391,28 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     return { kind: 'deleted' };
   }
   if (lastDeleteConflict) {
-    throw new Error(
-      `Daytona timed-out sandbox ${input.sandboxName} remained in a state transition across the bounded cleanup window. Modal fallback suppressed.`,
-      { cause: lastDeleteConflict },
-    );
+    return { kind: 'transition_pending' };
   }
   return { kind: 'not_found' };
 }
 
+function daytonaSandboxName(providerOperationToken?: string | null): string {
+  return providerOperationToken
+    ? `dl-${providerOperationToken}`
+    : `dl-${crypto.randomUUID()}`;
+}
+
 async function createRetriedOneShotDaytonaSandbox(input: {
   daytona: DaytonaClient;
   orgId: string;
   context: DaytonaExecutionContext;
   emitStage: DaytonaStageEmitter;
   observeCreateCall?: DaytonaCreateCallObserver;
-  reserveSandboxCapacity?: (
-    providerAttempt: number,
-  ) => Promise<{ leaseId: string; providerOperationToken: string | null }>;
+  reserveSandboxCapacity?: (providerAttempt: number) => Promise<{
+    leaseId: string;
+    providerOperationToken: string | null;
+    resumeExistingProviderOperation?: boolean;
+  }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   nextProviderAttempt: () => number;
   startedAt: number;
@@ -400,7 +420,6 @@ async function createRetriedOneShotDaytonaSandbox(input: {
   const errors: string[] = [];
   for (const [index, delayMs] of DAYTONA_CREATE_RETRY_DELAYS_MS.entries()) {
     const attempt = input.nextProviderAttempt();
-    const sandboxName = `dl-${crypto.randomUUID()}`;
     if (delayMs > 0) {
       input.emitStage('create:retry', {
         attempt: index,
@@ -417,6 +436,40 @@ async function createRetriedOneShotDaytonaSandbox(input: {
       providerAttempt: attempt,
     });
     const reservation = await input.reserveSandboxCapacity?.(attempt);
+    const sandboxName = daytonaSandboxName(reservation?.providerOperationToken);
+    if (reservation?.resumeExistingProviderOperation) {
+      if (!input.daytona.get) {
+        throw new DaytonaSandboxTransitionPendingError(sandboxName);
+      }
+      try {
+        const sandbox = await input.daytona.get(sandboxName);
+        if (sandbox.state !== 'started') {
+          throw new DaytonaSandboxTransitionPendingError(sandboxName);
+        }
+        const acquiredAt = Date.now();
+        input.emitStage('create:resumed', {
+          attempt,
+          elapsedMs: acquiredAt - input.startedAt,
+          sandboxId: sandbox.id,
+        });
+        return {
+          sandbox,
+          attempt,
+          attemptElapsedMs: acquiredAt - attemptStartedAt,
+          sandboxCapacityLeaseId: reservation.leaseId,
+        };
+      } catch (error) {
+        if (error instanceof DaytonaSandboxTransitionPendingError) throw error;
+        if (!isDaytonaSandboxNotFound(error)) {
+          throw new DaytonaSandboxTransitionPendingError(sandboxName);
+        }
+        await input.releaseSandboxCapacity?.(reservation.leaseId);
+        throw new DaytonaSandboxAcquisitionUnavailableError(
+          'daytona_sandbox_start_timeout',
+          `Timed-out Daytona sandbox ${sandboxName} was confirmed absent before resume.`,
+        );
+      }
+    }
     let sandbox: DaytonaSandbox;
     try {
       sandbox = await createOneShotDaytonaSandbox({
@@ -496,6 +549,15 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           };
         }
         await recordCreateFailure();
+        if (reconciliation.kind === 'transition_pending') {
+          if (reservation?.providerOperationToken) {
+            throw new DaytonaSandboxTransitionPendingError(sandboxName);
+          }
+          throw new Error(
+            `Daytona timed-out sandbox ${sandboxName} remained in a state transition across the bounded cleanup window. Modal fallback suppressed.`,
+            { cause: error },
+          );
+        }
         if (reconciliation.kind === 'deleted') {
           // The provider-confirmed reconciliation means this reservation can
           // no longer represent a live sandbox. Release before returning the
@@ -693,6 +755,7 @@ export function createOneShotDaytonaSandboxLifecycle(input: {
   reserveSandboxCapacity?: (providerAttempt: number) => Promise<{
     leaseId: string;
     providerOperationToken: string | null;
+    resumeExistingProviderOperation?: boolean;
   }>;
   releaseSandboxCapacity?: (leaseId: string) => Promise<void>;
   startAdmission?: DaytonaSandboxStartAdmission;

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-payload-transport.ts

@@ -26,6 +26,11 @@ import {
   RUNTIME_SANDBOX_KILLED_MESSAGE,
   RUNTIME_SANDBOX_OOM_MESSAGE,
 } from '../../run-failure';
+import {
+  buildDaytonaPayloadMaterializerSource,
+  type DaytonaPayloadEnvelope,
+} from '../../daytona-payload-contract';
+export { buildDaytonaPayloadMaterializerSource } from '../../daytona-payload-contract';
 import { compactPlayArtifactForRuntimeTransport } from '../../../plays/artifact-transport';
 import type {
   DaytonaExecutionContext,
@@ -36,16 +41,6 @@ import { buildDaytonaRuntimeWatchdogSource } from './daytona-runtime-watchdog';
 
 type DaytonaRemoteRuntimeContext = PlayRunnerExecutionConfig['context'];
 
-type DaytonaPayloadEnvelope = {
-  schemaVersion: 1;
-  runnerCode: string;
-  artifactBundledCode: string;
-  artifactSourceMap: string;
-  config: PlayRunnerExecutionConfig;
-  /** Crash-containment epilogue script (see buildDaytonaCrashTerminalPusherSource). */
-  crashPusherCode: string;
-};
-
 /**
  * The crash pusher must be able to recover one complete terminal event after
  * a runner exits before its primary gateway push. A stdout `result` event is
@@ -116,8 +111,7 @@ function nodeMaterializePayloadCommand(input: {
   artifactSourceMapPath: string;
   crashPusherPath: string;
 }): string {
-  const script =
-    "const fs=require('node:fs');const zlib=require('node:zlib');const p=JSON.parse(zlib.gunzipSync(fs.readFileSync(process.argv[1])));if(p.schemaVersion!==1)throw new Error('Unsupported Daytona payload envelope');fs.writeFileSync(process.argv[2],p.runnerCode);fs.writeFileSync(process.argv[3],JSON.stringify(p.config));fs.writeFileSync(process.argv[4],p.artifactBundledCode);fs.writeFileSync(process.argv[5],p.artifactSourceMap);fs.writeFileSync(process.argv[6],p.crashPusherCode);";
+  const script = buildDaytonaPayloadMaterializerSource();
   return [
     'node',
     '-e',