deepline 0.2.0 → 0.2.1

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

@@ -0,0 +1,240 @@
+import {
+  deleteDaytonaSandboxByIdWithOutcome,
+  readDetachedDaytonaRuntimeCompletion,
+} from './backends/daytona';
+import {
+  deleteModalSandboxById,
+  readDetachedModalRuntimeCompletion,
+} from './backends/modal';
+import type { DetachedRunnerSuspension } from '@shared_libs/play-runtime/suspension';
+
+export type RuntimeSandboxProviderId = 'daytona' | 'modal';
+
+export type RuntimeSandboxRef = {
+  schemaVersion: 1;
+  provider: RuntimeSandboxProviderId;
+  resourceId: string;
+  routingDomain: string | null;
+};
+
+export type RuntimeSandboxReconciliationAdapter = {
+  provider: RuntimeSandboxProviderId;
+  delete(ref: RuntimeSandboxRef): Promise<RuntimeSandboxDeleteOutcome>;
+  readWorkCompletedAt(
+    ref: RuntimeSandboxRef,
+    path: string,
+  ): Promise<number | null>;
+};
+
+export type RuntimeSandboxReconciliation = {
+  delete(ref: RuntimeSandboxRef): Promise<RuntimeSandboxDeleteOutcome>;
+  readWorkCompletedAt(
+    ref: RuntimeSandboxRef,
+    path: string,
+  ): Promise<number | null>;
+};
+
+export type RuntimeSandboxDeleteOutcome =
+  | {
+      kind: 'deleted' | 'already_absent';
+      routingDomain: string | null;
+    }
+  | {
+      kind: 'timed_out' | 'rate_limited' | 'failed';
+      routingDomain: string | null;
+      code: string;
+      detail: string;
+    };
+
+export function runtimeSandboxDeleteSucceeded(
+  outcome: RuntimeSandboxDeleteOutcome,
+): outcome is Extract<
+  RuntimeSandboxDeleteOutcome,
+  { kind: 'deleted' | 'already_absent' }
+> {
+  return outcome.kind === 'deleted' || outcome.kind === 'already_absent';
+}
+
+/** Stable identity for deduplication and task idempotency at provider seams. */
+export function runtimeSandboxRefIdentityKey(ref: RuntimeSandboxRef): string {
+  return JSON.stringify([ref.provider, ref.resourceId, ref.routingDomain]);
+}
+
+function registry(
+  adapters: readonly RuntimeSandboxReconciliationAdapter[],
+): Map<RuntimeSandboxProviderId, RuntimeSandboxReconciliationAdapter> {
+  const result = new Map<
+    RuntimeSandboxProviderId,
+    RuntimeSandboxReconciliationAdapter
+  >();
+  for (const adapter of adapters) {
+    if (result.has(adapter.provider)) {
+      throw new Error(
+        `Duplicate Runtime Sandbox Adapter: ${adapter.provider}.`,
+      );
+    }
+    result.set(adapter.provider, adapter);
+  }
+  return result;
+}
+
+export function createRuntimeSandboxReconciliation(input: {
+  adapters: readonly RuntimeSandboxReconciliationAdapter[];
+}): RuntimeSandboxReconciliation {
+  const adapters = registry(input.adapters);
+  const resolve = (ref: RuntimeSandboxRef) => {
+    const adapter = adapters.get(ref.provider);
+    if (!adapter) {
+      throw new Error(
+        `No Runtime Sandbox Adapter is registered for ${ref.provider}.`,
+      );
+    }
+    return adapter;
+  };
+  return {
+    delete: (ref) => resolve(ref).delete(ref),
+    readWorkCompletedAt: (ref, path) =>
+      resolve(ref).readWorkCompletedAt(ref, path),
+  };
+}
+
+export function runtimeSandboxRefFromResource(
+  value: unknown,
+): RuntimeSandboxRef | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const resource = value as Record<string, unknown>;
+  const resourceId =
+    typeof resource.sandboxId === 'string' ? resource.sandboxId.trim() : '';
+  if (!resourceId) return null;
+  if (resource.kind === 'daytona_sandbox') {
+    return {
+      schemaVersion: 1,
+      provider: 'daytona',
+      resourceId,
+      routingDomain:
+        typeof resource.daytonaOrganizationId === 'string' &&
+        resource.daytonaOrganizationId.trim()
+          ? resource.daytonaOrganizationId.trim()
+          : null,
+    };
+  }
+  if (resource.kind === 'modal_sandbox') {
+    return {
+      schemaVersion: 1,
+      provider: 'modal',
+      resourceId,
+      routingDomain:
+        typeof resource.modalAppId === 'string' && resource.modalAppId.trim()
+          ? resource.modalAppId.trim()
+          : null,
+    };
+  }
+  return null;
+}
+
+export function runtimeSandboxRefFromSuspension(
+  suspension: DetachedRunnerSuspension,
+): RuntimeSandboxRef {
+  const storedRef = (suspension as { runtimeSandboxRef?: unknown })
+    .runtimeSandboxRef;
+  if (storedRef !== undefined) {
+    if (
+      !storedRef ||
+      typeof storedRef !== 'object' ||
+      Array.isArray(storedRef)
+    ) {
+      throw new Error('Persisted Runtime Sandbox Ref is not an object.');
+    }
+    const candidate = storedRef as Record<string, unknown>;
+    const resourceId =
+      typeof candidate.resourceId === 'string'
+        ? candidate.resourceId.trim()
+        : '';
+    const provider = candidate.provider;
+    const routingDomain = candidate.routingDomain;
+    if (
+      candidate.schemaVersion !== 1 ||
+      (provider !== 'daytona' && provider !== 'modal') ||
+      !resourceId ||
+      resourceId !== suspension.sandboxId.trim() ||
+      (routingDomain !== null && typeof routingDomain !== 'string') ||
+      (typeof routingDomain === 'string' && !routingDomain.trim()) ||
+      (suspension.sandboxProvider !== undefined &&
+        suspension.sandboxProvider !== provider)
+    ) {
+      throw new Error(
+        `Persisted Runtime Sandbox Ref is invalid or inconsistent for sandbox ${suspension.sandboxId}.`,
+      );
+    }
+    return {
+      schemaVersion: 1,
+      provider,
+      resourceId,
+      routingDomain:
+        typeof routingDomain === 'string' ? routingDomain.trim() : null,
+    };
+  }
+  if (
+    suspension.sandboxProvider !== undefined &&
+    suspension.sandboxProvider !== 'daytona' &&
+    suspension.sandboxProvider !== 'modal'
+  ) {
+    throw new Error(
+      `Legacy detached runner has unsupported sandbox provider ${String(suspension.sandboxProvider)}.`,
+    );
+  }
+  return {
+    schemaVersion: 1,
+    provider: suspension.sandboxProvider === 'modal' ? 'modal' : 'daytona',
+    resourceId: suspension.sandboxId,
+    // Legacy suspensions never persisted ownership. Cleanup still uses the
+    // provider-scoped credential; resource-backed cleanup carries the domain.
+    routingDomain: null,
+  };
+}
+
+export const defaultRuntimeSandboxReconciliation =
+  createRuntimeSandboxReconciliation({
+    adapters: [
+      {
+        provider: 'daytona',
+        delete: async (ref) => {
+          const outcome = await deleteDaytonaSandboxByIdWithOutcome({
+            sandboxId: ref.resourceId,
+            timeoutSeconds: 30,
+            expectedOrganizationId: ref.routingDomain,
+            allowUnscopedAlreadyAbsent: ref.routingDomain === null,
+          });
+          return {
+            ...outcome,
+            routingDomain: outcome.organizationId,
+          };
+        },
+        readWorkCompletedAt: (ref, path) =>
+          readDetachedDaytonaRuntimeCompletion({
+            sandboxId: ref.resourceId,
+            runtimeCompletedPath: path,
+            expectedOrganizationId: ref.routingDomain,
+          }),
+      },
+      {
+        provider: 'modal',
+        delete: async (ref) => {
+          const outcome = await deleteModalSandboxById({
+            sandboxId: ref.resourceId,
+            expectedAppId: ref.routingDomain,
+          });
+          return {
+            ...outcome,
+            routingDomain: outcome.appId,
+          };
+        },
+        readWorkCompletedAt: (ref, path) =>
+          readDetachedModalRuntimeCompletion({
+            sandboxId: ref.resourceId,
+            runtimeCompletedPath: path,
+            expectedAppId: ref.routingDomain,
+          }),
+      },
+    ],
+  });

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. */

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;