deepline 0.1.312 → 0.1.314

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

@@ -198,16 +198,12 @@ export type PlayBindings = {
     /** Stop the run before a billed action would push total run credits above this cap. */
     maxCreditsPerRun?: number;
   };
-  /** Requested sandbox envelope; the server enforces the final allowed limits. */
+  /** Requested prebuilt sandbox and runtime deadline. */
   runtime?: {
     /** Duration such as `"90m"` or `"2h"`. */
     timeout?: string;
-    /** Memory such as `"4GiB"`. */
-    memory?: string;
-    /** Whole vCPU count. */
-    cpu?: number;
-    /** Disk such as `"10GiB"`. */
-    disk?: string;
+    /** Deepline-managed prebuilt sandbox size. */
+    size?: 'standard';
   };
   /** Webhook trigger with optional HMAC signature verification. */
   webhook?: {
@@ -1204,7 +1200,7 @@ export type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = {
   bindings?: PlayBindings;
   /** Billing options. */
   billing?: PlayBindings['billing'];
-  /** Requested sandbox envelope; the server enforces the final allowed limits. */
+  /** Requested prebuilt sandbox and runtime deadline. */
   runtime?: PlayBindings['runtime'];
   /** Runtime compatibility override. Omit for the current typed contract. */
   compatibility?: PlayBindings['compatibility'];
@@ -1367,7 +1363,7 @@ export type DefinedPlay<TInput, TOutput extends PlayReturnObject> = ((
   DeeplineNamedPlay<TInput, TOutput> & {
     /** Optional trigger bindings (cron, webhook). */
     readonly bindings?: PlayBindings;
-    /** Requested sandbox envelope. */
+    /** Requested prebuilt sandbox and runtime deadline. */
     readonly runtime?: PlayBindings['runtime'];
     /** Runtime compatibility explicitly selected by the author. */
     readonly compatibility?: PlayBindings['compatibility'];

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

@@ -157,7 +157,7 @@ export const SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: '0.1.312',
+  version: '0.1.314',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -1291,6 +1291,31 @@ function createPacingResolver(
 export class PlayContextImpl {
   private rowStates = new Map<number, RowState>();
   private toolCallQueue: ToolCallRequest[] = [];
+  private pendingRuntimeToolOwnershipAssertions: Array<{
+    targets: Array<{ receiptKey: string; leaseId: string }>;
+    resolve: () => void;
+    reject: (error: unknown) => void;
+  }> = [];
+  private runtimeToolOwnershipAssertionFlushScheduled = false;
+  /**
+   * Direct durable boundaries (including ctx.fetch) arrive independently from
+   * concurrent map rows. Hold one microtask's worth so they can use the bulk
+   * receipt gateway instead of serial remote claim requests.
+   */
+  private pendingRuntimeReceiptClaims = new Map<
+    string,
+    {
+      scheduled: boolean;
+      requests: Array<{
+        key: string;
+        reclaimRunning: boolean;
+        forceRefresh: boolean;
+        forceFailedRefresh: boolean;
+        resolve: (receipt: RuntimeStepReceipt | null) => void;
+        reject: (error: unknown) => void;
+      }>;
+    }
+  >();
   /**
    * Fixed, non-resetting coalescing deadlines for ready scheduling lanes. A
    * deadline starts when the first request enters an empty batch bucket. New
@@ -2002,6 +2027,14 @@ export class PlayContextImpl {
     forceRefresh = false,
     forceFailedRefresh = false,
   ): Promise<RuntimeStepReceipt | null> {
+    if (this.#options.claimRuntimeStepReceipts) {
+      return await this.enqueueRuntimeStepReceiptClaim({
+        key,
+        reclaimRunning,
+        forceRefresh,
+        forceFailedRefresh,
+      });
+    }
     if (!this.#options.claimRuntimeStepReceipt) {
       return null;
     }
@@ -2025,6 +2058,73 @@ export class PlayContextImpl {
     };
   }
 
+  private async enqueueRuntimeStepReceiptClaim(input: {
+    key: string;
+    reclaimRunning: boolean;
+    forceRefresh: boolean;
+    forceFailedRefresh: boolean;
+  }): Promise<RuntimeStepReceipt | null> {
+    const batchKey = [
+      input.reclaimRunning ? 'reclaim' : 'ordinary',
+      input.forceRefresh ? 'force' : 'cached',
+      input.forceFailedRefresh ? 'failed-force' : 'failed-cached',
+    ].join(':');
+    let batch = this.pendingRuntimeReceiptClaims.get(batchKey);
+    if (!batch) {
+      batch = { scheduled: false, requests: [] };
+      this.pendingRuntimeReceiptClaims.set(batchKey, batch);
+    }
+    return await new Promise<RuntimeStepReceipt | null>((resolve, reject) => {
+      batch!.requests.push({ ...input, resolve, reject });
+      if (batch!.scheduled) return;
+      batch!.scheduled = true;
+      queueMicrotask(
+        () => void this.flushRuntimeStepReceiptClaimBatch(batchKey),
+      );
+    });
+  }
+
+  private async flushRuntimeStepReceiptClaimBatch(
+    batchKey: string,
+  ): Promise<void> {
+    const batch = this.pendingRuntimeReceiptClaims.get(batchKey);
+    if (!batch) return;
+    this.pendingRuntimeReceiptClaims.delete(batchKey);
+    const requests = batch.requests;
+    const first = requests[0];
+    const claimReceipts = this.#options.claimRuntimeStepReceipts;
+    if (!first || !claimReceipts) {
+      for (const request of requests) request.resolve(null);
+      return;
+    }
+    try {
+      const receipts = await this.dispatchChunkedRuntimeReceiptRequest(
+        requests,
+        (chunk) => {
+          const leaseId = `receipt-lease:${crypto.randomUUID()}`;
+          return claimReceipts({
+            keys: chunk.map((request) => request.key),
+            leaseIds: chunk.map(() => leaseId),
+            runId: this.currentReceiptOwnerRunId,
+            runAttempt: this.currentRunAttempt,
+            leaseAware: true,
+            ...(first.reclaimRunning ? { reclaimRunning: true } : {}),
+            ...(first.forceRefresh ? { forceRefresh: true } : {}),
+            ...(first.forceFailedRefresh ? { forceFailedRefresh: true } : {}),
+          });
+        },
+      );
+      for (let index = 0; index < requests.length; index += 1) {
+        const request = requests[index]!;
+        request.resolve(
+          this.normalizeRuntimeStepReceipt(request.key, receipts[index]),
+        );
+      }
+    } catch (error) {
+      for (const request of requests) request.reject(error);
+    }
+  }
+
   private async completeRuntimeStepReceipt(
     key: string,
     _runId: string,
@@ -2111,59 +2211,148 @@ export class PlayContextImpl {
   private async assertRuntimeToolReceiptOwnership(
     requests: ToolCallRequest[],
   ): Promise<void> {
-    const targets = requests.flatMap((request) => {
+    const targets = this.runtimeToolReceiptOwnershipTargets(requests);
+    if (targets.length === 0) return;
+
+    return await new Promise<void>((resolve, reject) => {
+      this.pendingRuntimeToolOwnershipAssertions.push({
+        targets,
+        resolve,
+        reject,
+      });
+      if (this.runtimeToolOwnershipAssertionFlushScheduled) return;
+      this.runtimeToolOwnershipAssertionFlushScheduled = true;
+      queueMicrotask(() => void this.flushRuntimeToolOwnershipAssertionBatch());
+    });
+  }
+
+  private runtimeToolReceiptOwnershipTargets(
+    requests: ToolCallRequest[],
+  ): Array<{ receiptKey: string; leaseId: string }> {
+    return requests.flatMap((request) => {
       const receiptKey = request.receiptKey?.trim() || null;
       if (!receiptKey) return [];
       const leaseId = request.receiptLeaseId?.trim() || null;
       if (!leaseId) return [];
       return [{ receiptKey, leaseId }];
     });
-    if (targets.length === 0) return;
+  }
 
+  private async renewRuntimeToolReceiptOwnership(
+    requests: ToolCallRequest[],
+  ): Promise<void> {
+    const targets = this.runtimeToolReceiptOwnershipTargets(requests);
+    if (targets.length === 0) return;
+    if (!this.#options.heartbeatRuntimeStepReceipts) {
+      return await this.assertRuntimeToolReceiptOwnership(requests);
+    }
     const byLeaseId = new Map<string, string[]>();
     for (const target of targets) {
       const keys = byLeaseId.get(target.leaseId) ?? [];
       keys.push(target.receiptKey);
       byLeaseId.set(target.leaseId, keys);
     }
-
-    if (this.#options.heartbeatRuntimeStepReceipts) {
-      for (const [leaseId, keys] of byLeaseId) {
-        const receipts = await this.#options.heartbeatRuntimeStepReceipts({
+    await Promise.all(
+      [...byLeaseId].map(async ([leaseId, keys]) => {
+        const receipts = await this.#options.heartbeatRuntimeStepReceipts!({
           runId: this.currentReceiptOwnerRunId,
           runAttempt: this.currentRunAttempt,
           leaseId,
           keys,
         });
         this.assertRuntimeToolReceiptHeartbeatResult(keys, leaseId, receipts);
+      }),
+    );
+  }
+
+  private async flushRuntimeToolOwnershipAssertionBatch(): Promise<void> {
+    this.runtimeToolOwnershipAssertionFlushScheduled = false;
+    const assertions = this.pendingRuntimeToolOwnershipAssertions.splice(0);
+    if (assertions.length === 0) return;
+    const targets = assertions.flatMap((assertion) => assertion.targets);
+
+    if (this.#options.heartbeatRuntimeStepReceipts) {
+      try {
+        const byLeaseId = new Map<string, string[]>();
+        for (const target of targets) {
+          const keys = byLeaseId.get(target.leaseId) ?? [];
+          keys.push(target.receiptKey);
+          byLeaseId.set(target.leaseId, keys);
+        }
+        const renewed = new Map<string, RuntimeStepReceipt | null>();
+        await Promise.all(
+          [...byLeaseId].map(async ([leaseId, keys]) => {
+            const receipts = await this.#options.heartbeatRuntimeStepReceipts!({
+              runId: this.currentReceiptOwnerRunId,
+              runAttempt: this.currentRunAttempt,
+              leaseId,
+              keys,
+            });
+            for (let index = 0; index < keys.length; index += 1) {
+              renewed.set(keys[index]!, receipts[index] ?? null);
+            }
+          }),
+        );
+        for (const assertion of assertions) {
+          const lost = assertion.targets.find((target) => {
+            const receipt = renewed.get(target.receiptKey);
+            return !this.runtimeToolReceiptStillOwned(receipt, target.leaseId);
+          });
+          if (lost) {
+            assertion.reject(
+              new RuntimeReceiptLeaseLostError({
+                receiptKey: lost.receiptKey,
+                runId: this.currentReceiptOwnerRunId,
+                leaseId: lost.leaseId,
+              }),
+            );
+          } else {
+            assertion.resolve();
+          }
+        }
+      } catch (error) {
+        for (const assertion of assertions) assertion.reject(error);
       }
       return;
     }
 
     if (
-      !this.#options.getRuntimeStepReceipt &&
-      !this.#options.getRuntimeStepReceipts
+      this.#options.getRuntimeStepReceipt ||
+      this.#options.getRuntimeStepReceipts
     ) {
-      throw new RuntimeReceiptLeaseLostError({
-        receiptKey: targets[0]?.receiptKey ?? 'unknown',
-        runId: this.currentReceiptOwnerRunId,
-        leaseId: targets[0]?.leaseId ?? 'unknown',
-      });
-    }
-
-    const latest = await this.getRuntimeStepReceipts(
-      targets.map((target) => target.receiptKey),
-    );
-    for (const target of targets) {
-      const receipt = latest.get(target.receiptKey);
-      if (!this.runtimeToolReceiptStillOwned(receipt, target.leaseId)) {
-        throw new RuntimeReceiptLeaseLostError({
-          receiptKey: target.receiptKey,
-          runId: this.currentReceiptOwnerRunId,
-          leaseId: target.leaseId,
-        });
+      try {
+        const latest = await this.getRuntimeStepReceipts(
+          targets.map((target) => target.receiptKey),
+        );
+        for (const assertion of assertions) {
+          const lost = assertion.targets.find((target) => {
+            const receipt = latest.get(target.receiptKey);
+            return !this.runtimeToolReceiptStillOwned(receipt, target.leaseId);
+          });
+          if (lost) {
+            assertion.reject(
+              new RuntimeReceiptLeaseLostError({
+                receiptKey: lost.receiptKey,
+                runId: this.currentReceiptOwnerRunId,
+                leaseId: lost.leaseId,
+              }),
+            );
+          } else {
+            assertion.resolve();
+          }
+        }
+      } catch (error) {
+        for (const assertion of assertions) assertion.reject(error);
       }
+      return;
     }
+
+    const error = new RuntimeReceiptLeaseLostError({
+      receiptKey: targets[0]?.receiptKey ?? 'unknown',
+      runId: this.currentReceiptOwnerRunId,
+      leaseId: targets[0]?.leaseId ?? 'unknown',
+    });
+    for (const assertion of assertions) assertion.reject(error);
   }
 
   private assertRuntimeToolReceiptHeartbeatResult(
@@ -2366,22 +2555,23 @@ export class PlayContextImpl {
     if (uniqueKeys.length === 0) return new Map();
     const claimReceipts = this.#options.claimRuntimeStepReceipts;
     const receipts = claimReceipts
-      ? await this.dispatchChunkedRuntimeReceiptRequest(uniqueKeys, (chunk) =>
-          claimReceipts({
+      ? await this.dispatchChunkedRuntimeReceiptRequest(uniqueKeys, (chunk) => {
+          const leaseId = `receipt-lease:${crypto.randomUUID()}`;
+          return claimReceipts({
             keys: chunk,
             // A transport retry can replay this mutation after the store
             // committed but before the response body was consumed. Stable
             // caller-owned tokens distinguish that replay from a concurrent
             // claimant without weakening the provider-call execution fence.
-            leaseIds: chunk.map(() => `receipt-lease:${crypto.randomUUID()}`),
+            leaseIds: chunk.map(() => leaseId),
             runId: this.currentReceiptOwnerRunId,
             runAttempt: this.currentRunAttempt,
             leaseAware: true,
             ...(reclaimRunning ? { reclaimRunning: true } : {}),
             ...(forceRefresh ? { forceRefresh: true } : {}),
             ...(forceFailedRefresh ? { forceFailedRefresh: true } : {}),
-          }),
-        )
+          });
+        })
       : await Promise.all(
           uniqueKeys.map((key) =>
             this.claimRuntimeStepReceipt(
@@ -8194,7 +8384,7 @@ export class PlayContextImpl {
                     executionAuthScopeDigest: owner.executionAuthScopeDigest,
                     receiptLeaseExpiresAt: owner.receiptLeaseExpiresAt,
                     heartbeatReceipt: () =>
-                      this.assertRuntimeToolReceiptOwnership([owner]),
+                      this.renewRuntimeToolReceiptOwnership([owner]),
                     providerIdempotencyKey:
                       this.providerIdempotencyKeyForToolCall({
                         cacheKey: owner.cacheKey,
@@ -8471,7 +8661,7 @@ export class PlayContextImpl {
                         batch.memberRequests,
                       ),
                     heartbeatReceipt: () =>
-                      this.assertRuntimeToolReceiptOwnership(
+                      this.renewRuntimeToolReceiptOwnership(
                         batch.memberRequests,
                       ),
                   },
@@ -8634,7 +8824,7 @@ export class PlayContextImpl {
                             }),
                           receiptLeaseExpiresAt: request.receiptLeaseExpiresAt,
                           heartbeatReceipt: () =>
-                            this.assertRuntimeToolReceiptOwnership([request]),
+                            this.renewRuntimeToolReceiptOwnership([request]),
                         }
                       : {}),
                     timeoutMs: resolveRuntimeTimeoutMsForClaimedOwners([

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

@@ -1,11 +1,14 @@
-import type { Daytona } from '@daytonaio/sdk';
+import { type Daytona } from '@daytonaio/sdk';
 import type {
   PlayRunnerExecutionConfig,
   PlayRunnerResult,
 } from '@shared_libs/play-runtime/protocol';
 import { isIsolatedRuntimeSchedulerSchema } from '@shared_libs/play-runtime/runtime-scheduler-topology';
 import { PLAY_RUNNER_TIMEOUT_SECONDS } from '@shared_libs/play-runtime/runtime-constants';
-import { resolvePlaySandboxRuntimeLimits } from '@shared_libs/play-runtime/sandbox-runtime-limits';
+import {
+  STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
+  validatePlaySandboxRuntimeLimits,
+} from '@shared_libs/play-runtime/sandbox-runtime-limits';
 
 const DAYTONA_CREATE_TIMEOUT_SECONDS = 10;
 const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
@@ -14,11 +17,13 @@ const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
 // setup time cannot consume the terminal-flush grace.
 const DAYTONA_AUTO_ARCHIVE_INTERVAL_MINUTES = 15;
 const DAYTONA_SANDBOX_LABEL_SOURCE = 'deepline-play-runner';
-// Daytona's default image is the fast path. Non-standard resources are applied
-// during acquisition, before customer code and before the billing clock starts.
-export const DAYTONA_SANDBOX_CPU = 1;
-export const DAYTONA_SANDBOX_MEMORY_GIB = 1;
-export const DAYTONA_SANDBOX_DISK_GIB = 3;
+// Daytona's Deepline-managed default snapshot is the only admitted prebuilt.
+// Resources are verified during acquisition, before customer code or billing.
+export const DAYTONA_SANDBOX_CPU = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.cpu;
+export const DAYTONA_SANDBOX_MEMORY_GIB =
+  STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.memoryGiB;
+export const DAYTONA_SANDBOX_DISK_GIB =
+  STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.diskGiB;
 export const DAYTONA_SANDBOX_GPU = 0;
 const DAYTONA_NETWORK_ALLOW_LIST_ENV = 'DEEPLINE_DAYTONA_NETWORK_ALLOW_LIST';
 
@@ -173,15 +178,10 @@ async function createOneShotDaytonaSandbox(input: {
   orgId: string;
   context: DaytonaExecutionContext;
 }): Promise<DaytonaSandbox> {
-  const limits = resolvePlaySandboxRuntimeLimits(
-    input.context.sandboxRuntimeLimits
-      ? {
-          timeout: `${input.context.sandboxRuntimeLimits.timeoutSeconds / 60}m`,
-          memory: `${input.context.sandboxRuntimeLimits.memoryGiB}GiB`,
-          cpu: input.context.sandboxRuntimeLimits.cpu,
-          disk: `${input.context.sandboxRuntimeLimits.diskGiB}GiB`,
-        }
-      : null,
+  const limits = validatePlaySandboxRuntimeLimits(
+    input.context.sandboxRuntimeLimits ?? {
+      ...STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
+    },
   );
   const orgId = normalizeLabelValue(input.orgId);
   const workflowId = normalizeLabelValue(input.context.workflowId);
@@ -204,26 +204,24 @@ async function createOneShotDaytonaSandbox(input: {
     runtimeSchedulerSchema: input.context.runtimeSchedulerSchema ?? null,
   });
 
-  // Intentionally omit image/snapshot so Daytona uses its default fast sandbox
-  // image; custom images would add build/pull tax to one-shot cold starts.
-  return input.daytona.create(
-    {
-      labels,
-      ephemeral: true,
-      autoStopInterval: Math.ceil(
-        (limits.timeoutSeconds + PLAY_RUNNER_TIMEOUT_SECONDS - 30 * 60) / 60,
-      ),
-      autoArchiveInterval: DAYTONA_AUTO_ARCHIVE_INTERVAL_MINUTES,
-      // A non-empty `networkAllowList` IS the "block all egress except these
-      // CIDRs" control; Daytona rejects create when `networkBlockAll: true` is
-      // combined with a non-empty allow-list ("networkBlockAll: true cannot be
-      // combined with a non-empty networkAllowList or domainAllowList"). Pass
-      // the allow-list alone so the egress restriction holds without the
-      // contradictory flag.
-      ...(networkAllowList ? { networkAllowList } : {}),
-    },
-    { timeout: DAYTONA_CREATE_TIMEOUT_SECONDS },
-  );
+  const commonParams = {
+    labels,
+    ephemeral: true,
+    autoStopInterval: Math.ceil(
+      (limits.timeoutSeconds + PLAY_RUNNER_TIMEOUT_SECONDS - 30 * 60) / 60,
+    ),
+    autoArchiveInterval: DAYTONA_AUTO_ARCHIVE_INTERVAL_MINUTES,
+    // A non-empty `networkAllowList` IS the "block all egress except these
+    // CIDRs" control; Daytona rejects create when `networkBlockAll: true` is
+    // combined with a non-empty allow-list ("networkBlockAll: true cannot be
+    // combined with a non-empty networkAllowList or domainAllowList"). Pass
+    // the allow-list alone so the egress restriction holds without the
+    // contradictory flag.
+    ...(networkAllowList ? { networkAllowList } : {}),
+  };
+  return input.daytona.create(commonParams, {
+    timeout: DAYTONA_CREATE_TIMEOUT_SECONDS,
+  });
 }
 
 async function createRetriedOneShotDaytonaSandbox(input: {
@@ -286,15 +284,10 @@ async function acquireOneShotDaytonaSandbox(input: {
   emitStage: DaytonaStageEmitter;
   startedAt: number;
 }): Promise<AcquiredDaytonaSandbox> {
-  const limits = resolvePlaySandboxRuntimeLimits(
-    input.context.sandboxRuntimeLimits
-      ? {
-          timeout: `${input.context.sandboxRuntimeLimits.timeoutSeconds / 60}m`,
-          memory: `${input.context.sandboxRuntimeLimits.memoryGiB}GiB`,
-          cpu: input.context.sandboxRuntimeLimits.cpu,
-          disk: `${input.context.sandboxRuntimeLimits.diskGiB}GiB`,
-        }
-      : null,
+  const limits = validatePlaySandboxRuntimeLimits(
+    input.context.sandboxRuntimeLimits ?? {
+      ...STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS,
+    },
   );
   input.emitStage('create:start');
   const result = await createRetriedOneShotDaytonaSandbox(input);
@@ -304,42 +297,6 @@ async function acquireOneShotDaytonaSandbox(input: {
     diskGiB: result.sandbox.disk,
     gpu: result.sandbox.gpu ?? 0,
   };
-  // Daytona's SDK only accepts resources when a custom image is supplied.
-  // We deliberately retain the provider's fast default image, then resize
-  // before any customer code or billing window begins.
-  if (
-    typeof result.sandbox.resize === 'function' &&
-    (granted.cpu !== limits.cpu ||
-      granted.memoryGiB !== limits.memoryGiB ||
-      granted.diskGiB !== limits.diskGiB)
-  ) {
-    try {
-      if (granted.diskGiB !== limits.diskGiB) {
-        await result.sandbox.stop(60);
-        await result.sandbox.resize({
-          cpu: limits.cpu,
-          memory: limits.memoryGiB,
-          disk: limits.diskGiB,
-        });
-        await result.sandbox.start(60);
-      } else {
-        await result.sandbox.resize({
-          cpu: limits.cpu,
-          memory: limits.memoryGiB,
-          disk: limits.diskGiB,
-        });
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return await rejectAcquiredSandbox(
-        result.sandbox,
-        `Daytona sandbox resize failed before execution: ${message}.`,
-      );
-    }
-    granted.cpu = result.sandbox.cpu;
-    granted.memoryGiB = result.sandbox.memory;
-    granted.diskGiB = result.sandbox.disk;
-  }
   if (
     granted.cpu !== limits.cpu ||
     granted.memoryGiB !== limits.memoryGiB ||