deepline 0.2.0 → 0.2.1

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

@@ -187,7 +187,7 @@ function resolvePlayRunRuntimeSelection(
     const runtime = normalizePlayRuntimeSelection(request.runtime);
     if (!runtime) {
       throw new DeeplineError(
-        'runtime must be exactly { environment: "preview", namespace } with namespace matching ^[a-z][a-z0-9-]{0,30}$.',
+        'runtime must be { environment: "preview", namespace, backend?: "daytona" | "modal" } with namespace matching ^[a-z][a-z0-9-]{0,30}$.',
         undefined,
         'INVALID_RUNTIME_SELECTION',
       );
@@ -229,7 +229,18 @@ function resolvePlayRunRuntimeSelection(
       'INVALID_RUNTIME_NAMESPACE',
     );
   }
-  return { environment, namespace };
+  const configuredBackend = process.env.DEEPLINE_PLAY_RUNNER_BACKEND?.trim();
+  if (!configuredBackend) {
+    return { environment, namespace };
+  }
+  if (configuredBackend !== 'daytona' && configuredBackend !== 'modal') {
+    throw new DeeplineError(
+      `DEEPLINE_PLAY_RUNNER_BACKEND must be daytona or modal for preview runtime selection. Received "${configuredBackend}".`,
+      undefined,
+      'INVALID_RUNTIME_BACKEND',
+    );
+  }
+  return { environment, namespace, backend: configuredBackend };
 }
 
 function runtimeSelectionHeaders(

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

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.0',
+  version: '0.2.1',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -1,6 +1,7 @@
 export const PLAY_RUNTIME_BACKENDS = {
   localProcess: 'local_process',
   daytona: 'daytona',
+  modal: 'modal',
 } as const;
 
 export type PlayRuntimeBackendId =
@@ -39,6 +40,11 @@ export const PLAY_BACKEND_DESCRIPTORS: Record<
     artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
     label: 'Daytona sandbox',
   },
+  [PLAY_RUNTIME_BACKENDS.modal]: {
+    id: PLAY_RUNTIME_BACKENDS.modal,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: 'Modal sandbox',
+  },
 };
 
 export function describePlayBackend(
@@ -65,6 +71,10 @@ export function normalizePlayRuntimeBackend(
     return PLAY_RUNTIME_BACKENDS.daytona;
   }
 
+  if (normalized === PLAY_RUNTIME_BACKENDS.modal) {
+    return PLAY_RUNTIME_BACKENDS.modal;
+  }
+
   if (normalized === PLAY_RUNTIME_BACKENDS.localProcess) {
     return PLAY_RUNTIME_BACKENDS.localProcess;
   }
@@ -118,3 +128,12 @@ export function isPlayRuntimeBackendId(
     Object.values(PLAY_RUNTIME_BACKENDS).includes(value as PlayRuntimeBackendId)
   );
 }
+
+export function isManagedSandboxRuntimeBackend(
+  value: string | null | undefined,
+): boolean {
+  return (
+    value === PLAY_RUNTIME_BACKENDS.daytona ||
+    value === PLAY_RUNTIME_BACKENDS.modal
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/modal-runtime-config.ts

@@ -0,0 +1,104 @@
+import type { ModalClient } from 'modal';
+import { isIsolatedRuntimeSchedulerSchema } from './runtime-scheduler-topology';
+import {
+  STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
+  validatePlaySandboxRuntimeLimits,
+  type PlaySandboxRuntimeLimits,
+} from './sandbox-runtime-limits';
+
+export const MODAL_RUNNER_APP_NAME = 'deepline-play-runner';
+export const MODAL_RUNNER_IMAGE = 'node:20-bookworm-slim';
+export const MODAL_RUNNER_WORKDIR = '/root/deepline';
+
+// Modal bills one physical core as two vCPUs. This matches the standard
+// Deepline one-vCPU / one-GiB sandbox.
+export const MODAL_SANDBOX_CPU_CORES = 0.5;
+export const MODAL_SANDBOX_MEMORY_MIB = 1024;
+
+export type ModalRequiredConfig = {
+  client: ModalClient;
+  appName: string;
+  image: string;
+  workdir: string;
+  outboundCidrAllowlist: string[] | null;
+  limits: PlaySandboxRuntimeLimits;
+};
+
+export type ModalClientConfig = Omit<
+  ModalRequiredConfig,
+  'outboundCidrAllowlist' | 'limits'
+>;
+
+function requiredEnv(
+  env: NodeJS.ProcessEnv,
+  name: 'MODAL_TOKEN_ID' | 'MODAL_TOKEN_SECRET',
+): string {
+  const value = env[name]?.trim();
+  if (!value) throw new Error(`Missing required Modal configuration: ${name}.`);
+  return value;
+}
+
+function cidrAllowlist(raw: string | null | undefined): string[] | null {
+  const values = (raw ?? '')
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .filter((value) => !value.includes(':'));
+  return values.length > 0 ? values : null;
+}
+
+export function resolveModalSandboxNetworkPolicy(input: {
+  runtimeSchedulerSchema: string | null | undefined;
+  env?: NodeJS.ProcessEnv;
+}): { outboundCidrAllowlist: string[] | null } {
+  const env = input.env ?? process.env;
+  const outboundCidrAllowlist = cidrAllowlist(
+    env.DEEPLINE_DAYTONA_NETWORK_ALLOW_LIST,
+  );
+  if (
+    !outboundCidrAllowlist &&
+    env.NODE_ENV === 'production' &&
+    !isIsolatedRuntimeSchedulerSchema(input.runtimeSchedulerSchema)
+  ) {
+    throw new Error(
+      'DEEPLINE_DAYTONA_NETWORK_ALLOW_LIST is required for the Modal capacity fallback in production. Refusing to run customer code with unrestricted outbound network access.',
+    );
+  }
+  return { outboundCidrAllowlist };
+}
+
+export async function loadModalRequiredConfig(input: {
+  env?: NodeJS.ProcessEnv;
+  runtimeSchedulerSchema?: string | null;
+  limits?: PlaySandboxRuntimeLimits | null;
+}): Promise<ModalRequiredConfig> {
+  const env = input.env ?? process.env;
+  const clientConfig = await loadModalClientConfig({ env });
+  const { outboundCidrAllowlist } = resolveModalSandboxNetworkPolicy({
+    env,
+    runtimeSchedulerSchema: input.runtimeSchedulerSchema,
+  });
+  return {
+    ...clientConfig,
+    outboundCidrAllowlist,
+    limits: validatePlaySandboxRuntimeLimits(
+      input.limits ?? { ...STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS },
+    ),
+  };
+}
+
+export async function loadModalClientConfig(
+  input: { env?: NodeJS.ProcessEnv } = {},
+): Promise<ModalClientConfig> {
+  const env = input.env ?? process.env;
+  const tokenId = requiredEnv(env, 'MODAL_TOKEN_ID');
+  const tokenSecret = requiredEnv(env, 'MODAL_TOKEN_SECRET');
+  const { ModalClient } = await import('modal');
+  return {
+    client: new ModalClient({ tokenId, tokenSecret }),
+    appName:
+      env.DEEPLINE_MODAL_RUNNER_APP_NAME?.trim() || MODAL_RUNNER_APP_NAME,
+    image: env.DEEPLINE_MODAL_RUNNER_IMAGE?.trim() || MODAL_RUNNER_IMAGE,
+    workdir: env.DEEPLINE_MODAL_RUNNER_WORKDIR?.trim() || MODAL_RUNNER_WORKDIR,
+  };
+}

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

@@ -231,10 +231,13 @@ export type PlayRunnerEvent =
     };
 
 export type PlayRunnerRuntimeTiming = {
-  backend: 'daytona';
+  backend: 'daytona' | 'modal';
   daytonaCreateMs?: number;
   daytonaUploadMs?: number;
   daytonaExecuteMs?: number;
+  modalCreateMs?: number;
+  modalUploadMs?: number;
+  modalExecuteMs?: number;
 };
 
 /**

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

@@ -12,6 +12,9 @@ import {
 
 const DAYTONA_CREATE_TIMEOUT_SECONDS = 10;
 const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
+const DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS = [
+  0, 250, 750, 1_500, 3_000,
+] as const;
 // Explicit runner deadline + scheduler GC own the normal lifecycle. Daytona's
 // inactivity stop is a wider crash backstop measured from sandbox creation, so
 // setup time cannot consume the terminal-flush grace.
@@ -54,6 +57,47 @@ export type OneShotDaytonaSandboxLifecycle = {
   dispose: () => Promise<void>;
 };
 
+export type DaytonaSandboxAcquisitionUnavailableReason =
+  | 'daytona_total_cpu_limit_exceeded'
+  | 'daytona_sandbox_start_timeout';
+
+/**
+ * A typed, pre-customer-code acquisition rejection. Only this error may move
+ * managed placement to another provider.
+ */
+export class DaytonaSandboxAcquisitionUnavailableError extends Error {
+  readonly reason: DaytonaSandboxAcquisitionUnavailableReason;
+
+  constructor(
+    reason: DaytonaSandboxAcquisitionUnavailableReason,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'DaytonaSandboxAcquisitionUnavailableError';
+    this.reason = reason;
+  }
+}
+
+export function resolveDaytonaSandboxAcquisitionUnavailableReason(
+  errors: readonly string[],
+): DaytonaSandboxAcquisitionUnavailableReason | null {
+  if (
+    errors.length > 0 &&
+    errors.every((error) =>
+      /Total CPU limit exceeded\.\s*Maximum allowed:\s*\d+/i.test(error),
+    )
+  ) {
+    return 'daytona_total_cpu_limit_exceeded';
+  }
+  return null;
+}
+
+function isDaytonaSandboxStartTimeout(error: string): boolean {
+  return /Failed to create and start sandbox within 10 seconds\. Operation timed out\./.test(
+    error,
+  );
+}
+
 type DaytonaCreateResult = {
   sandbox: DaytonaSandbox;
   attempt: number;
@@ -177,6 +221,7 @@ async function createOneShotDaytonaSandbox(input: {
   daytona: DaytonaClient;
   orgId: string;
   context: DaytonaExecutionContext;
+  sandboxName: string;
 }): Promise<DaytonaSandbox> {
   const limits = validatePlaySandboxRuntimeLimits(
     input.context.sandboxRuntimeLimits ?? {
@@ -205,8 +250,13 @@ async function createOneShotDaytonaSandbox(input: {
   });
 
   const commonParams = {
+    name: input.sandboxName,
     labels,
+    // This is also the provider-owned backstop for an HTTP create timeout
+    // whose named sandbox never becomes lookup-addressable to this process:
+    // Daytona deletes an ephemeral sandbox immediately when it stops.
     ephemeral: true,
+    autoDeleteInterval: 0,
     autoStopInterval: Math.ceil(
       (limits.timeoutSeconds + PLAY_RUNNER_TIMEOUT_SECONDS - 30 * 60) / 60,
     ),
@@ -224,6 +274,34 @@ async function createOneShotDaytonaSandbox(input: {
   });
 }
 
+async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
+  daytona: DaytonaClient;
+  sandboxName: string;
+}): Promise<boolean> {
+  if (!input.daytona.get) return false;
+  for (const delayMs of DAYTONA_TIMED_OUT_CREATE_RECONCILE_DELAYS_MS) {
+    if (delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    let sandbox: DaytonaSandbox;
+    try {
+      sandbox = await input.daytona.get(input.sandboxName);
+    } catch {
+      continue;
+    }
+    try {
+      await sandbox.delete(30);
+    } catch (error) {
+      throw new Error(
+        `Daytona timed-out sandbox ${sandbox.id} was reconciled by name but could not be deleted. Modal fallback suppressed.`,
+        { cause: error },
+      );
+    }
+    return true;
+  }
+  return false;
+}
+
 async function createRetriedOneShotDaytonaSandbox(input: {
   daytona: DaytonaClient;
   orgId: string;
@@ -234,6 +312,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
   const errors: string[] = [];
   for (const [index, delayMs] of DAYTONA_CREATE_RETRY_DELAYS_MS.entries()) {
     const attempt = index + 1;
+    const sandboxName = `dl-${crypto.randomUUID()}`;
     if (delayMs > 0) {
       input.emitStage('create:retry', {
         attempt: index,
@@ -249,6 +328,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
         daytona: input.daytona,
         orgId: input.orgId,
         context: input.context,
+        sandboxName,
       });
       return {
         sandbox,
@@ -270,11 +350,34 @@ async function createRetriedOneShotDaytonaSandbox(input: {
         attempt,
         error: message,
       });
+      if (isDaytonaSandboxStartTimeout(message)) {
+        const deleted = await reconcileAndDeleteTimedOutDaytonaSandbox({
+          daytona: input.daytona,
+          sandboxName,
+        });
+        if (deleted) {
+          throw new DaytonaSandboxAcquisitionUnavailableError(
+            'daytona_sandbox_start_timeout',
+            `${message} Timed-out Daytona sandbox was reconciled and deleted before fallback.`,
+          );
+        }
+        throw new Error(
+          `${message} Daytona did not return a cleanup-addressable sandbox identity; Modal fallback suppressed. The named ephemeral sandbox retains Daytona's auto-delete-on-stop backstop.`,
+          { cause: error },
+        );
+      }
     }
   }
-  throw new Error(
-    `Daytona sandbox create failed across ${errors.length} bounded attempts: ${errors.join('; ')}`,
-  );
+  const message = `Daytona sandbox create failed across ${errors.length} bounded attempts: ${errors.join('; ')}`;
+  const fallbackReason =
+    resolveDaytonaSandboxAcquisitionUnavailableReason(errors);
+  if (fallbackReason) {
+    throw new DaytonaSandboxAcquisitionUnavailableError(
+      fallbackReason,
+      message,
+    );
+  }
+  throw new Error(message);
 }
 
 async function acquireOneShotDaytonaSandbox(input: {

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

@@ -0,0 +1,218 @@
+import type {
+  PlayRunnerBackend,
+  PlayRunnerCallbacks,
+  PlayRunnerPreparedExecution,
+  PlayRunnerPrepareInput,
+} from '../types';
+import type {
+  PlayRunnerExecutionConfig,
+  PlayRunnerResult,
+} from '@shared_libs/play-runtime/protocol';
+import { daytonaPlayRunnerBackend } from './daytona';
+import { DaytonaSandboxAcquisitionUnavailableError } from './daytona-lifecycle';
+import { modalPlayRunnerBackend } from './modal';
+import {
+  canTransitionRuntimeSandboxPlacement,
+  resolveRuntimeSandboxPlacementPolicy,
+  RUNTIME_SANDBOX_PLACEMENT_POLICIES,
+  type RuntimeSandboxPlacementPolicyId,
+  type RuntimeSandboxPlacementFailureReason,
+  type RuntimeSandboxPlacementPolicy,
+  type RuntimeSandboxProvider,
+} from '@shared_libs/play-runtime/runtime-sandbox-placement-policy';
+
+type DaytonaFallbackPreparedExecution = PlayRunnerPreparedExecution & {
+  kind: 'runtime_sandbox_placement';
+  policyId: string;
+  provider: RuntimeSandboxProvider;
+  providerPrepared: PlayRunnerPreparedExecution | undefined;
+};
+
+function isPrepared(
+  prepared: PlayRunnerPreparedExecution | undefined,
+): prepared is DaytonaFallbackPreparedExecution {
+  return prepared?.kind === 'runtime_sandbox_placement';
+}
+
+type RuntimeSandboxProviderAdapter = {
+  backend: PlayRunnerBackend;
+  classifyAcquisitionFailure: (
+    error: unknown,
+  ) => RuntimeSandboxPlacementFailureReason | null;
+};
+
+function classifyDaytonaAcquisitionFailure(
+  error: unknown,
+): RuntimeSandboxPlacementFailureReason | null {
+  if (!(error instanceof DaytonaSandboxAcquisitionUnavailableError)) {
+    return null;
+  }
+  if (error.reason === 'daytona_total_cpu_limit_exceeded') {
+    return 'provider_capacity_exhausted';
+  }
+  if (error.reason === 'daytona_sandbox_start_timeout') {
+    return 'provider_start_timeout_before_execution';
+  }
+  return null;
+}
+
+/**
+ * Deep placement Implementation. Provider order alone never permits a retry:
+ * the policy must also name the exact pre-execution transition and the source
+ * Adapter must classify the thrown failure into that provider-neutral reason.
+ */
+export function createRuntimeSandboxPlacementBackend(input: {
+  policy: RuntimeSandboxPlacementPolicy;
+  adapters: Readonly<
+    Partial<Record<RuntimeSandboxProvider, RuntimeSandboxProviderAdapter>>
+  >;
+}): PlayRunnerBackend {
+  const primaryProvider = input.policy.providers[0];
+  const primaryAdapter = input.adapters[primaryProvider];
+  if (!primaryAdapter) {
+    throw new Error(
+      `Runtime sandbox placement policy ${input.policy.id} has no Adapter for ${primaryProvider}.`,
+    );
+  }
+  return {
+    async prepare(
+      prepareInput: PlayRunnerPrepareInput,
+      callbacks?: PlayRunnerCallbacks,
+    ): Promise<PlayRunnerPreparedExecution> {
+      const providerPrepared = await primaryAdapter.backend.prepare?.(
+        prepareInput,
+        callbacks,
+      );
+      const prepared: DaytonaFallbackPreparedExecution = {
+        kind: 'runtime_sandbox_placement',
+        policyId: input.policy.id,
+        provider: primaryProvider,
+        providerPrepared,
+        dispose: async () => await providerPrepared?.dispose?.(),
+      };
+      return prepared;
+    },
+
+    async execute(
+      config: PlayRunnerExecutionConfig,
+      callbacks?: PlayRunnerCallbacks,
+      prepared?: PlayRunnerPreparedExecution,
+    ): Promise<PlayRunnerResult> {
+      const policyPrepared =
+        isPrepared(prepared) && prepared.policyId === input.policy.id
+          ? prepared
+          : null;
+      for (const [index, provider] of input.policy.providers.entries()) {
+        const adapter = input.adapters[provider];
+        if (!adapter) {
+          throw new Error(
+            `Runtime sandbox placement policy ${input.policy.id} has no Adapter for ${provider}.`,
+          );
+        }
+        try {
+          return await adapter.backend.execute(
+            config,
+            callbacks,
+            index === 0 && policyPrepared?.provider === provider
+              ? policyPrepared.providerPrepared
+              : undefined,
+          );
+        } catch (error) {
+          const nextProvider = input.policy.providers[index + 1];
+          const reason = adapter.classifyAcquisitionFailure(error);
+          if (
+            !nextProvider ||
+            !reason ||
+            callbacks?.cancellationSignal?.aborted ||
+            !canTransitionRuntimeSandboxPlacement({
+              policy: input.policy,
+              from: provider,
+              to: nextProvider,
+              stage: 'acquisition',
+              reason,
+            })
+          ) {
+            throw error;
+          }
+          console.warn('[play-runner.sandbox_provider_fallback]', {
+            runId: config.context.runId ?? null,
+            workflowId: config.context.workflowId ?? null,
+            policyId: input.policy.id,
+            from: provider,
+            to: nextProvider,
+            stage: 'acquisition',
+            reason,
+          });
+        }
+      }
+      throw new Error(
+        `Runtime sandbox placement policy ${input.policy.id} exhausted without a result.`,
+      );
+    },
+  };
+}
+
+export function createRuntimeSandboxPlacementBackendForPolicy(
+  policyId: RuntimeSandboxPlacementPolicyId | string,
+  overrides: {
+    daytona?: PlayRunnerBackend;
+    modal?: PlayRunnerBackend;
+  } = {},
+): PlayRunnerBackend {
+  return createRuntimeSandboxPlacementBackend({
+    policy: resolveRuntimeSandboxPlacementPolicy(policyId),
+    adapters: {
+      daytona: {
+        backend: overrides.daytona ?? daytonaPlayRunnerBackend,
+        classifyAcquisitionFailure: classifyDaytonaAcquisitionFailure,
+      },
+      modal: {
+        backend: overrides.modal ?? modalPlayRunnerBackend,
+        classifyAcquisitionFailure: () => null,
+      },
+    },
+  });
+}
+
+/** Compatibility factory retained for existing imports and tests. */
+export function createDaytonaModalFallbackBackend(
+  input: {
+    daytona?: PlayRunnerBackend;
+    modal?: PlayRunnerBackend;
+  } = {},
+): PlayRunnerBackend {
+  return createRuntimeSandboxPlacementBackendForPolicy(
+    RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1,
+    input,
+  );
+}
+
+export const daytonaModalFallbackPlayRunnerBackend =
+  createDaytonaModalFallbackBackend();
+
+export const daytonaOnlyPlayRunnerBackend =
+  createRuntimeSandboxPlacementBackendForPolicy(
+    RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaOnlyV1,
+  );
+
+export const modalOnlyPlayRunnerBackend =
+  createRuntimeSandboxPlacementBackendForPolicy(
+    RUNTIME_SANDBOX_PLACEMENT_POLICIES.modalOnlyV1,
+  );
+
+const DEFAULT_POLICY_BACKENDS: Readonly<
+  Record<RuntimeSandboxPlacementPolicyId, PlayRunnerBackend>
+> = {
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaOnlyV1]:
+    daytonaOnlyPlayRunnerBackend,
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1]:
+    daytonaModalFallbackPlayRunnerBackend,
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.modalOnlyV1]: modalOnlyPlayRunnerBackend,
+};
+
+export function resolveDefaultRuntimeSandboxPlacementBackend(
+  policyId: RuntimeSandboxPlacementPolicyId | string,
+): PlayRunnerBackend {
+  const policy = resolveRuntimeSandboxPlacementPolicy(policyId);
+  return DEFAULT_POLICY_BACKENDS[policy.id];
+}

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

@@ -65,6 +65,11 @@ export type StagedDaytonaPayload = {
   progressEventPath: string;
 };
 
+export type RemoteRunnerPayloadSandbox = {
+  id: string;
+  uploadFile(content: Buffer, path: string): Promise<void>;
+};
+
 function shellQuote(value: string): string {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -390,23 +395,23 @@ function remoteRuntimeContextForDaytona(
   };
 }
 
-async function timedDaytonaUpload(input: {
-  sandbox: DaytonaSandbox;
+async function timedRunnerPayloadUpload(input: {
+  sandbox: RemoteRunnerPayloadSandbox;
   emitStage: DaytonaStageEmitter;
   label: string;
   path: string;
   content: Buffer;
 }) {
   const startedAt = Date.now();
-  await input.sandbox.fs.uploadFile(input.content, input.path);
+  await input.sandbox.uploadFile(input.content, input.path);
   input.emitStage(`upload:${input.label}:done`, {
     bytes: input.content.byteLength,
     elapsedMs: Date.now() - startedAt,
   });
 }
 
-export async function stageDaytonaRunnerPayload(input: {
-  sandbox: DaytonaSandbox;
+export async function stageRunnerPayload(input: {
+  sandbox: RemoteRunnerPayloadSandbox;
   bundlePromise: Promise<string>;
   config: PlayRunnerExecutionConfig;
   workDir: string;
@@ -458,7 +463,7 @@ export async function stageDaytonaRunnerPayload(input: {
 
   await Promise.all(
     [...uniqueLocalPaths.entries()].map(async ([localPath, remotePath]) => {
-      await timedDaytonaUpload({
+      await timedRunnerPayloadUpload({
         sandbox: input.sandbox,
         emitStage: input.emitStage,
         label:
@@ -508,7 +513,7 @@ export async function stageDaytonaRunnerPayload(input: {
     STANDARD_PLAY_RUNTIME_LIMIT_SECONDS;
 
   const envelopeUpload = input.bundlePromise.then((bundle) =>
-    timedDaytonaUpload({
+    timedRunnerPayloadUpload({
       sandbox: input.sandbox,
       emitStage: input.emitStage,
       label: 'payload',
@@ -583,3 +588,17 @@ export async function stageDaytonaRunnerPayload(input: {
     progressEventPath,
   };
 }
+
+export async function stageDaytonaRunnerPayload(
+  input: Omit<Parameters<typeof stageRunnerPayload>[0], 'sandbox'> & {
+    sandbox: DaytonaSandbox;
+  },
+): Promise<StagedDaytonaPayload> {
+  return await stageRunnerPayload({
+    ...input,
+    sandbox: {
+      id: input.sandbox.id,
+      uploadFile: (content, path) => input.sandbox.fs.uploadFile(content, path),
+    },
+  });
+}