@elench/testkit 0.1.149 → 0.1.151

package/lib/runner/runtime-manager.mjs

@@ -12,6 +12,7 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
   const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
   const pools = new Map();
   const locks = new Map();
+  const resourceBudgets = createResourceBudgetState(graphs);
   const failedGraphs = new Map();
   let nextLeaseCounter = 1;
   const runtimeHooks = {
@@ -32,7 +33,7 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
       if (!locksAvailable(locks, task.locks || [])) {
         return false;
       }
-      return claimableRuntimeSlot(pool, task) !== null;
+      return claimableRuntimeSlot(pool, task, resourceBudgets) !== null;
     },
     async acquire(task) {
       const pool = getPool(pools, graphByKey, task, productDir, lifecycle);
@@ -47,7 +48,7 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
         throw new Error(`Task ${task.id} was claimed before its locks were available`);
       }
 
-      const slot = claimRuntimeSlot(pool, task);
+      const slot = claimRuntimeSlot(pool, task, resourceBudgets);
       if (!slot) {
         releaseLocks(locks, task.locks || [], leaseId);
         throw new Error(`Task ${task.id} was claimed before runtime capacity was available`);
@@ -69,7 +70,8 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
         releaseRuntimeSlot(slot, task);
         releaseLocks(locks, task.locks || [], leaseId);
         cleanupLeaseDir({ leaseDir: path.join(slot.context?.runtimeDir || productDir, "leases", leaseId) });
-        await drainRuntimeSlot(slot, lifecycle, runtimeHooks);
+        if (!slot.context) releaseSlotResources(slot, resourceBudgets);
+        await drainRuntimeSlot(slot, lifecycle, runtimeHooks, resourceBudgets);
         if (!lifecycle.isStopRequested()) {
           markGraphFailed(failedGraphs, task.graphKey, formatError(error));
         }
@@ -85,14 +87,14 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
         lease.slot.draining = true;
       }
       if (lease.slot.draining && lease.slot.activeLeaseCount === 0) {
-        await drainRuntimeSlot(lease.slot, lifecycle, runtimeHooks);
+        await drainRuntimeSlot(lease.slot, lifecycle, runtimeHooks, resourceBudgets);
       }
     },
     async cleanupAll() {
       for (const pool of pools.values()) {
         for (const slot of pool.slots) {
           slot.draining = true;
-          await drainRuntimeSlot(slot, lifecycle, runtimeHooks);
+          await drainRuntimeSlot(slot, lifecycle, runtimeHooks, resourceBudgets);
         }
       }
     },
@@ -109,7 +111,22 @@ export function createRuntimeManager({ productDir, graphs, lifecycle, hooks = {}
             runtimeId: slot.runtimeId,
             peakLeaseCount: slot.peakLeaseCount,
             peakResourceUnits: slot.peakResourceUnits,
+            resourceReservations: (slot.resourceReservations || []).map((reservation) => ({ ...reservation })),
           })),
+          resourceBudgets: [...resourceBudgets.values()]
+            .filter((budget) =>
+              pool.slots.some((slot) =>
+                (slot.graph.resourceReservations || []).some((reservation) => reservation.key === budget.key)
+              )
+            )
+            .map((budget) => ({
+              key: budget.key,
+              capacity: budget.capacity,
+              reserved: budget.reserved,
+              available: budget.available,
+              active: budget.active,
+              peakActive: budget.peakActive,
+            })),
         }))
         .sort((left, right) => String(left.graphKey).localeCompare(String(right.graphKey)));
     },
@@ -156,6 +173,7 @@ function getPool(pools, graphByKey, task, productDir, lifecycle) {
       contextPromise: null,
       activeLeaseCount: 0,
       activeResourceUnits: 0,
+      resourceReservations: [],
       peakLeaseCount: 0,
       peakResourceUnits: 0,
       draining: false,
@@ -165,13 +183,13 @@ function getPool(pools, graphByKey, task, productDir, lifecycle) {
   return pool;
 }
 
-function claimRuntimeSlot(pool, task) {
+function claimRuntimeSlot(pool, task, resourceBudgets) {
   const resourceCost = task.resourceCost || 1;
   const available = pool.slots.filter((slot) => !slot.draining);
   if (available.length === 0) return null;
 
   const slot = [...available]
-    .filter((candidate) => slotHasCapacity(candidate, resourceCost))
+    .filter((candidate) => slotHasCapacity(candidate, resourceCost) && slotResourceBudgetsAvailable(candidate, resourceBudgets))
     .sort(
       (left, right) =>
         left.activeResourceUnits - right.activeResourceUnits ||
@@ -179,6 +197,7 @@ function claimRuntimeSlot(pool, task) {
         left.runtimeId.localeCompare(right.runtimeId)
     )[0];
   if (!slot) return null;
+  reserveSlotResources(slot, resourceBudgets);
   slot.activeLeaseCount += 1;
   slot.activeResourceUnits += resourceCost;
   slot.peakLeaseCount = Math.max(slot.peakLeaseCount, slot.activeLeaseCount);
@@ -209,9 +228,10 @@ async function getReadyContext(slot, productDir, task, lifecycle, runtimeHooks)
   return slot.context;
 }
 
-async function drainRuntimeSlot(slot, lifecycle, runtimeHooks) {
+async function drainRuntimeSlot(slot, lifecycle, runtimeHooks, resourceBudgets) {
   if (!slot.context || slot.activeLeaseCount > 0) return;
   await runtimeHooks.cleanupRuntimeInstanceContext(slot.context, lifecycle);
+  releaseSlotResources(slot, resourceBudgets);
   slot.context = null;
   slot.contextPromise = null;
   slot.draining = false;
@@ -234,10 +254,15 @@ function locksAvailable(lockMap, lockNames) {
   return [...new Set(lockNames)].every((lockName) => !lockMap.has(lockName));
 }
 
-function claimableRuntimeSlot(pool, task) {
+function claimableRuntimeSlot(pool, task, resourceBudgets) {
   const resourceCost = task.resourceCost || 1;
   return (
-    pool.slots.find((slot) => !slot.draining && slotHasCapacity(slot, resourceCost)) || null
+    pool.slots.find(
+      (slot) =>
+        !slot.draining &&
+        slotHasCapacity(slot, resourceCost) &&
+        slotResourceBudgetsAvailable(slot, resourceBudgets)
+    ) || null
   );
 }
 
@@ -245,6 +270,62 @@ function slotHasCapacity(slot, resourceCost) {
   return slot.activeResourceUnits + resourceCost <= slot.graph.maxConcurrentTasks;
 }
 
+function createResourceBudgetState(graphs) {
+  const budgets = new Map();
+  for (const graph of graphs) {
+    for (const reservation of graph.resourceReservations || []) {
+      const existing = budgets.get(reservation.key) || {
+        key: reservation.key,
+        capacity: reservation.capacity || 0,
+        reserved: reservation.reserved || 0,
+        available: reservation.available || Math.max(0, (reservation.capacity || 0) - (reservation.reserved || 0)),
+        active: 0,
+        peakActive: 0,
+      };
+      existing.capacity = Math.max(existing.capacity, reservation.capacity || 0);
+      existing.reserved = Math.max(existing.reserved, reservation.reserved || 0);
+      existing.available = Math.max(0, existing.capacity - existing.reserved);
+      budgets.set(reservation.key, existing);
+    }
+  }
+  return budgets;
+}
+
+function slotResourceBudgetsAvailable(slot, resourceBudgets) {
+  if (slot.resourceReservations?.length > 0) return true;
+  return (slot.graph.resourceReservations || []).every((reservation) => {
+    const budget = resourceBudgets.get(reservation.key);
+    if (!budget) return true;
+    return budget.active + reservation.perRuntime <= budget.available;
+  });
+}
+
+function reserveSlotResources(slot, resourceBudgets) {
+  if (slot.resourceReservations?.length > 0) return;
+  const reservations = [];
+  for (const reservation of slot.graph.resourceReservations || []) {
+    const budget = resourceBudgets.get(reservation.key);
+    if (!budget) continue;
+    budget.active += reservation.perRuntime;
+    budget.peakActive = Math.max(budget.peakActive, budget.active);
+    reservations.push({
+      key: reservation.key,
+      units: reservation.perRuntime,
+      services: reservation.services || [],
+    });
+  }
+  slot.resourceReservations = reservations;
+}
+
+function releaseSlotResources(slot, resourceBudgets) {
+  for (const reservation of slot.resourceReservations || []) {
+    const budget = resourceBudgets.get(reservation.key);
+    if (!budget) continue;
+    budget.active = Math.max(0, budget.active - reservation.units);
+  }
+  slot.resourceReservations = [];
+}
+
 function releaseLocks(lockMap, lockNames, leaseId) {
   for (const lockName of [...new Set(lockNames)].sort()) {
     if (lockMap.get(lockName) === leaseId) {

package/lib/runner/scheduler/index.mjs

@@ -69,12 +69,13 @@ export function buildScheduledQueue(servicePlans, graphs, { timings, history } =
     }));
 }
 
-export function buildRunPlanningMetadata(queue) {
+export function buildRunPlanningMetadata(queue, graphs = []) {
   return {
     scheduler: {
       policy: SCHEDULER_POLICY,
       version: SCHEDULER_VERSION,
     },
+    resourceBudgets: buildPlanningResourceBudgets(graphs),
     tasks: (queue || []).map((task) => ({
       rank: task.schedulerRank || null,
       id: task.id,
@@ -94,6 +95,34 @@ export function buildRunPlanningMetadata(queue) {
   };
 }
 
+function buildPlanningResourceBudgets(graphs) {
+  const byKey = new Map();
+  for (const graph of graphs || []) {
+    for (const reservation of graph.resourceReservations || []) {
+      const existing = byKey.get(reservation.key) || {
+        key: reservation.key,
+        kind: reservation.kind,
+        scope: reservation.scope,
+        resourceName: reservation.resourceName,
+        capacity: reservation.capacity,
+        reserved: reservation.reserved,
+        available: reservation.available,
+        graphs: [],
+      };
+      existing.capacity = Math.max(existing.capacity || 0, reservation.capacity || 0);
+      existing.reserved = Math.max(existing.reserved || 0, reservation.reserved || 0);
+      existing.available = Math.max(0, existing.capacity - existing.reserved);
+      existing.graphs.push({
+        graphKey: graph.key,
+        services: reservation.services || [],
+        perRuntime: reservation.perRuntime,
+      });
+      byKey.set(reservation.key, existing);
+    }
+  }
+  return [...byKey.values()].sort((left, right) => left.key.localeCompare(right.key));
+}
+
 export function compareScheduledTasks(a, b) {
   return (
     b.estimatedDurationMs - a.estimatedDurationMs ||

package/lib/runtime/index.d.ts

@@ -245,7 +245,7 @@ export interface RawRequestClient {
     extraHeaders?: RuntimeHeaders
   ): RuntimeResponse;
   as(actorName: string): RawRequestClient;
-  delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  delete(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   headers(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
   multipart: MultipartRequestClient;
@@ -269,7 +269,7 @@ export interface ActorRequestClient {
     body?: unknown,
     extraHeaders?: RuntimeHeaders
   ): RuntimeResponse;
-  rawDelete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawDelete(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawGet(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawHeaders(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
   rawMultipart: MultipartRequestClient;
@@ -277,7 +277,7 @@ export interface ActorRequestClient {
   rawPost(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawPut(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawReq: RawRequestClient;
-  delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  delete(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   patch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   post(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
@@ -301,12 +301,12 @@ export interface HttpClient<TSetup = unknown> {
   as(actorName: string): ActorRequestClient;
   headers(extraHeaders?: RuntimeHeaders): RuntimeHeaders;
   multipart: MultipartRequestClient;
-  delete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  delete(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   get(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   patch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   post(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   put(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
-  rawDelete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawDelete(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawGet(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
   rawHeaders(actorName?: string | null, extraHeaders?: RuntimeHeaders): RuntimeHeaders;
   rawMultipart: MultipartRequestClient;

package/lib/runtime-src/k6/http.js

@@ -137,8 +137,8 @@ export function createHttpClient(config) {
         return resolvedRawHeadersFor(actorName, extraHeaders);
       },
       rawReq: actorRawReq,
-      delete(path, extraHeaders = {}) {
-        return requestAs(actorName, "DELETE", path, null, extraHeaders);
+      delete(path, body = null, extraHeaders = {}) {
+        return requestAs(actorName, "DELETE", path, body, extraHeaders);
       },
       get(path, extraHeaders = {}) {
         return requestAs(actorName, "GET", path, null, extraHeaders);
@@ -158,8 +158,8 @@ export function createHttpClient(config) {
       raw(method, path, body, extraHeaders = {}) {
         return actorRawReq(method, path, body, extraHeaders);
       },
-      rawDelete(path, extraHeaders = {}) {
-        return actorRawReq.delete(path, extraHeaders);
+      rawDelete(path, body = null, extraHeaders = {}) {
+        return actorRawReq.delete(path, body, extraHeaders);
       },
       rawGet(path, extraHeaders = {}) {
         return actorRawReq.get(path, extraHeaders);
@@ -208,8 +208,8 @@ export function createHttpClient(config) {
     invoker.post = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "POST", path, body, extraHeaders);
     invoker.put = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "PUT", path, body, extraHeaders);
     invoker.patch = (path, body, extraHeaders = {}) => rawAs(defaultRawActor, "PATCH", path, body, extraHeaders);
-    invoker.delete = (path, extraHeaders = {}) =>
-      rawAs(defaultRawActor, "DELETE", path, null, extraHeaders);
+    invoker.delete = (path, body = null, extraHeaders = {}) =>
+      rawAs(defaultRawActor, "DELETE", path, body, extraHeaders);
     invoker.headers = (extraHeaders = {}) => resolvedRawHeadersFor(defaultRawActor, extraHeaders);
     invoker.as = (actorName) => {
       ensureKnownActor(actorName);
@@ -264,8 +264,8 @@ export function createHttpClient(config) {
     patch(path, body, extraHeaders = {}) {
       return defaultClient.patch(path, body, extraHeaders);
     },
-    delete(path, extraHeaders = {}) {
-      return defaultClient.delete(path, extraHeaders);
+    delete(path, body = null, extraHeaders = {}) {
+      return defaultClient.delete(path, body, extraHeaders);
     },
     rawGet(path, extraHeaders = {}) {
       return rawClient.get(path, extraHeaders);
@@ -279,8 +279,8 @@ export function createHttpClient(config) {
     rawPatch(path, body, extraHeaders = {}) {
       return rawClient.patch(path, body, extraHeaders);
     },
-    rawDelete(path, extraHeaders = {}) {
-      return rawClient.delete(path, extraHeaders);
+    rawDelete(path, body = null, extraHeaders = {}) {
+      return rawClient.delete(path, body, extraHeaders);
     },
     multipart: {
       post(path, payload, extraHeaders = {}) {
@@ -351,7 +351,7 @@ function runHttpRequest(method, path, url, body, headers, actorRecord = null, re
   else if (method === "PUT") rawResponse = http.put(url, requestBody, transportOptions);
   else if (method === "POST") rawResponse = http.post(url, requestBody, transportOptions);
   else if (method === "PATCH") rawResponse = http.patch(url, requestBody, transportOptions);
-  else if (method === "DELETE") rawResponse = http.del(url, null, transportOptions);
+  else if (method === "DELETE") rawResponse = http.del(url, requestBody, transportOptions);
   else throw new Error(`unsupported method: ${method}`);
 
   finalizeTrace(trace, rawResponse);

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.149",
+  "version": "0.1.151",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.149",
+  "version": "0.1.151",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.149"
+    "@elench/testkit-protocol": "0.1.151"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.149",
+  "version": "0.1.151",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.149",
+  "version": "0.1.151",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {