deepline 0.3.472 → 0.3.474

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

@@ -18,10 +18,11 @@ import {
   PLAY_RUNNER_TERMINAL_GRACE_SECONDS,
 } from '../../runtime-constants';
 import {
-  MODAL_SANDBOX_CPU_CORES,
-  MODAL_SANDBOX_MEMORY_MIB,
+  modalSandboxResourcesForPlay,
   loadModalClientConfig,
   loadModalRequiredConfig,
+  resolveModalSandboxMemoryPolicy,
+  isModalPreviewEvaluation,
   withModalCallSignal,
 } from '../../modal-runtime-config';
 import type { PlaySandboxRuntimeLimits } from '../../../plays/sandbox-runtime-limits';
@@ -371,10 +372,33 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
         runtimeSchedulerSchema: config.context.runtimeSchedulerSchema,
         limits: config.context.sandboxRuntimeLimits,
       });
+      const resources = modalSandboxResourcesForPlay(modalConfig.limits);
+      const memoryPolicy = resolveModalSandboxMemoryPolicy({
+        limits: modalConfig.limits,
+        runtimeSchedulerSchema: config.context.runtimeSchedulerSchema,
+      });
       const app = await modalConfig.client.apps.fromName(modalConfig.appName, {
         createIfMissing: true,
       });
-      const image = modalConfig.client.images.fromRegistry(modalConfig.image);
+      const baseImage = modalConfig.client.images.fromRegistry(
+        modalConfig.image,
+      );
+      // Modal caches this immutable layer by its build commands. Build before
+      // sandbox admission so a cold Python image owns no sandbox-capacity lease
+      // or ambiguous SandboxCreate intent. Production keeps its existing image.
+      const image = isModalPreviewEvaluation({
+        runtimeSchedulerSchema: config.context.runtimeSchedulerSchema,
+      })
+        ? await withModalCallSignal(
+            AbortSignal.timeout(MODAL_SANDBOX_CREATE_TIMEOUT_MS),
+            () =>
+              baseImage
+                .dockerfileCommands([
+                  'RUN apt-get update && apt-get install -y --no-install-recommends python3 python-is-python3 && rm -rf /var/lib/apt/lists/*',
+                ])
+                .build(app),
+          )
+        : baseImage;
       const capacityReservation =
         await callbacks?.reserveSandboxCapacity?.('modal');
       const createTags = {
@@ -428,10 +452,10 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
         createSent = true;
         sandbox = await awaitModalSandboxCreate({
           create: modalConfig.client.sandboxes.create(app, image, {
-            cpu: MODAL_SANDBOX_CPU_CORES,
-            cpuLimit: MODAL_SANDBOX_CPU_CORES,
-            memoryMiB: MODAL_SANDBOX_MEMORY_MIB,
-            memoryLimitMiB: MODAL_SANDBOX_MEMORY_MIB,
+            cpu: resources.physicalCpuCores,
+            cpuLimit: resources.physicalCpuCores,
+            memoryMiB: memoryPolicy.reservationMemoryMiB,
+            memoryLimitMiB: memoryPolicy.memoryLimitMiB,
             timeoutMs: modalSandboxLifetimeMs(modalConfig.limits),
             idleTimeoutMs: modalSandboxLifetimeMs(modalConfig.limits),
             workdir: modalConfig.workdir,
@@ -473,8 +497,12 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
                 maxBillingDurationSeconds:
                   modalConfig.limits.timeoutSeconds +
                   PLAY_RUNNER_TERMINAL_GRACE_SECONDS,
-                cpu: MODAL_SANDBOX_CPU_CORES,
-                memoryGiB: MODAL_SANDBOX_MEMORY_MIB / 1024,
+                cpu: resources.physicalCpuCores,
+                memoryGiB: modalConfig.limits.memoryGiB,
+                ...(memoryPolicy.memoryLimitMiB >
+                memoryPolicy.reservationMemoryMiB
+                  ? { memoryLimitGiB: memoryPolicy.memoryLimitMiB / 1024 }
+                  : {}),
                 diskGiB: 0,
                 ...(capacityReservation
                   ? { sandboxCapacityLeaseId: capacityReservation.leaseId }
@@ -587,8 +615,11 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
             maxBillingDurationSeconds:
               modalConfig.limits.timeoutSeconds +
               PLAY_RUNNER_TERMINAL_GRACE_SECONDS,
-            cpu: MODAL_SANDBOX_CPU_CORES,
-            memoryGiB: MODAL_SANDBOX_MEMORY_MIB / 1024,
+            cpu: resources.physicalCpuCores,
+            memoryGiB: modalConfig.limits.memoryGiB,
+            ...(memoryPolicy.memoryLimitMiB > memoryPolicy.reservationMemoryMiB
+              ? { memoryLimitGiB: memoryPolicy.memoryLimitMiB / 1024 }
+              : {}),
             diskGiB: 0,
             ...(capacityReservation
               ? { sandboxCapacityLeaseId: capacityReservation.leaseId }
@@ -654,6 +685,9 @@ export const modalPlayRunnerBackend: PlayRunnerBackend = {
             },
             bundlePromise: buildPlayRunnerBundle(),
             config: withRunnerSandboxProvider(config, 'modal'),
+            ...(memoryPolicy.memoryLimitMiB > memoryPolicy.reservationMemoryMiB
+              ? { memoryLimitMiB: memoryPolicy.memoryLimitMiB }
+              : {}),
             workDir: modalConfig.workdir,
             startedAt,
             emitStage: (stage, extra) =>
@@ -972,9 +1006,7 @@ export async function inspectDetachedModalRunner(input: {
   const deadline = new AbortController();
   const timer = setTimeout(() => {
     deadline.abort(
-      new Error(
-        `Modal detached-runner inspection exceeded ${timeoutMs}ms.`,
-      ),
+      new Error(`Modal detached-runner inspection exceeded ${timeoutMs}ms.`),
     );
   }, timeoutMs);
   try {

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

@@ -41,6 +41,8 @@ export type PlayRunnerRuntimeResource = {
   terminalAt?: number | null;
   cpu?: number | null;
   memoryGiB?: number | null;
+  /** Optional Modal burst ceiling; absence retains the fixed reservation. */
+  memoryLimitGiB?: number | null;
   diskGiB?: number | null;
   /** Scheduler-only soft-capacity reservation made before provider create. */
   sandboxCapacityLeaseId?: string;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-incident-drills.ts

@@ -362,16 +362,20 @@ export const RUNTIME_INCIDENT_DRILL_CATALOG: readonly RuntimeIncidentDrill[] = [
     topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
     control: {
       kind: 'runtime_test_fault',
-      // The 120-second lease plus 80 seconds of confirmation puts the first
-      // provider read at about 200 seconds. The rest absorbs late wakes, so
-      // that read lands inside the silence and not after it.
-      defaultValue: 300_000,
+      // The 120-second lease plus 80 seconds of on-time confirmation is the
+      // earliest provider read. Preview woke late enough to exhaust 300
+      // seconds of silence before that read. Keep the synthetic runner quiet
+      // for seven minutes without changing the worker's liveness policy.
+      defaultValue: 420_000,
       valueMeaning: 'milliseconds',
     },
     expected: {
       outcome:
         'The worker asks the provider once the lease and confirmation pass, the sandbox is not proven gone, and the same attempt finishes after heartbeats return.',
-      safetyFacts: ['same_logical_run', 'no_loss_verdict_without_provider_proof'],
+      safetyFacts: [
+        'same_logical_run',
+        'no_loss_verdict_without_provider_proof',
+      ],
     },
     verification: {
       kind: 'preview_black_box',

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

@@ -23,6 +23,7 @@ export function resolveRuntimeSandboxComputeItems(input: {
       endedAt: number | null;
       physicalCpuCores: number | null;
       memoryGiB: number | null;
+      memoryLimitGiB: number | null;
       maxBillingDurationSeconds: number | null;
     }
   >();
@@ -52,6 +53,10 @@ export function resolveRuntimeSandboxComputeItems(input: {
         finiteNonNegative(value.cpu) ?? existing?.physicalCpuCores ?? null,
       memoryGiB:
         finiteNonNegative(value.memoryGiB) ?? existing?.memoryGiB ?? null,
+      memoryLimitGiB:
+        finiteNonNegative(value.memoryLimitGiB) ??
+        existing?.memoryLimitGiB ??
+        null,
       maxBillingDurationSeconds:
         finiteNonNegative(value.maxBillingDurationSeconds) ??
         existing?.maxBillingDurationSeconds ??
@@ -77,6 +82,9 @@ export function resolveRuntimeSandboxComputeItems(input: {
         wallTimeSeconds: Math.max(0, endedAt - resource.startedAt) / 1_000,
         physicalCpuCores: resource.physicalCpuCores ?? 0.5,
         memoryGiB: resource.memoryGiB ?? 1,
+        ...(resource.memoryLimitGiB === null
+          ? {}
+          : { memoryLimitGiB: resource.memoryLimitGiB }),
         sandboxId,
         startedAt: resource.startedAt,
         endedAt,

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

@@ -204,6 +204,8 @@ export type SandboxExecutionResource = SandboxRunResource & {
   billingEndedAtMs?: number | null;
   cpu?: number | null;
   memoryGiB?: number | null;
+  /** Optional provider burst ceiling, distinct from the reserved memory. */
+  memoryLimitGiB?: number | null;
   diskGiB?: number | null;
   /** A create settled after the launching attempt had already timed out. */
   lateAcquired?: boolean;

package/dist/bundling-sources/shared_libs/play-runtime/sandbox-runs/runner-backend-adapter.ts

@@ -254,6 +254,7 @@ function toSandboxResource(
     maxBillingDurationSeconds: resource.maxBillingDurationSeconds ?? null,
     cpu: resource.cpu ?? null,
     memoryGiB: resource.memoryGiB ?? null,
+    memoryLimitGiB: resource.memoryLimitGiB ?? null,
     diskGiB: resource.diskGiB ?? null,
     // Historical Daytona facts use `daytonaEnvironment`; normalize it at the
     // portable boundary so the cleanup job stays in the resource's actual
@@ -295,6 +296,7 @@ export function playRunnerRuntimeResourceFromSandboxExecutionResource(
     maxBillingDurationSeconds: resource.maxBillingDurationSeconds ?? null,
     cpu: resource.cpu ?? null,
     memoryGiB: resource.memoryGiB ?? null,
+    memoryLimitGiB: resource.memoryLimitGiB ?? null,
     diskGiB: resource.diskGiB ?? null,
     ...(resource.capacityLeaseId
       ? { sandboxCapacityLeaseId: resource.capacityLeaseId }

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

@@ -24428,7 +24428,11 @@ async function acknowledgeRunLedgerPrefixWithContinuation(
           waitForRunLock: true,
         },
         options,
-        { eventIds, targetEventId },
+        {
+          eventIds,
+          targetEventId,
+          createdProjectionWake: input.createdProjectionWake,
+        },
       );
       if (fast !== null) {
         let continuation: RunLedgerOutboxDrainScope | null = null;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/run-ledger-outbox-recovery.ts

@@ -938,6 +938,12 @@ export function startRunLedgerOutboxRecovery(
  * together for projection.
  */
 export const RUN_CREATED_INLINE_DELIVERY_DEADLINE_MS = 1_500;
+/**
+ * A response-owned background attempt can finish a cold projection without
+ * holding admission open. Keep its deadline plus release grace below the
+ * existing five-second delivery lease; foreground callers retain 1.5 seconds.
+ */
+export const RUN_CREATED_BACKGROUND_DELIVERY_DEADLINE_MS = 4_000;
 /**
  * How long an abandoned inline attempt may keep its caller while it gives the
  * lease back. The caller is the only owner of that release: a serverless
@@ -1016,7 +1022,8 @@ function inlineAttemptErrorClass(error: unknown): string {
  * Never throws and never exceeds `deadlineMs` plus the release grace. A
  * deadline abandons the append and releases its lease without charging a
  * retry, and that release completes before this returns whenever it fits the
- * grace: nothing else keeps the admitting invocation alive for it.
+ * grace. Background callers own the returned promise through their response
+ * lifecycle; foreground callers retain the shorter inline deadline.
  */
 export async function deliverRunCreatedOutboxEventInline(input: {
   runId: string;
@@ -1024,6 +1031,8 @@ export async function deliverRunCreatedOutboxEventInline(input: {
   schedulerOptions?: Pick<PostgresSchedulerOptions, 'schema'>;
   tokenAuthority: RunLedgerOutboxTokenAuthority;
   appRuntimeFetch?: typeof fetch;
+  /** The caller owns this attempt through its after-response lifecycle. */
+  background?: boolean;
   deadlineMs?: number;
   /** Test seam; clamped to `RUN_CREATED_INLINE_RELEASE_GRACE_MS`. */
   releaseGraceMs?: number;
@@ -1032,12 +1041,12 @@ export async function deliverRunCreatedOutboxEventInline(input: {
   const now = input.now ?? Date.now;
   const startedAt = now();
   const elapsed = () => Math.max(0, now() - startedAt);
+  const maximumDeadlineMs = input.background
+    ? RUN_CREATED_BACKGROUND_DELIVERY_DEADLINE_MS
+    : RUN_CREATED_INLINE_DELIVERY_DEADLINE_MS;
   const deadlineMs = Math.max(
     1,
-    Math.min(
-      RUN_CREATED_INLINE_DELIVERY_DEADLINE_MS,
-      input.deadlineMs ?? RUN_CREATED_INLINE_DELIVERY_DEADLINE_MS,
-    ),
+    Math.min(maximumDeadlineMs, input.deadlineMs ?? maximumDeadlineMs),
   );
   const releaseGraceMs = Math.max(
     1,

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

@@ -1,6 +1,7 @@
 import type { PlayDocflowNodeIoState } from './docflow-node-io';
 import type { PlayMapRowActivitySource } from './run-ledger';
 import type { PlayConditionCounts } from './cell-provenance';
+import { PLAY_SANDBOX_SIZE_LIMITS } from '../plays/sandbox-runtime-limits';
 
 export type PlayStagedFileRef = {
   storageKind: 'r2';
@@ -69,6 +70,17 @@ export const MODAL_SANDBOX_COMPUTE_PRICING_USD = {
 // Convex billing can use it without importing Modal's Node runtime config.
 export const MODAL_SANDBOX_CPU_CORES = 0.5;
 
+/** Scale Modal's physical-core request from Deepline's standard one-vCPU unit. */
+export function modalSandboxResourcesForPlay(input: {
+  cpu: number;
+  memoryGiB: number;
+}) {
+  return {
+    physicalCpuCores: MODAL_SANDBOX_CPU_CORES * input.cpu,
+    memoryMiB: input.memoryGiB * 1024,
+  };
+}
+
 const NEON_COMPUTE_PRICING_USD = {
   cuHour: 0.106,
   defaultCu: 1,
@@ -78,6 +90,14 @@ function roundUsd(amount: number): number {
   return Number(Math.max(0, amount).toFixed(12));
 }
 
+/** Portable billing identity derived from the resources actually acquired. */
+function sandboxSizeMetadata(cpu: number, memoryGiB: number) {
+  const entry = Object.entries(PLAY_SANDBOX_SIZE_LIMITS).find(
+    ([, limits]) => limits.cpu === cpu && limits.memoryGiB === memoryGiB,
+  );
+  return entry ? { sandboxSize: entry[0] } : {};
+}
+
 export function resolveDaytonaSandboxComputeItem(input: {
   itemId: string;
   source?: string;
@@ -110,6 +130,7 @@ export function resolveDaytonaSandboxComputeItem(input: {
     units: billableSeconds,
     providerCostUsd,
     metadata: {
+      ...sandboxSizeMetadata(cpu, memoryGiB),
       sandboxId: input.sandboxId ?? null,
       cpu,
       memoryGiB,
@@ -126,6 +147,8 @@ export function resolveModalSandboxComputeItem(input: {
   wallTimeSeconds: number;
   physicalCpuCores: number;
   memoryGiB: number;
+  /** Bounded burst allocation; absent on fixed-resource historical items. */
+  memoryLimitGiB?: number;
   sandboxId?: string | null;
   startedAt?: number;
   endedAt?: number;
@@ -145,9 +168,22 @@ export function resolveModalSandboxComputeItem(input: {
     units: billableSeconds,
     providerCostUsd,
     metadata: {
+      ...sandboxSizeMetadata(
+        physicalCpuCores / MODAL_SANDBOX_CPU_CORES,
+        memoryGiB,
+      ),
       sandboxId: input.sandboxId ?? null,
       physicalCpuCores,
       memoryGiB,
+      ...(input.memoryLimitGiB === undefined
+        ? {}
+        : {
+            memoryLimitGiB: input.memoryLimitGiB,
+            // The Preview evaluation preserves the existing compute price.
+            // Sampled burst cost is diagnostic until provider billing can be
+            // reconciled; a hard ceiling is never presented as actual usage.
+            costBasis: 'reserved_resources',
+          }),
       startedAt: input.startedAt,
       endedAt: input.endedAt,
     },

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -3,7 +3,10 @@ export type { BillingEntitlements } from '../integration-contracts/billing-entit
 import { Type, type Static, type TSchema } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
 import type { PreviousCell } from './cell-staleness';
-import type { PlaySandboxRuntimeLimits } from './sandbox-runtime-limits';
+import type {
+  PlaySandboxRuntimeLimits,
+  PlaySandboxSize,
+} from './sandbox-runtime-limits';
 import type {
   BasicToolExecuteResult,
   ToolExecuteResult,
@@ -207,6 +210,7 @@ export const PLAY_AUTHORING_CONTRACT_ISSUE_CODES = [
   'play_authoring_row_sleep_unsupported',
   'play_authoring_hitl_retry_loop_unsafe',
   'play_authoring_binding_invalid',
+  'play_runtime_size_preview_only',
   'play_authoring_input_schema_unresolved',
   'tool_response_raw_access',
   'check_error',
@@ -863,7 +867,7 @@ export type PlayAuthoringBindings<TInput = Record<string, unknown>> = {
    */
   runtime?: {
     timeout?: string;
-    size?: 'standard';
+    size?: PlaySandboxSize;
   };
   /**
    * Start at most one run of this Play per window, whatever started it.
@@ -2967,20 +2971,26 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
       'rateLimit.every must be a static duration from "10s" to "24h", such as "5m".',
   },
   'runtime.size': {
-    schema: Type.Literal('standard'),
+    schema: Type.Union([
+      Type.Literal('standard'),
+      Type.Literal('large'),
+      Type.Literal('xlarge'),
+    ]),
     fixtures: {
-      valid: 'standard',
-      invalid: 'large',
+      valid: 'large',
+      invalid: 'xxlarge',
       absent: undefined,
       unresolved: { expression: 'size' },
       edition1: 'standard',
     },
-    referenceType: "'standard'",
+    referenceType: "'standard' | 'large' | 'xlarge'",
     required: false,
     resolution: 'static-required',
     issueCode: 'play_authoring_binding_invalid',
-    description: 'Deepline-managed sandbox size. Only standard is supported.',
-    errorMessage: 'runtime.size must be the static literal "standard".',
+    description:
+      'Deepline-managed sandbox size. Standard is 1 GiB memory. Large (4 GiB) and xlarge (8 GiB) are available only on branch Preview deployments. Production supports standard.',
+    errorMessage:
+      'runtime.size must be the static literal "standard", "large", or "xlarge".',
   },
   'ctx.customerDb.query.statement': {
     schema: Type.Union([

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -1125,7 +1125,7 @@ function sandboxRuntimeDeclarationFromOptions(
   if (unsupportedProperties.length > 0) {
     throw new Error(
       `Unsupported runtime sandbox option${unsupportedProperties.length === 1 ? '' : 's'} "${unsupportedProperties.join('", "')}". ` +
-        'Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard".',
+        'Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard", "large", or "xlarge".',
     );
   }
   const timeout = resolveStaticProperty(runtime.value, 'timeout', context);

package/dist/bundling-sources/shared_libs/plays/sandbox-runtime-limits.ts

@@ -5,7 +5,7 @@ export type PlaySandboxRuntimeLimits = {
   diskGiB: number;
 };
 
-export type PlaySandboxSize = 'standard';
+export type PlaySandboxSize = 'standard' | 'large' | 'xlarge';
 
 export const PLAY_SANDBOX_SIZE_LIMITS = {
   standard: {
@@ -13,6 +13,16 @@ export const PLAY_SANDBOX_SIZE_LIMITS = {
     cpu: 1,
     diskGiB: 3,
   },
+  large: {
+    memoryGiB: 4,
+    cpu: 2,
+    diskGiB: 8,
+  },
+  xlarge: {
+    memoryGiB: 8,
+    cpu: 4,
+    diskGiB: 10,
+  },
 } as const satisfies Record<
   PlaySandboxSize,
   Omit<PlaySandboxRuntimeLimits, 'timeoutSeconds'>
@@ -27,11 +37,50 @@ export const STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
 // customer-authored Play can never ask Daytona for an unbounded resource.
 export const MAX_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
   timeoutSeconds: 4 * 60 * 60,
-  memoryGiB: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.memoryGiB,
-  cpu: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.cpu,
-  diskGiB: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.diskGiB,
+  ...PLAY_SANDBOX_SIZE_LIMITS.xlarge,
 };
 
+/** Bounded Modal burst headroom; resource reservation remains the chosen profile. */
+export function modalSandboxMemoryLimitGiBForPlay(
+  input: Pick<PlaySandboxRuntimeLimits, 'memoryGiB'>,
+): number {
+  if (
+    !Object.values(PLAY_SANDBOX_SIZE_LIMITS).some(
+      (profile) => profile.memoryGiB === input.memoryGiB,
+    )
+  ) {
+    throw new Error(
+      `Unsupported Modal memory reservation: ${input.memoryGiB} GiB.`,
+    );
+  }
+  return Math.min(
+    Math.max(4, input.memoryGiB * 2),
+    MAX_PLAY_SANDBOX_RUNTIME_LIMITS.memoryGiB,
+  );
+}
+
+export function playSandboxSizeForLimits(
+  limits: Pick<PlaySandboxRuntimeLimits, 'memoryGiB' | 'cpu' | 'diskGiB'>,
+): PlaySandboxSize | null {
+  return (
+    (
+      Object.entries(PLAY_SANDBOX_SIZE_LIMITS) as [
+        PlaySandboxSize,
+        (typeof PLAY_SANDBOX_SIZE_LIMITS)[PlaySandboxSize],
+      ][]
+    ).find(
+      ([, profile]) =>
+        profile.memoryGiB === limits.memoryGiB &&
+        profile.cpu === limits.cpu &&
+        profile.diskGiB === limits.diskGiB,
+    )?.[0] ?? null
+  );
+}
+
+const supportedPlaySandboxSizes = Object.keys(PLAY_SANDBOX_SIZE_LIMITS).join(
+  ', ',
+);
+
 export type PlaySandboxRuntimeDeclaration = {
   timeout?: string;
   size?: PlaySandboxSize;
@@ -48,15 +97,11 @@ function parseTimeout(value: string): number | null {
 export function validatePlaySandboxRuntimeLimits(
   value: PlaySandboxRuntimeLimits,
 ): PlaySandboxRuntimeLimits {
-  const base = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS;
-  for (const key of ['memoryGiB', 'cpu', 'diskGiB'] as const) {
-    if (value[key] !== base[key]) {
-      throw new Error(
-        `Unsupported runtime sandbox resources: ${key}=${value[key]}. ` +
-          `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard" ` +
-          `(${base.cpu} CPU, ${base.memoryGiB}GiB memory, ${base.diskGiB}GiB disk).`,
-      );
-    }
+  if (!playSandboxSizeForLimits(value)) {
+    throw new Error(
+      `Unsupported runtime sandbox resources: cpu=${value.cpu} memoryGiB=${value.memoryGiB} diskGiB=${value.diskGiB}. ` +
+        `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: ${supportedPlaySandboxSizes}.`,
+    );
   }
   if (
     !Number.isSafeInteger(value.timeoutSeconds) ||
@@ -85,12 +130,15 @@ export function resolvePlaySandboxRuntimeLimits(
   if (unsupportedProperties.length > 0) {
     throw new Error(
       `Unsupported runtime sandbox option${unsupportedProperties.length === 1 ? '' : 's'}: ${unsupportedProperties.join(', ')}. ` +
-        'Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard".',
+        `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: ${supportedPlaySandboxSizes}.`,
     );
   }
-  if (declaration.size !== undefined && declaration.size !== 'standard') {
+  if (
+    declaration.size !== undefined &&
+    !Object.hasOwn(PLAY_SANDBOX_SIZE_LIMITS, declaration.size)
+  ) {
     throw new Error(
-      `Unsupported runtime sandbox size "${String(declaration.size)}". Supported sizes: "standard".`,
+      `Unsupported runtime sandbox size "${String(declaration.size)}". Supported sizes: ${supportedPlaySandboxSizes}.`,
     );
   }
   const timeoutSeconds = declaration.timeout

package/dist/bundling-sources/shared_libs/plays/tool-result-types.ts

@@ -413,7 +413,7 @@ export type ToolExecuteResultAccessors<
  * incomplete lists throw: use readList(result, path) for explicit dataset access.
  * Provider pagination requires a separate request; getters never fetch it.
  * Historical editions 1–9 retain PlayDataset getters and async materialize/peek;
- * missing getters never mean empty results. Inspect rawV2 for debugging: parsed,
+ * missing getters never mean empty results. Inspect toolResponse.rawV2 for debugging: parsed,
  * scrubbed envelopes, pagination and siblings, not HTTP bytes or headers.
  *
  * @sdkReference runtime 200

package/dist/bundling-sources/shared_libs/product-notifications/billing-sales.ts

@@ -21,6 +21,14 @@ export function isBillingSalesGroupKey(key: unknown): boolean {
   );
 }
 
+export const BILLING_ALERTS_SLACK_CHANNEL_ID = 'C0CEBRS6PHS';
+export const BILLING_USAGE_GROUP_KEY = 'shadow.billing-usage';
+export const BILLING_USAGE_DESTINATION_KEY = 'shadow.billing-usage.slack';
+export function isPlatformBillingDestination(key: unknown): boolean {
+  return (
+    key === BILLING_USAGE_DESTINATION_KEY || isBillingSalesDestinationKey(key)
+  );
+}
 export const BILLING_SALES_GROUP_KEY = 'shadow.billing-sales';
 export const BILLING_SALES_DESTINATION_KEY = 'shadow.billing-sales.slack';
 export const BILLING_SALES_SLACK_CHANNEL_ID = 'C0AGWVD2TNK';
@@ -33,13 +41,18 @@ export const BILLING_DELIVERY_LATE_RULE_KEYS: readonly string[] = [
   BILLING_RENEWAL_LATE_RULE_KEY,
 ];
 export const BILLING_SALES_RULE_KEYS: readonly string[] = [
+  'internal.billing.usage_charge',
   'internal.billing.credit_purchase',
   'internal.billing.paid_plan',
   ...BILLING_DELIVERY_LATE_RULE_KEYS,
 ];
 
 export function isPlatformNotificationGroup(groupKey: string): boolean {
-  return groupKey === 'shadow' || isBillingSalesGroupKey(groupKey);
+  return (
+    groupKey === 'shadow' ||
+    isBillingSalesGroupKey(groupKey) ||
+    groupKey === BILLING_USAGE_GROUP_KEY
+  );
 }
 
 /** Permit only the code-owned purchase-rule move while old deliveries drain. */

package/dist/bundling-sources/shared_libs/product-notifications/catalog.ts

@@ -20,6 +20,7 @@ import {
   BILLING_SALES_CREDIT_PURCHASE_MINIMUM_CENTS,
   BILLING_CREDIT_PURCHASE_GROUP_KEY,
   BILLING_SALES_GROUP_KEY,
+  BILLING_USAGE_GROUP_KEY,
 } from './billing-sales';
 
 export const DEFAULT_PLAY_FAILURE_SETTINGS = {
@@ -995,6 +996,45 @@ const PRODUCT_NOTIFICATION_TYPE_REGISTRY = [
       }),
     },
   },
+  {
+    id: 'internal.billing.usage_charge',
+    eventName: ProductNotificationEvent.BillingUsageChargeObserved,
+    requiredFilter: {},
+    allowedTriggers: ['each_match'],
+    catalog: undefined,
+    shadow: true,
+    rule: {
+      default: {
+        ruleKey: 'internal.billing.usage_charge',
+        groupKey: BILLING_USAGE_GROUP_KEY,
+      },
+      create: (_input, base) => ({
+        ...base,
+        repeatMode: 'every_match',
+        trigger: { kind: 'each_match' },
+      }),
+      present: ({ payload }) => ({
+        title: payload.paging
+          ? 'Large individual usage charge'
+          : 'Individual usage charge over $10',
+        summary: [
+          { workspace: true },
+          ` charged ${payload.amount} for ${payload.tool}.`,
+        ],
+        details: [
+          `Tool: ${payload.tool}`,
+          `Charge record time (UTC): ${payload.chargeTime}`,
+          `Charge: ${payload.chargeId}`,
+          `Paging threshold: ${payload.threshold}`,
+          'Investigate settlement and performed work. For verified legitimate large batches, raise monitoring.largeUsageChargeThresholds for this exact tool in its provider registry and publish the catalog. Keep over-$10 messages enabled. Runbook: https://github.com/getaero-io/deepline-api/blob/main/docs/billing-observability.md#individual-charge-slack-messages-and-response',
+        ],
+        targetUrl: String(payload.targetUrl),
+        subjectKind: 'usage_charge',
+        subjectId: String(payload.chargeId),
+        ...(payload.paging ? { severity: 'error' as const } : {}),
+      }),
+    },
+  },
   lateCreditDeliveryRegistration(
     BILLING_PURCHASE_LATE_RULE_KEY,
     ProductNotificationEvent.BillingPurchaseLate,