@shipfox/api-runners 6.0.0 → 7.0.2

package/drizzle/0000_initial.sql

@@ -2,18 +2,6 @@ CREATE TYPE "public"."runners_provider_runner_state" AS ENUM('starting', 'runnin
 CREATE TYPE "public"."runners_provisioner_scope" AS ENUM('workspace', 'installation');--> statement-breakpoint
 CREATE TYPE "public"."runners_runner_session_registration_token_kind" AS ENUM('manual', 'ephemeral', 'activation');--> statement-breakpoint
 CREATE TYPE "public"."runners_runner_session_scope" AS ENUM('workspace');--> statement-breakpoint
-CREATE TABLE "runners_capacity_assignments" (
-	"id" uuid PRIMARY KEY DEFAULT uuidv7() NOT NULL,
-	"capacity_id" uuid NOT NULL,
-	"reservation_id" uuid NOT NULL,
-	"workspace_id" uuid NOT NULL,
-	"provisioner_id" uuid NOT NULL,
-	"created_at" timestamp with time zone DEFAULT now() NOT NULL
-);
---> statement-breakpoint
-CREATE UNIQUE INDEX "runners_capacity_assignments_capacity_unique" ON "runners_capacity_assignments" USING btree ("capacity_id");--> statement-breakpoint
-CREATE INDEX "runners_capacity_assignments_reservation_idx" ON "runners_capacity_assignments" USING btree ("reservation_id");--> statement-breakpoint
-CREATE INDEX "runners_capacity_assignments_workspace_idx" ON "runners_capacity_assignments" USING btree ("workspace_id");--> statement-breakpoint
 CREATE TABLE "runners_ephemeral_registration_tokens" (
 	"id" uuid PRIMARY KEY DEFAULT uuidv7() NOT NULL,
 	"workspace_id" uuid,
@@ -73,6 +61,7 @@ CREATE TABLE "runners_runner_instances" (
 	"provisioner_id" uuid NOT NULL,
 	"provider_runner_id" text,
 	"reservation_id" uuid,
+	"assigned_at" timestamp with time zone,
 	"template_key" text,
 	"labels" text[] DEFAULT '{}' NOT NULL,
 	"state" "runners_provider_runner_state" NOT NULL,

package/drizzle/meta/0000_snapshot.json

@@ -4,103 +4,6 @@
   "version": "7",
   "dialect": "postgresql",
   "tables": {
-    "public.runners_capacity_assignments": {
-      "name": "runners_capacity_assignments",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "uuid",
-          "primaryKey": true,
-          "notNull": true,
-          "default": "uuidv7()"
-        },
-        "capacity_id": {
-          "name": "capacity_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "reservation_id": {
-          "name": "reservation_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "workspace_id": {
-          "name": "workspace_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "provisioner_id": {
-          "name": "provisioner_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp with time zone",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {
-        "runners_capacity_assignments_capacity_unique": {
-          "name": "runners_capacity_assignments_capacity_unique",
-          "columns": [
-            {
-              "expression": "capacity_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": true,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        },
-        "runners_capacity_assignments_reservation_idx": {
-          "name": "runners_capacity_assignments_reservation_idx",
-          "columns": [
-            {
-              "expression": "reservation_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        },
-        "runners_capacity_assignments_workspace_idx": {
-          "name": "runners_capacity_assignments_workspace_idx",
-          "columns": [
-            {
-              "expression": "workspace_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        }
-      },
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
     "public.runners_ephemeral_registration_tokens": {
       "name": "runners_ephemeral_registration_tokens",
       "schema": "",
@@ -852,6 +755,12 @@
           "primaryKey": false,
           "notNull": false
         },
+        "assigned_at": {
+          "name": "assigned_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
         "template_key": {
           "name": "template_key",
           "type": "text",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-runners",
   "license": "MIT",
-  "version": "6.0.0",
+  "version": "7.0.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -27,42 +27,21 @@
     "zod": "^4.4.3",
     "@shipfox/api-auth-context": "6.0.0",
     "@shipfox/api-auth-dto": "6.0.0",
-    "@shipfox/api-runners-dto": "6.0.0",
+    "@shipfox/api-runners-dto": "7.0.1",
     "@shipfox/api-workflows-dto": "6.0.0",
     "@shipfox/config": "1.2.2",
+    "@shipfox/inter-module": "0.2.0",
     "@shipfox/node-drizzle": "0.3.2",
-    "@shipfox/node-auth-root-key": "0.2.0",
+    "@shipfox/node-auth-root-key": "0.2.1",
     "@shipfox/node-fastify": "0.2.4",
+    "@shipfox/node-module": "0.4.0",
     "@shipfox/node-opentelemetry": "0.5.2",
     "@shipfox/node-outbox": "0.2.4",
-    "@shipfox/inter-module": "0.2.0",
-    "@shipfox/node-module": "0.4.0",
     "@shipfox/node-postgres": "0.4.2",
-    "@shipfox/node-tokens": "0.3.0",
+    "@shipfox/node-rate-limit": "0.3.0",
     "@shipfox/node-temporal": "0.3.2",
-    "@shipfox/runner-labels": "0.1.1",
-    "@shipfox/node-rate-limit": "0.3.0"
-  },
-  "devDependencies": {
-    "@temporalio/activity": "1.18.1",
-    "@temporalio/client": "1.18.1",
-    "@temporalio/common": "1.18.1",
-    "@temporalio/testing": "1.18.1",
-    "@temporalio/worker": "1.18.1",
-    "@types/pg": "^8.15.5",
-    "drizzle-kit": "^0.31.10",
-    "fastify": "^5.3.3",
-    "fastify-type-provider-zod": "^6.0.0",
-    "fishery": "^2.4.0",
-    "@shipfox/api-auth": "6.0.0",
-    "@shipfox/api-auth-dto": "6.0.0",
-    "@shipfox/biome": "1.8.2",
-    "@shipfox/depcruise": "1.0.2",
-    "@shipfox/node-jwt": "0.3.0",
-    "@shipfox/swc": "1.2.6",
-    "@shipfox/typescript": "1.1.7",
-    "@shipfox/vitest": "1.2.3",
-    "@shipfox/ts-config": "1.3.8"
+    "@shipfox/node-tokens": "0.3.0",
+    "@shipfox/runner-labels": "0.1.1"
   },
   "scripts": {
     "build": "shipfox-swc && shipfox-temporal-bundle dist/temporal/workflows/index.js",

package/src/config.ts

@@ -1,8 +1,8 @@
-import {REGISTRATION_TOKEN_BATCH_HARD_MAX} from '@shipfox/api-runners-dto';
 import {bool, createConfig, num} from '@shipfox/config';
 import {STUCK_JOB_THRESHOLD_SECONDS} from '#core/maintenance-policy.js';
 
 const EPHEMERAL_REGISTRATION_TOKEN_TTL_HARD_MAX_SECONDS = 3600;
+const REGISTRATION_TOKEN_BATCH_HARD_MAX = 1000;
 const RUNNER_CONTROL_PLANE_TOKEN_TTL_HARD_MAX_SECONDS = 3600;
 
 export const config = createConfig({

package/src/core/entities/runner-instance.ts

@@ -12,6 +12,7 @@ export interface RunnerInstance {
   provisionerId: string;
   providerRunnerId: string;
   reservationId: string | null;
+  assignedAt?: Date | null;
   templateKey: string | null;
   labels: string[];
   state: RunnerInstanceState;

package/src/core/errors.ts

@@ -86,16 +86,16 @@ export class ReservationExpiredError extends Error {
   }
 }
 
-export class CapacityNotAssignableError extends Error {
-  constructor(public readonly capacityId: string) {
-    super(`Capacity cannot be assigned: ${capacityId}`);
-    this.name = 'CapacityNotAssignableError';
+export class RunnerInstanceNotAssignableError extends Error {
+  constructor(public readonly runnerInstanceId: string) {
+    super(`Runner instance cannot be assigned: ${runnerInstanceId}`);
+    this.name = 'RunnerInstanceNotAssignableError';
   }
 }
-export class CapacityAlreadyAssignedError extends Error {
-  constructor(public readonly capacityId: string) {
-    super(`Capacity is already assigned: ${capacityId}`);
-    this.name = 'CapacityAlreadyAssignedError';
+export class RunnerInstanceAlreadyAssignedError extends Error {
+  constructor(public readonly runnerInstanceId: string) {
+    super(`Runner instance is already assigned: ${runnerInstanceId}`);
+    this.name = 'RunnerInstanceAlreadyAssignedError';
   }
 }
 export class ReservationAlreadyAssignedError extends Error {

package/src/core/index.ts

@@ -1,5 +1,3 @@
-export {assignCapacityBatch} from './capacity-assignments.js';
-export type {CapacityAssignment} from './entities/capacity-assignment.js';
 export type {EphemeralRegistrationToken} from './entities/ephemeral-registration-token.js';
 export type {ManualRegistrationToken} from './entities/manual-registration-token.js';
 export type {ProvisionerCapabilitySnapshot} from './entities/provisioner-capability-snapshot.js';
@@ -13,11 +11,6 @@ export type {
   RunnerInstanceState,
 } from './entities/runner-instance.js';
 export type {RunnerSession} from './entities/runner-session.js';
-export {
-  type MintEphemeralRegistrationTokenParams,
-  type MintEphemeralRegistrationTokenResult,
-  mintEphemeralRegistrationToken,
-} from './ephemeral-registration-tokens.js';
 export {
   EmptyRunnerLabelsError,
   ManualRegistrationTokenNotFoundError,
@@ -43,6 +36,7 @@ export {
   revokeWorkspaceProvisionerToken,
 } from './provisioner-tokens.js';
 export {getRunnerAssignment, issueRunnerActivationToken} from './runner-activation.js';
+export {assignRunnerInstances} from './runner-assignments.js';
 export {
   attachRunnerControlProviderId,
   createRunnerInstancesWithBootstrapTokens,
@@ -54,8 +48,7 @@ export {
 } from './runner-control-sessions.js';
 export {
   type ActiveRunner,
-  attachProviderRunnerId,
-  createPlannedProvisionedCapacity,
+  attachRunnerInstanceProviderId,
   listActiveRunners,
   type ReconcileDesiredIntent,
   type ReconciledBoundJobExecution,

package/src/core/runner-assignments.ts

@@ -0,0 +1,9 @@
+import {assignRunnerInstances as assignRunnerInstancesDb} from '#db/runner-assignments.js';
+
+export function assignRunnerInstances(params: {
+  provisionerId: string;
+  reservationId: string;
+  runnerInstanceIds: string[];
+}): Promise<string[]> {
+  return assignRunnerInstancesDb(params);
+}

package/src/core/runner-instances.ts

@@ -1,7 +1,6 @@
 import type {RunnerInstance, RunnerInstanceState} from '#core/entities/runner-instance.js';
 import {
-  attachProviderRunnerId as attachProviderRunnerIdDb,
-  createPlannedProvisionedCapacity as createPlannedProvisionedCapacityDb,
+  attachRunnerInstanceProviderId as attachRunnerInstanceProviderIdDb,
   isTerminalState,
   listActiveRunnerInstances,
   listActiveRunningJobExecutions,
@@ -29,20 +28,12 @@ export interface ReportRunnerInstancesParams {
   events: RunnerInstanceReportEvent[];
 }
 
-export function createPlannedProvisionedCapacity(params: {
-  provisionerId: string;
-  providerKind: string | null;
-  templateKey: string | null;
-}): Promise<{capacityId: string}> {
-  return createPlannedProvisionedCapacityDb(params);
-}
-
-export function attachProviderRunnerId(params: {
-  capacityId: string;
+export function attachRunnerInstanceProviderId(params: {
+  runnerInstanceId: string;
   provisionerId: string;
   providerRunnerId: string;
 }): Promise<boolean> {
-  return attachProviderRunnerIdDb(params);
+  return attachRunnerInstanceProviderIdDb(params);
 }
 
 export interface ReportRunnerInstancesResult {

package/src/db/db.ts

@@ -1,6 +1,5 @@
 import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';
 import {pgClient} from '@shipfox/node-postgres';
-import {capacityAssignments} from './schema/capacity-assignments.js';
 import {ephemeralRegistrationTokens} from './schema/ephemeral-registration-tokens.js';
 import {manualRegistrationTokens} from './schema/manual-registration-tokens.js';
 import {runnersOutbox} from './schema/outbox.js';
@@ -16,7 +15,6 @@ import {runnerSessions} from './schema/runner-sessions.js';
 import {runningJobExecutions} from './schema/running-job-executions.js';
 
 export const schema = {
-  capacityAssignments,
   ephemeralRegistrationTokens,
   pendingJobExecutions,
   providerRunners,

package/src/db/index.ts

@@ -1,7 +1,6 @@
 import {dirname, resolve} from 'node:path';
 import {fileURLToPath} from 'node:url';
 
-export {assignCapacityBatch} from './capacity-assignments.js';
 export {closeDb, db, schema} from './db.js';
 export type {
   CreateEphemeralRegistrationTokenParams,
@@ -67,6 +66,7 @@ export {
   pollDemandAndReserve,
   releaseReservationUnits,
 } from './reservations.js';
+export {assignRunnerInstances} from './runner-assignments.js';
 export type {
   ActiveRunnerInstanceTemplateCount,
   ReapStaleRunnerInstancesResult,
@@ -78,8 +78,7 @@ export type {
   RunnerInstanceTerminateIntentReason,
 } from './runner-instances.js';
 export {
-  attachProviderRunnerId,
-  createPlannedProvisionedCapacity,
+  attachRunnerInstanceProviderId,
   isTerminalState,
   listActiveRunnerInstanceCountsByTemplateTx,
   listActiveRunnerInstances,

package/src/db/runner-assignments.test.ts

@@ -0,0 +1,163 @@
+import {eq} from 'drizzle-orm';
+import {
+  ReservationExpiredError,
+  RunnerInstanceAlreadyAssignedError,
+  RunnerInstanceNotAssignableError,
+} from '#core/errors.js';
+import {db} from '#db/db.js';
+import {assignRunnerInstances} from '#db/runner-assignments.js';
+import {reservations} from '#db/schema/reservations.js';
+import {runnerControlSessions} from '#db/schema/runner-control-sessions.js';
+import {providerRunners} from '#db/schema/runner-instances.js';
+
+describe('assignRunnerInstances', () => {
+  let workspaceId: string;
+  let provisionerId: string;
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    provisionerId = crypto.randomUUID();
+  });
+
+  it('writes the reservation and workspace after enrollment', async () => {
+    const reservation = await createReservation();
+    const runner = await createEnrolledRunner();
+
+    const assigned = await assignRunnerInstances({
+      provisionerId,
+      reservationId: reservation.id,
+      runnerInstanceIds: [runner.id],
+    });
+
+    expect(assigned).toEqual([runner.id]);
+    const [stored] = await db()
+      .select()
+      .from(providerRunners)
+      .where(eq(providerRunners.id, runner.id));
+    expect(stored).toMatchObject({
+      workspaceId,
+      reservationId: reservation.id,
+      assignedAt: expect.any(Date),
+    });
+  });
+
+  it('is idempotent for concurrent retries of the same assignment', async () => {
+    const reservation = await createReservation();
+    const runner = await createEnrolledRunner();
+
+    const results = await Promise.all([
+      assignRunnerInstances({
+        provisionerId,
+        reservationId: reservation.id,
+        runnerInstanceIds: [runner.id],
+      }),
+      assignRunnerInstances({
+        provisionerId,
+        reservationId: reservation.id,
+        runnerInstanceIds: [runner.id],
+      }),
+    ]);
+
+    expect(results).toEqual([[runner.id], [runner.id]]);
+  });
+
+  it('rejects expired reservations', async () => {
+    const reservation = await createReservation({expiresAt: new Date(Date.now() - 1_000)});
+    const runner = await createEnrolledRunner();
+
+    const assignment = assignRunnerInstances({
+      provisionerId,
+      reservationId: reservation.id,
+      runnerInstanceIds: [runner.id],
+    });
+
+    await expect(assignment).rejects.toThrow(ReservationExpiredError);
+  });
+
+  it('rejects unenrolled or incompatible runners', async () => {
+    const reservation = await createReservation({requiredLabels: ['linux', 'gpu']});
+    const runner = await createEnrolledRunner({labels: ['linux']});
+
+    const assignment = assignRunnerInstances({
+      provisionerId,
+      reservationId: reservation.id,
+      runnerInstanceIds: [runner.id],
+    });
+
+    await expect(assignment).rejects.toThrow(RunnerInstanceNotAssignableError);
+  });
+
+  it('rejects a runner assigned to a different reservation', async () => {
+    const firstReservation = await createReservation();
+    const secondReservation = await createReservation();
+    const runner = await createEnrolledRunner();
+    await assignRunnerInstances({
+      provisionerId,
+      reservationId: firstReservation.id,
+      runnerInstanceIds: [runner.id],
+    });
+
+    const assignment = assignRunnerInstances({
+      provisionerId,
+      reservationId: secondReservation.id,
+      runnerInstanceIds: [runner.id],
+    });
+
+    await expect(assignment).rejects.toThrow(RunnerInstanceAlreadyAssignedError);
+  });
+
+  it('rejects assignments that exceed reservation capacity', async () => {
+    const reservation = await createReservation();
+    const firstRunner = await createEnrolledRunner();
+    const secondRunner = await createEnrolledRunner();
+
+    const assignment = assignRunnerInstances({
+      provisionerId,
+      reservationId: reservation.id,
+      runnerInstanceIds: [firstRunner.id, secondRunner.id],
+    });
+
+    await expect(assignment).rejects.toThrow(RunnerInstanceNotAssignableError);
+  });
+
+  async function createReservation(
+    overrides: Partial<{expiresAt: Date; requiredLabels: string[]}> = {},
+  ) {
+    const [reservation] = await db()
+      .insert(reservations)
+      .values({
+        workspaceId,
+        provisionerId,
+        requiredLabels: overrides.requiredLabels ?? ['linux'],
+        count: 1,
+        expiresAt: overrides.expiresAt ?? new Date(Date.now() + 60_000),
+      })
+      .returning();
+    if (!reservation) throw new Error('Reservation insert returned no row');
+    return reservation;
+  }
+
+  async function createEnrolledRunner(overrides: Partial<{labels: string[]}> = {}) {
+    const [runner] = await db()
+      .insert(providerRunners)
+      .values({
+        provisionerId,
+        providerRunnerId: crypto.randomUUID(),
+        labels: overrides.labels ?? ['linux'],
+        state: 'running',
+        reportedAt: new Date(),
+      })
+      .returning();
+    if (!runner) throw new Error('Runner instance insert returned no row');
+    await db()
+      .insert(runnerControlSessions)
+      .values({
+        runnerInstanceId: runner.id,
+        provisionerId,
+        hashedToken: crypto.randomUUID(),
+        prefix: 'test',
+        expiresAt: new Date(Date.now() + 60_000),
+      });
+    return runner;
+  }
+});

package/src/db/runner-assignments.ts

@@ -0,0 +1,115 @@
+import {and, eq, inArray, isNull, sql} from 'drizzle-orm';
+import {
+  ReservationExpiredError,
+  ReservationNotFoundError,
+  RunnerInstanceAlreadyAssignedError,
+  RunnerInstanceNotAssignableError,
+} from '#core/errors.js';
+import {db} from './db.js';
+import {reservations} from './schema/reservations.js';
+import {runnerControlSessions} from './schema/runner-control-sessions.js';
+import {providerRunners} from './schema/runner-instances.js';
+
+/** Atomically consumes reservation units by writing the immutable assignment on each runner. */
+export async function assignRunnerInstances(params: {
+  provisionerId: string;
+  reservationId: string;
+  runnerInstanceIds: string[];
+}): Promise<string[]> {
+  const runnerInstanceIds = [...params.runnerInstanceIds].sort();
+  return await db().transaction(async (tx) => {
+    await tx.execute(
+      sql`select pg_advisory_xact_lock(hashtext(${`runners_assignment:${params.provisionerId}:${params.reservationId}`}))`,
+    );
+    const [reservation] = await tx
+      .select()
+      .from(reservations)
+      .where(
+        and(
+          eq(reservations.id, params.reservationId),
+          eq(reservations.provisionerId, params.provisionerId),
+        ),
+      )
+      .limit(1)
+      .for('update');
+    if (!reservation) throw new ReservationNotFoundError(params.reservationId);
+    if (reservation.expiresAt <= new Date())
+      throw new ReservationExpiredError(params.reservationId);
+
+    const runnerRows = await tx
+      .select({
+        id: providerRunners.id,
+        reservationId: providerRunners.reservationId,
+        workspaceId: providerRunners.workspaceId,
+        providerRunnerId: providerRunners.providerRunnerId,
+        labels: providerRunners.labels,
+        state: providerRunners.state,
+      })
+      .from(providerRunners)
+      .where(
+        and(
+          eq(providerRunners.provisionerId, params.provisionerId),
+          inArray(providerRunners.id, runnerInstanceIds),
+        ),
+      )
+      .for('update');
+    const activeControlSessions = await tx
+      .select({runnerInstanceId: runnerControlSessions.runnerInstanceId})
+      .from(runnerControlSessions)
+      .where(
+        and(
+          inArray(
+            runnerControlSessions.runnerInstanceId,
+            runnerRows.map((runner) => runner.id),
+          ),
+          isNull(runnerControlSessions.closedAt),
+        ),
+      );
+    const runnerInstanceIdsWithControlSession = new Set(
+      activeControlSessions.map((session) => session.runnerInstanceId),
+    );
+    const runners = runnerRows.map((runner) => ({
+      ...runner,
+      controlSessionId: runnerInstanceIdsWithControlSession.has(runner.id) ? runner.id : null,
+    }));
+    if (runners.length !== runnerInstanceIds.length)
+      throw new RunnerInstanceNotAssignableError(runnerInstanceIds[0] ?? '');
+
+    const alreadyAssigned = runners.filter((runner) => runner.reservationId !== null);
+    if (alreadyAssigned.some((runner) => runner.reservationId !== reservation.id))
+      throw new RunnerInstanceAlreadyAssignedError(alreadyAssigned[0]?.id ?? '');
+    const newRunners = runners.filter((runner) => runner.reservationId === null);
+    const assignedCount = await tx
+      .select({count: sql<number>`count(*)::int`})
+      .from(providerRunners)
+      .where(eq(providerRunners.reservationId, reservation.id));
+    if ((assignedCount[0]?.count ?? 0) + newRunners.length > reservation.count)
+      throw new RunnerInstanceNotAssignableError(newRunners[0]?.id ?? '');
+    for (const runner of newRunners) {
+      if (
+        runner.state !== 'running' ||
+        !runner.providerRunnerId ||
+        !runner.controlSessionId ||
+        !reservation.requiredLabels.every((label) => runner.labels.includes(label))
+      )
+        throw new RunnerInstanceNotAssignableError(runner.id);
+    }
+    if (newRunners.length > 0) {
+      await tx
+        .update(providerRunners)
+        .set({
+          workspaceId: reservation.workspaceId,
+          reservationId: reservation.id,
+          assignedAt: sql`now()`,
+          updatedAt: sql`now()`,
+        })
+        .where(
+          inArray(
+            providerRunners.id,
+            newRunners.map((runner) => runner.id),
+          ),
+        );
+    }
+    return params.runnerInstanceIds;
+  });
+}