deepline 0.2.0 → 0.2.2

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

@@ -10,11 +10,15 @@ import type {
 } from '@shared_libs/play-runtime/protocol';
 
 export type PlayRunnerRuntimeResource = {
-  kind: 'daytona_sandbox';
+  kind: 'daytona_sandbox' | 'modal_sandbox';
   sandboxId: string;
+  /** Runtime estate that owns provider credentials and durable cleanup. */
+  runtimeEnvironment?: 'preview' | 'production';
   daytonaEnvironment?: 'preview' | 'production';
   /** Stable, non-secret provider ownership domain returned by Daytona. */
   daytonaOrganizationId?: string;
+  /** Stable, non-secret Modal ownership domain returned at acquisition. */
+  modalAppId?: string;
   billingStartedAt: number;
   billingEndedAt?: number | null;
   /** Customer liability ceiling for this physical sandbox. */
@@ -36,6 +40,22 @@ export type RuntimeResourceTerminalReason =
   | 'cancelled'
   | 'lease_expired';
 
+/**
+ * Safe, provider-edge lifecycle evidence. The scheduler records these before
+ * relying on a non-idempotent provider outcome; raw provider responses,
+ * commands, inputs, and credentials are intentionally not part of the type.
+ */
+export type PlayRunnerRuntimeLifecycleEvent = {
+  type:
+    | 'daytona_create_call_started'
+    | 'daytona_create_call_succeeded'
+    | 'daytona_create_call_failed';
+  occurredAtMs: number;
+  providerAttempt: number;
+  sandboxId?: string;
+  errorClass?: 'timeout' | 'capacity' | 'rate_limit' | 'other';
+};
+
 export class RuntimeResourceFenceLostError extends Error {
   constructor(message: string) {
     super(message);
@@ -51,6 +71,13 @@ export interface PlayRunnerCallbacks {
   onRuntimeResourceAcquired?: (
     resource: PlayRunnerRuntimeResource,
   ) => void | Promise<void>;
+  /**
+   * Durable scheduler-owned evidence for a provider create call. Backends
+   * await this callback at the create boundary; it is not best-effort logging.
+   */
+  onRuntimeLifecycleEvent?: (
+    event: PlayRunnerRuntimeLifecycleEvent,
+  ) => Promise<void>;
   /**
    * Scheduler-owned readiness read for a detached runner attempt. Daytona uses
    * this direct control-plane port before parking; it is never serialized into

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

@@ -1,3 +1,5 @@
+import { PLAY_RUNTIME_BACKENDS, type PlayRuntimeBackendId } from './backend';
+
 export const PLAY_RUNTIME_ENVIRONMENTS = ['preview'] as const;
 
 export type PlayRuntimeEnvironment = (typeof PLAY_RUNTIME_ENVIRONMENTS)[number];
@@ -6,6 +8,8 @@ export type PlayRuntimeSelection = {
   environment: 'preview';
   /** Caller-named isolation scope inside a remote runtime environment. */
   namespace: string;
+  /** Explicit managed-sandbox executor. Omission preserves Daytona compatibility. */
+  backend?: Extract<PlayRuntimeBackendId, 'daytona' | 'modal'>;
 };
 
 const PLAY_RUNTIME_NAMESPACE_PATTERN = /^[a-z][a-z0-9-]{0,30}$/;
@@ -24,14 +28,25 @@ export function normalizePlayRuntimeSelection(
   const record = value as Record<string, unknown>;
   if (
     Object.keys(record).some(
-      (key) => key !== 'environment' && key !== 'namespace',
+      (key) =>
+        key !== 'environment' && key !== 'namespace' && key !== 'backend',
     ) ||
     record.environment !== 'preview'
   ) {
     return null;
   }
   const namespace = normalizePlayRuntimeNamespace(record.namespace);
-  return namespace ? { environment: 'preview', namespace } : null;
+  if (!namespace) return null;
+  if (record.backend === undefined) {
+    return { environment: 'preview', namespace };
+  }
+  if (
+    record.backend !== PLAY_RUNTIME_BACKENDS.daytona &&
+    record.backend !== PLAY_RUNTIME_BACKENDS.modal
+  ) {
+    return null;
+  }
+  return { environment: 'preview', namespace, backend: record.backend };
 }
 
 export function normalizePlayRuntimeEnvironment(

package/dist/bundling-sources/shared_libs/play-runtime/runtime-sandbox-placement-policy.ts

@@ -0,0 +1,188 @@
+import { PLAY_RUNTIME_BACKENDS, type PlayRuntimeBackendId } from './backend';
+
+export const RUNTIME_SANDBOX_PROVIDERS = {
+  daytona: 'daytona',
+  modal: 'modal',
+} as const;
+
+export type RuntimeSandboxProvider =
+  (typeof RUNTIME_SANDBOX_PROVIDERS)[keyof typeof RUNTIME_SANDBOX_PROVIDERS];
+
+/**
+ * Stable durable ids. Changing provider order or transition rules creates a
+ * new version instead of changing the meaning of an already-queued launch.
+ */
+export const RUNTIME_SANDBOX_PLACEMENT_POLICIES = {
+  daytonaOnlyV1: 'daytona_only@1',
+  daytonaThenModalV1: 'daytona_then_modal@1',
+  modalOnlyV1: 'modal_only@1',
+} as const;
+
+export type RuntimeSandboxPlacementPolicyId =
+  (typeof RUNTIME_SANDBOX_PLACEMENT_POLICIES)[keyof typeof RUNTIME_SANDBOX_PLACEMENT_POLICIES];
+
+export type RuntimeSandboxPlacementFailureReason =
+  | 'provider_capacity_exhausted'
+  | 'provider_start_timeout_before_execution';
+
+export type RuntimeSandboxPlacementTransition = Readonly<{
+  from: RuntimeSandboxProvider;
+  to: RuntimeSandboxProvider;
+  stage: 'acquisition';
+  reasons: readonly RuntimeSandboxPlacementFailureReason[];
+}>;
+
+export type RuntimeSandboxPlacementPolicy = Readonly<{
+  id: RuntimeSandboxPlacementPolicyId;
+  compatibilityRuntimeBackend:
+    | typeof PLAY_RUNTIME_BACKENDS.daytona
+    | typeof PLAY_RUNTIME_BACKENDS.modal;
+  providers: readonly [RuntimeSandboxProvider, ...RuntimeSandboxProvider[]];
+  transitions: readonly RuntimeSandboxPlacementTransition[];
+  requiredCredentialEnv: readonly string[];
+  cleanupProviders: readonly RuntimeSandboxProvider[];
+}>;
+
+const DAYTONA_THEN_MODAL_V1: RuntimeSandboxPlacementPolicy = {
+  id: RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1,
+  compatibilityRuntimeBackend: PLAY_RUNTIME_BACKENDS.daytona,
+  providers: [
+    RUNTIME_SANDBOX_PROVIDERS.daytona,
+    RUNTIME_SANDBOX_PROVIDERS.modal,
+  ],
+  transitions: [
+    {
+      from: RUNTIME_SANDBOX_PROVIDERS.daytona,
+      to: RUNTIME_SANDBOX_PROVIDERS.modal,
+      stage: 'acquisition',
+      reasons: [
+        'provider_capacity_exhausted',
+        'provider_start_timeout_before_execution',
+      ],
+    },
+  ],
+  requiredCredentialEnv: [
+    'DAYTONA_API_KEY',
+    'MODAL_TOKEN_ID',
+    'MODAL_TOKEN_SECRET',
+  ],
+  cleanupProviders: [
+    RUNTIME_SANDBOX_PROVIDERS.daytona,
+    RUNTIME_SANDBOX_PROVIDERS.modal,
+  ],
+};
+
+/**
+ * Frozen compatibility policy for launches written before placement policy ids
+ * existed. It is retained until every pre-policy release lane has drained.
+ */
+const DAYTONA_ONLY_V1: RuntimeSandboxPlacementPolicy = {
+  id: RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaOnlyV1,
+  compatibilityRuntimeBackend: PLAY_RUNTIME_BACKENDS.daytona,
+  providers: [RUNTIME_SANDBOX_PROVIDERS.daytona],
+  transitions: [],
+  requiredCredentialEnv: ['DAYTONA_API_KEY'],
+  cleanupProviders: [RUNTIME_SANDBOX_PROVIDERS.daytona],
+};
+
+const MODAL_ONLY_V1: RuntimeSandboxPlacementPolicy = {
+  id: RUNTIME_SANDBOX_PLACEMENT_POLICIES.modalOnlyV1,
+  compatibilityRuntimeBackend: PLAY_RUNTIME_BACKENDS.modal,
+  providers: [RUNTIME_SANDBOX_PROVIDERS.modal],
+  transitions: [],
+  requiredCredentialEnv: ['MODAL_TOKEN_ID', 'MODAL_TOKEN_SECRET'],
+  cleanupProviders: [RUNTIME_SANDBOX_PROVIDERS.modal],
+};
+
+export const RUNTIME_SANDBOX_PLACEMENT_POLICY_CATALOG: Readonly<
+  Record<RuntimeSandboxPlacementPolicyId, RuntimeSandboxPlacementPolicy>
+> = {
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaOnlyV1]: DAYTONA_ONLY_V1,
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1]:
+    DAYTONA_THEN_MODAL_V1,
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.modalOnlyV1]: MODAL_ONLY_V1,
+};
+
+export function resolveRuntimeSandboxPlacementPolicy(
+  id: RuntimeSandboxPlacementPolicyId | string,
+): RuntimeSandboxPlacementPolicy {
+  const normalized = id.trim();
+  const policy =
+    RUNTIME_SANDBOX_PLACEMENT_POLICY_CATALOG[
+      normalized as RuntimeSandboxPlacementPolicyId
+    ];
+  if (!policy) {
+    throw new Error(
+      `Unsupported runtime sandbox placement policy "${normalized}". Expected one of: ${Object.keys(
+        RUNTIME_SANDBOX_PLACEMENT_POLICY_CATALOG,
+      ).join(', ')}.`,
+    );
+  }
+  return policy;
+}
+
+/**
+ * Compatibility Adapter for the public runtimeBackend selector. The returned
+ * policy id, not this selector, is the durable execution contract.
+ */
+export function runtimeSandboxPlacementPolicyForBackend(
+  backend: PlayRuntimeBackendId,
+): RuntimeSandboxPlacementPolicy | null {
+  if (backend === PLAY_RUNTIME_BACKENDS.daytona) {
+    return DAYTONA_THEN_MODAL_V1;
+  }
+  if (backend === PLAY_RUNTIME_BACKENDS.modal) {
+    return MODAL_ONLY_V1;
+  }
+  return null;
+}
+
+export function runtimeSandboxPlacementPoliciesForBackend(
+  backend: PlayRuntimeBackendId,
+): readonly RuntimeSandboxPlacementPolicy[] {
+  if (backend === PLAY_RUNTIME_BACKENDS.localProcess) return [];
+  return Object.values(RUNTIME_SANDBOX_PLACEMENT_POLICY_CATALOG).filter(
+    (policy) => policy.compatibilityRuntimeBackend === backend,
+  );
+}
+
+/**
+ * Old queued launches have no policy id. Derive their historical meaning from
+ * runtimeBackend only when the durable field is absent. Unknown stored ids fail
+ * loudly rather than silently changing execution semantics.
+ */
+export function resolveLaunchRuntimeSandboxPlacementPolicy(input: {
+  runtimeSandboxPlacementPolicyId?: string | null;
+  runtimeBackend: PlayRuntimeBackendId;
+}): RuntimeSandboxPlacementPolicy | null {
+  const storedId = input.runtimeSandboxPlacementPolicyId?.trim();
+  if (storedId) {
+    const policy = resolveRuntimeSandboxPlacementPolicy(storedId);
+    if (policy.compatibilityRuntimeBackend !== input.runtimeBackend) {
+      throw new Error(
+        `Runtime sandbox placement policy ${policy.id} is incompatible with runtime backend ${input.runtimeBackend}.`,
+      );
+    }
+    return policy;
+  }
+  if (input.runtimeBackend === PLAY_RUNTIME_BACKENDS.daytona) {
+    return DAYTONA_ONLY_V1;
+  }
+  return runtimeSandboxPlacementPolicyForBackend(input.runtimeBackend);
+}
+
+export function canTransitionRuntimeSandboxPlacement(input: {
+  policy: RuntimeSandboxPlacementPolicy;
+  from: RuntimeSandboxProvider;
+  to: RuntimeSandboxProvider;
+  stage: 'acquisition';
+  reason: RuntimeSandboxPlacementFailureReason;
+}): boolean {
+  return input.policy.transitions.some(
+    (transition) =>
+      transition.from === input.from &&
+      transition.to === input.to &&
+      transition.stage === input.stage &&
+      transition.reasons.includes(input.reason),
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-compute-usage.ts

@@ -1,5 +1,6 @@
 import {
   resolveDaytonaSandboxComputeItem,
+  resolveModalSandboxComputeItem,
   type ComputeBillingItem,
 } from './worker-api-types';
 
@@ -9,6 +10,82 @@ function finiteNonNegative(value: unknown): number | null {
     : null;
 }
 
+/** Project every provider-owned sandbox into a distinct internal compute item. */
+export function resolveRuntimeSandboxComputeItems(input: {
+  resources: readonly unknown[];
+  endedAt: number;
+}): ComputeBillingItem[] {
+  const daytonaResources: unknown[] = [];
+  const modalResources = new Map<
+    string,
+    {
+      startedAt: number;
+      endedAt: number | null;
+      physicalCpuCores: number | null;
+      memoryGiB: number | null;
+      maxBillingDurationSeconds: number | null;
+    }
+  >();
+  for (const resource of input.resources) {
+    if (!resource || typeof resource !== 'object' || Array.isArray(resource)) {
+      continue;
+    }
+    const value = resource as Record<string, unknown>;
+    if (value.kind === 'daytona_sandbox') {
+      daytonaResources.push(resource);
+      continue;
+    }
+    if (value.kind !== 'modal_sandbox') continue;
+    const sandboxId =
+      typeof value.sandboxId === 'string' ? value.sandboxId.trim() : '';
+    const startedAt = finiteNonNegative(value.billingStartedAt);
+    if (!sandboxId || startedAt === null) continue;
+    const endedAt = finiteNonNegative(value.billingEndedAt);
+    const existing = modalResources.get(sandboxId);
+    modalResources.set(sandboxId, {
+      startedAt: Math.min(existing?.startedAt ?? startedAt, startedAt),
+      endedAt:
+        endedAt === null
+          ? (existing?.endedAt ?? null)
+          : Math.max(existing?.endedAt ?? endedAt, endedAt),
+      physicalCpuCores:
+        finiteNonNegative(value.cpu) ?? existing?.physicalCpuCores ?? null,
+      memoryGiB:
+        finiteNonNegative(value.memoryGiB) ?? existing?.memoryGiB ?? null,
+      maxBillingDurationSeconds:
+        finiteNonNegative(value.maxBillingDurationSeconds) ??
+        existing?.maxBillingDurationSeconds ??
+        null,
+    });
+  }
+  const items = resolveDaytonaRuntimeComputeItems({
+    resources: daytonaResources,
+    endedAt: input.endedAt,
+  });
+  for (const [sandboxId, resource] of modalResources) {
+    const observedEndedAt = resource.endedAt ?? input.endedAt;
+    const endedAt =
+      resource.maxBillingDurationSeconds === null
+        ? observedEndedAt
+        : Math.min(
+            observedEndedAt,
+            resource.startedAt + resource.maxBillingDurationSeconds * 1_000,
+          );
+    items.push(
+      resolveModalSandboxComputeItem({
+        itemId: `modal:${sandboxId}`,
+        wallTimeSeconds: Math.max(0, endedAt - resource.startedAt) / 1_000,
+        physicalCpuCores: resource.physicalCpuCores ?? 0.5,
+        memoryGiB: resource.memoryGiB ?? 1,
+        sandboxId,
+        startedAt: resource.startedAt,
+        endedAt,
+      }),
+    );
+  }
+  return items;
+}
+
 /** Project executor resource facts into one idempotent item per real sandbox. */
 export function resolveDaytonaRuntimeComputeItems(input: {
   resources: readonly unknown[];

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

@@ -21,6 +21,7 @@ import type { RuntimeAuthorityDescriptor } from './execution-capabilities';
 import type { PlayRunnerRuntimeTiming } from './protocol';
 import type { RuntimeTestPolicyOverrides } from './test-runtime-seams';
 import type { PlayRunInputPayload } from './play-input';
+import type { RuntimeSandboxPlacementPolicyId } from './runtime-sandbox-placement-policy';
 
 export const PLAY_SCHEDULER_BACKENDS = {
   /**
@@ -114,6 +115,12 @@ export type PlaySchedulerSubmitInput = {
   executionProfile?: string | null;
   /** runner backend to use for executing attempts */
   runtimeBackend: string;
+  /**
+   * Versioned managed-sandbox placement contract. Optional only so launches
+   * queued before the policy field existed can drain using runtimeBackend's
+   * historical meaning.
+   */
+  runtimeSandboxPlacementPolicyId?: RuntimeSandboxPlacementPolicyId | null;
   /** dedup backend for cross-attempt cross-process idempotency */
   dedupBackend: string;
   /** If known at submit time, total input rows (for partition decisions). */

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

@@ -32,6 +32,16 @@ export type PlayExecutionSuspension =
        * the key under which its pushed terminal is recorded and its wake event
        * is named. */
       runnerAttempt: number;
+      /** Missing on historical records, which are Daytona. */
+      sandboxProvider?: 'daytona' | 'modal';
+      /** Versioned physical identity for provider-safe wake and cleanup.
+       * Legacy fields remain until every launch-pinned release has drained. */
+      runtimeSandboxRef?: {
+        schemaVersion: 1;
+        provider: 'daytona' | 'modal';
+        resourceId: string;
+        routingDomain: string | null;
+      };
       sandboxId: string;
       sessionId: string;
       cmdId: string;

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

@@ -42,6 +42,12 @@ export const DAYTONA_COMPUTE_PRICING_USD = {
   includedStorageGiB: 5,
 } as const;
 
+/** Modal Sandbox on-demand rates, per second (modal.com/pricing, 2026-07-29). */
+export const MODAL_SANDBOX_COMPUTE_PRICING_USD = {
+  physicalCoreSecond: 0.00003942,
+  memoryGiBSecond: 0.00000667,
+} as const;
+
 const NEON_COMPUTE_PRICING_USD = {
   cuHour: 0.106,
   defaultCu: 1,
@@ -94,6 +100,39 @@ export function resolveDaytonaSandboxComputeItem(input: {
   };
 }
 
+export function resolveModalSandboxComputeItem(input: {
+  itemId: string;
+  wallTimeSeconds: number;
+  physicalCpuCores: number;
+  memoryGiB: number;
+  sandboxId?: string | null;
+  startedAt?: number;
+  endedAt?: number;
+}): ComputeBillingItem {
+  const billableSeconds = Math.max(1, Math.ceil(input.wallTimeSeconds));
+  const physicalCpuCores = Math.max(0, input.physicalCpuCores);
+  const memoryGiB = Math.max(0, input.memoryGiB);
+  const providerCostUsd = roundUsd(
+    billableSeconds *
+      (physicalCpuCores * MODAL_SANDBOX_COMPUTE_PRICING_USD.physicalCoreSecond +
+        memoryGiB * MODAL_SANDBOX_COMPUTE_PRICING_USD.memoryGiBSecond),
+  );
+  return {
+    itemId: input.itemId,
+    source: 'modal',
+    unit: 'sandbox_second',
+    units: billableSeconds,
+    providerCostUsd,
+    metadata: {
+      sandboxId: input.sandboxId ?? null,
+      physicalCpuCores,
+      memoryGiB,
+      startedAt: input.startedAt,
+      endedAt: input.endedAt,
+    },
+  };
+}
+
 export function resolveNeonComputeItem(input: {
   itemId: string;
   activeSeconds: number;

package/dist/cli/index.js

@@ -1040,7 +1040,7 @@ var 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.2",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -3247,6 +3247,33 @@ function usesExtendedTheirstackJobSearchBudget(endpointId, payload) {
   return maxAgeDays !== null && maxAgeDays >= 365 ? true : usesLongExplicitDateWindow(payload);
 }
 
+// ../shared_libs/play-runtime/backend.ts
+var PLAY_RUNTIME_BACKENDS = {
+  localProcess: "local_process",
+  daytona: "daytona",
+  modal: "modal"
+};
+var PLAY_ARTIFACT_KINDS = {
+  cjsNode20: "cjs_node20"
+};
+var PLAY_BACKEND_DESCRIPTORS = {
+  [PLAY_RUNTIME_BACKENDS.localProcess]: {
+    id: PLAY_RUNTIME_BACKENDS.localProcess,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Local node subprocess"
+  },
+  [PLAY_RUNTIME_BACKENDS.daytona]: {
+    id: PLAY_RUNTIME_BACKENDS.daytona,
+    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"
+  }
+};
+
 // ../shared_libs/play-runtime/runtime-environment.ts
 var PLAY_RUNTIME_ENVIRONMENTS = ["preview"];
 var PLAY_RUNTIME_NAMESPACE_PATTERN = /^[a-z][a-z0-9-]{0,30}$/;
@@ -3259,12 +3286,19 @@ function normalizePlayRuntimeSelection(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const record = value;
   if (Object.keys(record).some(
-    (key) => key !== "environment" && key !== "namespace"
+    (key) => key !== "environment" && key !== "namespace" && key !== "backend"
   ) || record.environment !== "preview") {
     return null;
   }
   const namespace = normalizePlayRuntimeNamespace(record.namespace);
-  return namespace ? { environment: "preview", namespace } : null;
+  if (!namespace) return null;
+  if (record.backend === void 0) {
+    return { environment: "preview", namespace };
+  }
+  if (record.backend !== PLAY_RUNTIME_BACKENDS.daytona && record.backend !== PLAY_RUNTIME_BACKENDS.modal) {
+    return null;
+  }
+  return { environment: "preview", namespace, backend: record.backend };
 }
 function normalizePlayRuntimeEnvironment(value) {
   return typeof value === "string" && PLAY_RUNTIME_ENVIRONMENTS.includes(value) ? value : null;
@@ -3297,7 +3331,7 @@ function resolvePlayRunRuntimeSelection(request) {
     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}$.',
         void 0,
         "INVALID_RUNTIME_SELECTION"
       );
@@ -3333,7 +3367,18 @@ function resolvePlayRunRuntimeSelection(request) {
       "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}".`,
+      void 0,
+      "INVALID_RUNTIME_BACKEND"
+    );
+  }
+  return { environment, namespace, backend: configuredBackend };
 }
 function runtimeSelectionHeaders(runtime) {
   if (!runtime) return void 0;
@@ -12067,27 +12112,6 @@ ${hint}`;
   });
 }
 
-// ../shared_libs/play-runtime/backend.ts
-var PLAY_RUNTIME_BACKENDS = {
-  localProcess: "local_process",
-  daytona: "daytona"
-};
-var PLAY_ARTIFACT_KINDS = {
-  cjsNode20: "cjs_node20"
-};
-var PLAY_BACKEND_DESCRIPTORS = {
-  [PLAY_RUNTIME_BACKENDS.localProcess]: {
-    id: PLAY_RUNTIME_BACKENDS.localProcess,
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: "Local node subprocess"
-  },
-  [PLAY_RUNTIME_BACKENDS.daytona]: {
-    id: PLAY_RUNTIME_BACKENDS.daytona,
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: "Daytona sandbox"
-  }
-};
-
 // ../shared_libs/play-runtime/dedup-backend.ts
 var PLAY_DEDUP_BACKENDS = {
   inMemory: "in_memory",