deepline 0.3.460 → 0.3.462

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

@@ -76,6 +76,7 @@ function schemaTables(options?: Pick<PostgresSchedulerOptions, 'schema'>) {
     operations: `${schema}."runtime_sandbox_operations"`,
     cleanup: `${schema}."sandbox_cleanup_jobs_v2"`,
     runs: `${schema}."runs"`,
+    attempts: `${schema}."attempts"`,
   };
 }
 
@@ -286,6 +287,7 @@ export async function reserveRuntimeSandboxCapacityLease(
       activeLeases: number;
       wouldDefer: boolean;
       resumeExistingProviderOperation: boolean;
+      resumePendingDelete?: boolean;
       /**
        * Database-clock age of a resumed operation. Absent on a same-key race and
        * once the lease expires, when a new sandbox could no longer be promoted.
@@ -296,7 +298,8 @@ export async function reserveRuntimeSandboxCapacityLease(
 > {
   const orgId = assertId(input.orgId, 'orgId');
   const runId = assertId(input.runId, 'runId');
-  const { cache, leases, operations, runs } = schemaTables(options);
+  const { cache, leases, operations, runs, attempts, cleanup } =
+    schemaTables(options);
   const leaseId = input.leaseId?.trim() || randomUUID();
   const unsentProviderOperationToken = unsentReservationInputs.get(input);
   const providerOperationToken =
@@ -321,6 +324,9 @@ export async function reserveRuntimeSandboxCapacityLease(
       provider_operation_token: string | null;
       attempt: number;
       environment: 'preview' | 'production';
+      operation_state: RuntimeSandboxOperationState;
+      sandbox_id: string | null;
+      routing_domain: string | null;
       age_ms: number | null;
     }>;
     existing_operation: {
@@ -368,6 +374,8 @@ export async function reserveRuntimeSandboxCapacityLease(
           FROM (
             SELECT lease.lease_id, operation.provider_operation_token,
                    operation.attempt, operation.environment,
+                   operation.state AS operation_state,
+                   operation.sandbox_id, operation.routing_domain,
                    CASE WHEN lease.expires_at > clock_timestamp() THEN
                      extract(epoch FROM clock_timestamp() - operation.created_at) * 1000
                    END AS age_ms
@@ -377,9 +385,44 @@ export async function reserveRuntimeSandboxCapacityLease(
               AND operation.org_id = $1
               AND operation.run_id = $3
               AND operation.provider = $4
-              AND operation.state = $7
+              AND (
+                (operation.state = $7 AND lease.sandbox_id IS NULL)
+                OR (
+                  operation.state = 'deleting'
+                  AND operation.sandbox_id IS NOT NULL
+                  AND lease.sandbox_id = operation.sandbox_id
+                  AND lease.routing_domain IS NOT DISTINCT FROM operation.routing_domain
+                  AND EXISTS (
+                    SELECT 1
+                    FROM ${attempts} AS owner_attempt
+                    CROSS JOIN LATERAL jsonb_array_elements(
+                      CASE
+                        WHEN jsonb_typeof(owner_attempt.resource_json) = 'array'
+                          THEN owner_attempt.resource_json
+                        WHEN owner_attempt.resource_json IS NULL THEN '[]'::jsonb
+                        ELSE jsonb_build_array(owner_attempt.resource_json)
+                      END
+                    ) AS resource
+                    WHERE owner_attempt.run_id = operation.run_id
+                      AND owner_attempt.attempt = operation.attempt
+                      AND resource->>'sandboxCapacityLeaseId' = operation.operation_key
+                      AND resource->>'sandboxId' = operation.sandbox_id
+                      AND resource->>'lateAcquired' = 'true'
+                      AND (
+                        resource->'billingEndedAt' IS NULL
+                        OR resource->'billingEndedAt' = 'null'::jsonb
+                      )
+                  )
+                  AND EXISTS (
+                    SELECT 1 FROM ${cleanup} AS cleanup_job
+                    WHERE cleanup_job.provider = operation.provider
+                      AND cleanup_job.sandbox_id = operation.sandbox_id
+                      AND cleanup_job.routing_domain IS NOT DISTINCT FROM operation.routing_domain
+                      AND cleanup_job.status <> 'deleted'
+                  )
+                )
+              )
               AND lease.released_at IS NULL
-              AND lease.sandbox_id IS NULL
             ORDER BY operation.created_at ASC
             LIMIT 2
           ) AS pending
@@ -512,9 +555,15 @@ export async function reserveRuntimeSandboxCapacityLease(
         activeLeases,
         wouldDefer,
         resumeExistingProviderOperation: true,
+        ...(pendingOperation.operation_state ===
+        RuntimeSandboxOperationState.Deleting
+          ? { resumePendingDelete: true }
+          : {}),
         ...(pendingOperation.age_ms === null
           ? {}
-          : { existingProviderOperationAgeMs: Number(pendingOperation.age_ms) }),
+          : {
+              existingProviderOperationAgeMs: Number(pendingOperation.age_ms),
+            }),
       };
     }
   }
@@ -887,14 +936,19 @@ export async function releaseRuntimeSandboxCapacityLease(
 export async function abandonRuntimeSandboxOperationReservation(
   client: PostgresSchedulerQueryClient,
   /** With `attempt`, an operation a newer attempt has adopted is left alone. */
-  input: { operationKey: string; attempt?: number },
+  input: {
+    operationKey: string;
+    attempt?: number;
+    /** A lookup 404 must not retire a terminal Run's unresolved creation. */
+    onlyWhileRunActive?: boolean;
+  },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<boolean> {
   const { leases, operations, runs } = schemaTables(options);
   const result = await client.query<{ operation_key: string }>(
     `
       WITH custody_run AS MATERIALIZED (
-        SELECT run_id FROM ${runs}
+        SELECT run_id, status FROM ${runs}
         WHERE run_id = (SELECT run_id FROM ${operations} WHERE operation_key = $1)
         FOR NO KEY UPDATE
       ), custody_attempts AS MATERIALIZED (
@@ -914,6 +968,12 @@ export async function abandonRuntimeSandboxOperationReservation(
           AND operation.state = $3
           AND ($4::integer IS NULL OR operation.attempt <= $4)
           AND EXISTS (SELECT 1 FROM eligible_lease)
+          AND (
+            NOT $5::boolean OR EXISTS (
+              SELECT 1 FROM custody_run
+              WHERE status IN ('queued', 'running', 'waiting')
+            )
+          )
         RETURNING operation.operation_key
       ), released AS (
         UPDATE ${leases} AS lease
@@ -930,11 +990,13 @@ export async function abandonRuntimeSandboxOperationReservation(
       RuntimeSandboxOperationState.Abandoned,
       RuntimeSandboxOperationState.Reserved,
       input.attempt ?? null,
+      input.onlyWhileRunActive ?? false,
     ],
   );
   return result.rows.length === 1;
 }
 
+/** A run's terminal outcome must not strand a create that has not been bound yet. */
 export async function readReservedDaytonaCancellationOperation(
   client: PostgresSchedulerQueryClient,
   environment: 'preview' | 'production',
@@ -942,23 +1004,32 @@ export async function readReservedDaytonaCancellationOperation(
 ): Promise<{
   operationKey: string;
   providerOperationToken: string;
+  orgId: string;
+  runId: string;
   createdAtMs: number;
 } | null> {
-  const { operations } = schemaTables(options);
+  const { operations, runs } = schemaTables(options);
   const schema = quoteIdent(options?.schema ?? 'runtime_scheduler');
   const rows = await client.query<{
     operation_key: string;
     provider_operation_token: string | null;
+    org_id: string;
+    run_id: string;
     created_at_ms: number;
   }>(
     `WITH candidate AS (
        SELECT operation.operation_key
        FROM ${operations} AS operation
-       JOIN ${schema}."control" AS request
+       JOIN ${runs} AS run ON run.run_id = operation.run_id
+       LEFT JOIN ${schema}."control" AS request
          ON request.key = 'runtime_cancel:' || operation.run_id
        WHERE operation.provider = 'daytona'
          AND operation.environment = $1
          AND operation.state = 'reserved'
+         AND (
+           run.status IN ('completed', 'failed', 'cancelled')
+           OR request.key IS NOT NULL
+         )
        ORDER BY operation.updated_at ASC, operation.operation_key ASC
        LIMIT 1
        FOR UPDATE OF operation SKIP LOCKED
@@ -967,7 +1038,8 @@ export async function readReservedDaytonaCancellationOperation(
      SET updated_at = clock_timestamp()
      FROM candidate
      WHERE operation.operation_key = candidate.operation_key
-     RETURNING operation.operation_key, operation.provider_operation_token,
+       RETURNING operation.operation_key, operation.provider_operation_token,
+               operation.org_id, operation.run_id,
                floor(extract(epoch FROM operation.created_at) * 1000)::bigint AS created_at_ms`,
     [environment],
   );
@@ -981,6 +1053,8 @@ export async function readReservedDaytonaCancellationOperation(
   return {
     operationKey: row.operation_key,
     providerOperationToken: row.provider_operation_token,
+    orgId: row.org_id,
+    runId: row.run_id,
     createdAtMs: Number(row.created_at_ms),
   };
 }
@@ -1071,6 +1145,165 @@ export async function recordRecoveredDaytonaCancellationSandbox(
   return recorded.rows.length === 1;
 }
 
+export async function recordDaytonaSandboxCleanupIntent(
+  client: PostgresSchedulerQueryClient,
+  input: {
+    operationKey: string;
+    providerOperationToken: string;
+    orgId: string;
+    runId: string;
+    sandboxId: string;
+    routingDomain: string;
+  },
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<boolean> {
+  const { operations, leases, cleanup } = schemaTables(options);
+  const schema = quoteIdent(options?.schema ?? 'runtime_scheduler');
+  const recorded = await client.query<{ operation_key: string }>(
+    `WITH custody_run AS MATERIALIZED (
+       SELECT run.run_id FROM ${schema}."runs" AS run
+       WHERE run.run_id = $1
+       FOR NO KEY UPDATE
+     ), custody_attempts AS MATERIALIZED (
+       SELECT attempt.* FROM ${schema}."attempts" AS attempt
+       WHERE attempt.run_id IN (SELECT run_id FROM custody_run)
+       ORDER BY attempt.attempt FOR UPDATE
+     ), custody_lease AS MATERIALIZED (
+       SELECT lease.lease_id FROM ${leases} AS lease
+       CROSS JOIN (SELECT count(*) FROM custody_attempts) AS attempt_locks
+       WHERE lease.lease_id = $2 FOR UPDATE OF lease
+     ), custody_operation AS MATERIALIZED (
+       SELECT operation.operation_key FROM ${operations} AS operation
+       CROSS JOIN (SELECT count(*) FROM custody_lease) AS lease_locks
+       WHERE operation.operation_key = $2 FOR UPDATE OF operation
+     ), eligible AS MATERIALIZED (
+       SELECT operation.operation_key, operation.run_id, operation.attempt,
+              operation.environment, operation.created_at
+       FROM ${operations} AS operation
+       JOIN custody_operation
+         ON custody_operation.operation_key = operation.operation_key
+       JOIN custody_lease ON custody_lease.lease_id = operation.operation_key
+       JOIN ${leases} AS lease ON lease.lease_id = operation.operation_key
+       JOIN custody_attempts AS attempt
+         ON attempt.run_id = operation.run_id
+        AND attempt.attempt = operation.attempt
+       WHERE operation.operation_key = $2
+         AND operation.run_id = $1
+         AND operation.org_id = $3
+         AND operation.provider_operation_token = $4
+         AND operation.provider = 'daytona'
+         AND operation.state = 'reserved'
+         AND lease.released_at IS NULL
+         AND lease.sandbox_id IS NULL
+     ), queued AS (
+       INSERT INTO ${cleanup} AS job (
+         provider, sandbox_id, run_id, attempt, environment, routing_domain
+       )
+       SELECT 'daytona', $5, eligible.run_id, eligible.attempt,
+              eligible.environment, $6
+       FROM eligible
+       ON CONFLICT (provider, sandbox_id, routing_domain_key)
+       DO UPDATE SET updated_at = job.updated_at
+       WHERE job.status <> 'deleted'
+         AND job.run_id = EXCLUDED.run_id
+         AND job.attempt = EXCLUDED.attempt
+         AND job.environment = EXCLUDED.environment
+         AND job.routing_domain IS NOT DISTINCT FROM EXCLUDED.routing_domain
+       RETURNING job.provider, job.sandbox_id, job.run_id, job.attempt,
+                 job.environment, job.routing_domain
+     ), promoted AS (
+       UPDATE ${operations} AS operation
+       SET state = 'deleting',
+           sandbox_id = $5,
+           routing_domain = $6,
+           provider_created_at = clock_timestamp(),
+           updated_at = clock_timestamp()
+       FROM eligible
+       JOIN queued ON queued.run_id = eligible.run_id
+                  AND queued.attempt = eligible.attempt
+                  AND queued.environment = eligible.environment
+       WHERE operation.operation_key = eligible.operation_key
+         AND operation.state = 'reserved'
+       RETURNING operation.operation_key, operation.run_id, operation.attempt,
+                 operation.environment, operation.created_at
+     ), resource AS (
+       SELECT promoted.*,
+              jsonb_build_object(
+                'kind', 'daytona_sandbox',
+                'sandboxId', $5::text,
+                'runtimeEnvironment', promoted.environment,
+                'daytonaOrganizationId', $6::text,
+                'billingStartedAt', extract(epoch FROM promoted.created_at) * 1000,
+                'sandboxCapacityLeaseId', promoted.operation_key,
+                'lateAcquired', true
+              ) AS value
+       FROM promoted
+     ), recorded_attempt AS (
+       UPDATE ${schema}."attempts" AS attempt
+       SET resource_json = CASE
+             WHEN attempt.resource_json IS NULL THEN jsonb_build_array(resource.value)
+             WHEN jsonb_typeof(attempt.resource_json) = 'array'
+               THEN attempt.resource_json || jsonb_build_array(resource.value)
+             ELSE jsonb_build_array(attempt.resource_json, resource.value)
+           END,
+           updated_at = clock_timestamp()
+       FROM resource
+       WHERE attempt.run_id = resource.run_id
+         AND attempt.attempt = resource.attempt
+       RETURNING attempt.run_id
+     ), bound AS (
+       UPDATE ${leases} AS lease
+       SET sandbox_id = $5, routing_domain = $6
+       FROM promoted
+       WHERE lease.lease_id = promoted.operation_key
+         AND lease.released_at IS NULL
+       RETURNING lease.lease_id
+     )
+     SELECT promoted.operation_key FROM promoted
+     JOIN recorded_attempt ON recorded_attempt.run_id = promoted.run_id
+     JOIN bound ON bound.lease_id = promoted.operation_key
+     JOIN queued ON queued.provider = 'daytona'
+                 AND queued.sandbox_id = $5
+                 AND queued.run_id = promoted.run_id
+                 AND queued.attempt = promoted.attempt
+                 AND queued.environment = promoted.environment
+                 AND queued.routing_domain IS NOT DISTINCT FROM $6
+     UNION ALL
+     SELECT operation.operation_key
+     FROM ${operations} AS operation
+     JOIN ${leases} AS lease ON lease.lease_id = operation.operation_key
+     JOIN ${cleanup} AS job
+       ON job.provider = operation.provider
+      AND job.sandbox_id = operation.sandbox_id
+      AND job.routing_domain IS NOT DISTINCT FROM operation.routing_domain
+      AND job.run_id = operation.run_id
+      AND job.attempt = operation.attempt
+      AND job.environment = operation.environment
+     WHERE operation.operation_key = $2
+       AND operation.run_id = $1
+       AND operation.org_id = $3
+       AND operation.provider_operation_token = $4
+       AND operation.provider = 'daytona'
+       AND operation.state = 'deleting'
+       AND operation.sandbox_id = $5
+       AND operation.routing_domain IS NOT DISTINCT FROM $6
+       AND lease.sandbox_id = operation.sandbox_id
+       AND lease.routing_domain IS NOT DISTINCT FROM operation.routing_domain
+       AND lease.released_at IS NULL
+       AND job.status <> 'deleted'
+     LIMIT 1`,
+    [
+      input.runId,
+      input.operationKey,
+      input.orgId,
+      input.providerOperationToken,
+      input.sandboxId,
+      input.routingDomain,
+    ],
+  );
+  return recorded.rows.length === 1;
+}
+
 /** Release only after the provider confirms deletion (or already absent). */
 export async function releaseRuntimeSandboxCapacityLeaseForSandbox(
   client: PostgresSchedulerQueryClient,
@@ -1178,3 +1411,138 @@ export async function readRuntimeSandboxCapacitySummaryViaRuntimeScheduler(input
     ),
   );
 }
+
+/** Fixed-size Preview test evidence from the existing capacity/cleanup owners. */
+export type RuntimeSandboxCapacityTestEvidence = {
+  observedAtMs: number;
+  mirror:
+    | null
+    | (Pick<
+        RuntimeOrgSandboxLimitCacheRow,
+        'limit' | 'expiresAt' | 'sourceRevision'
+      > & { effectiveLimit: number });
+  org: {
+    unreleasedLeases: number;
+  };
+  run: null | {
+    runId: string;
+    status: string;
+    capacityDeferrals: number;
+    acquired: number;
+    unresolvedOperations: number;
+    confirmedDeleted: number;
+    unreleasedLeases: number;
+    releasedBoundLeases: number;
+    invalidReleasedLeases: number;
+    cleanupJobs: number;
+    confirmedCleanupJobs: number;
+    pendingCleanup: number;
+    computeJobStatus: string | null;
+    hasComputeIntent: boolean;
+    recordedResources: number;
+    firstAcquiredAtMs: number | null;
+    lastDeleteConfirmedAtMs: number | null;
+  };
+};
+
+/**
+ * Read-only, caller-owned evidence for a small Preview contract fixture. The
+ * API chooses the namespace-derived schema; no SQL or connection override is
+ * accepted. Every row projection is an aggregate, so response size never
+ * depends on attempts, resources, leases or cleanup history.
+ *
+ * Deleted means the existing lifecycle owner recorded provider-confirmed
+ * deletion. Lease expiry is deliberately never consulted by this reader.
+ */
+export async function readRuntimeSandboxCapacityTestEvidence(
+  client: PostgresSchedulerQueryClient,
+  input: { orgId: string; runId?: string; releaseId: string },
+  options: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<RuntimeSandboxCapacityTestEvidence | null> {
+  if (!options.schema?.startsWith('runtime_scheduler_preview_')) {
+    throw new Error(
+      'Sandbox capacity test evidence requires an isolated Preview schema.',
+    );
+  }
+  const schema = quoteIdent(options.schema);
+  const { cache, leases, operations, cleanup, runs } = schemaTables(options);
+  const result = await client.query<{
+    evidence: RuntimeSandboxCapacityTestEvidence;
+  }>(
+    `WITH owned_run AS (
+       SELECT run_id, status FROM ${runs}
+       WHERE org_id = $1 AND run_id = $2
+         AND launch_json->>'absurdReleaseId' = $3
+     ), owned_operations AS (
+       SELECT operation.* FROM ${operations} AS operation
+       JOIN owned_run ON owned_run.run_id = operation.run_id
+       WHERE operation.org_id = $1
+     ), owned_leases AS (
+       SELECT lease.* FROM owned_operations AS operation
+       JOIN ${leases} AS lease ON lease.lease_id = operation.operation_key
+       WHERE lease.org_id = $1 AND lease.run_id = operation.run_id
+     ), owned_cleanup AS (
+       SELECT job.* FROM owned_operations AS operation
+       JOIN ${cleanup} AS job ON job.provider = operation.provider
+         AND job.sandbox_id = operation.sandbox_id
+         AND job.routing_domain_key = operation.routing_domain_key
+         AND job.run_id = operation.run_id
+     )
+     SELECT jsonb_build_object(
+       'observedAtMs', floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint,
+       'mirror', (SELECT jsonb_build_object(
+         'limit', "limit", 'effectiveLimit', CASE WHEN expires_at IS NOT NULL AND expires_at <= clock_timestamp()
+           THEN ${DEFAULT_PLAY_SANDBOX_CONCURRENCY} ELSE "limit" END,
+         'expiresAt', floor(extract(epoch FROM expires_at) * 1000)::bigint,
+         'sourceRevision', source_revision
+       ) FROM ${cache} WHERE org_id = $1),
+       'org', jsonb_build_object(
+         'unreleasedLeases', (SELECT count(*)::integer FROM ${leases} WHERE org_id = $1 AND released_at IS NULL)
+       ),
+       'run', (SELECT jsonb_build_object(
+         'runId', run_id, 'status', status,
+         'capacityDeferrals', (SELECT count(*)::integer FROM ${schema}."attempts" AS attempt
+           WHERE attempt.run_id = owned_run.run_id AND attempt.error_json->>'kind' = 'scheduler_capacity'
+             AND starts_with(attempt.error_json->>'message', 'Runtime scheduler sandbox capacity is full for organization ')),
+         'acquired', (SELECT count(*)::integer FROM owned_operations WHERE sandbox_id IS NOT NULL AND provider_created_at IS NOT NULL),
+         'unresolvedOperations', (SELECT count(*)::integer FROM owned_operations WHERE state NOT IN ('deleted', 'abandoned')),
+         'confirmedDeleted', (SELECT count(*)::integer FROM owned_operations WHERE state = 'deleted' AND delete_confirmed_at IS NOT NULL),
+         'unreleasedLeases', (SELECT count(*)::integer FROM owned_leases WHERE released_at IS NULL),
+         'releasedBoundLeases', (SELECT count(*)::integer FROM owned_leases WHERE sandbox_id IS NOT NULL AND released_at IS NOT NULL),
+         'invalidReleasedLeases', (SELECT count(*)::integer FROM owned_leases AS lease
+           WHERE lease.sandbox_id IS NOT NULL AND lease.released_at IS NOT NULL AND NOT EXISTS (
+             SELECT 1 FROM owned_operations AS operation WHERE operation.operation_key = lease.lease_id
+               AND operation.provider = lease.provider AND operation.sandbox_id = lease.sandbox_id
+               AND operation.routing_domain_key = coalesce(lease.routing_domain, '')
+               AND operation.state = 'deleted' AND operation.delete_confirmed_at IS NOT NULL)),
+         'cleanupJobs', (SELECT count(*)::integer FROM owned_cleanup),
+         'confirmedCleanupJobs', (SELECT count(*)::integer FROM owned_cleanup WHERE status = 'deleted' AND deleted_at IS NOT NULL),
+         'pendingCleanup', (SELECT count(*)::integer FROM owned_cleanup WHERE status <> 'deleted' OR blocked_at IS NOT NULL),
+         'hasComputeIntent', EXISTS (SELECT 1 FROM ${schema}."attempts" AS attempt
+           CROSS JOIN LATERAL jsonb_array_elements(CASE
+             WHEN jsonb_typeof(attempt.resource_json) = 'array' THEN attempt.resource_json
+             WHEN attempt.resource_json IS NULL THEN '[]'::jsonb ELSE jsonb_build_array(attempt.resource_json) END) AS resource
+           WHERE attempt.run_id = owned_run.run_id AND resource->>'kind' = 'compute_session'),
+         'recordedResources', (SELECT count(DISTINCT (resource->>'kind', resource->>'sandboxId'))::integer
+           FROM ${schema}."attempts" AS attempt
+           CROSS JOIN LATERAL jsonb_array_elements(CASE
+             WHEN jsonb_typeof(attempt.resource_json) = 'array' THEN attempt.resource_json
+             WHEN attempt.resource_json IS NULL THEN '[]'::jsonb ELSE jsonb_build_array(attempt.resource_json) END) AS resource
+           WHERE attempt.run_id = owned_run.run_id AND resource->>'kind' IN ('daytona_sandbox', 'modal_sandbox')
+             AND NULLIF(resource->>'sandboxId', '') IS NOT NULL),
+         'computeJobStatus', (SELECT status FROM ${schema}."compute_billing_jobs_v2" AS job WHERE job.run_id = owned_run.run_id),
+         'firstAcquiredAtMs', (SELECT floor(extract(epoch FROM min(provider_created_at)) * 1000)::bigint FROM owned_operations),
+         'lastDeleteConfirmedAtMs', (SELECT floor(extract(epoch FROM max(delete_confirmed_at)) * 1000)::bigint FROM owned_operations)
+       ) FROM owned_run)
+     ) AS evidence`,
+    [
+      assertId(input.orgId, 'orgId'),
+      input.runId ? assertId(input.runId, 'runId') : null,
+      assertId(input.releaseId, 'releaseId'),
+    ],
+  );
+  const evidence = result.rows[0]?.evidence;
+  if (!evidence)
+    throw new Error('Sandbox capacity evidence query returned no snapshot.');
+  return input.runId && evidence.run === null ? null : evidence;
+}