@shipfox/api-runners 12.1.0 → 12.3.0

package/dist/db/schema/runner-instances.d.ts

@@ -175,8 +175,8 @@ export declare const providerRunners: import("drizzle-orm/pg-core").PgTableWithC
         }, {}, {
             baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
                 name: "labels";
-                dataType: "string";
-                columnType: "PgText";
+                dataType: 'string';
+                columnType: 'PgText';
                 data: string;
                 enumValues: [string, ...string[]];
                 driverParam: string;
@@ -188,7 +188,7 @@ export declare const providerRunners: import("drizzle-orm/pg-core").PgTableWithC
             tableName: "runner_instances";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "starting" | "running" | "stopping" | "stopped" | "failed" | "terminated";
+            data: "failed" | "running" | "starting" | "stopped" | "stopping" | "terminated";
             driverParam: string;
             notNull: true;
             hasDefault: false;
@@ -476,7 +476,7 @@ export declare const providerRunners: import("drizzle-orm/pg-core").PgTableWithC
             generated: undefined;
         }, {}, {}>;
     };
-    dialect: "pg";
+    dialect: 'pg';
 }>;
 export type RunnerInstanceDb = typeof providerRunners.$inferSelect;
 export type RunnerInstanceInsertDb = typeof providerRunners.$inferInsert;

package/dist/db/schema/runner-instances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner-instances.d.ts","sourceRoot":"","sources":["../../../src/db/schema/runner-instances.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,mCAAmC,CAAC;AAGtE,eAAO,MAAM,uBAAuB,8GAOlC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqD3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AACnE,MAAM,MAAM,sBAAsB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AAEzE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,cAAc,CAyBtE"}
+{"version":3,"file":"runner-instances.d.ts","sourceRoot":"","sources":["../../../src/db/schema/runner-instances.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,mCAAmC,CAAC;AAGtE,eAAO,MAAM,uBAAuB,8GAOlC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwD3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AACnE,MAAM,MAAM,sBAAsB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AAEzE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,cAAc,CAyBtE"}

package/dist/db/schema/runner-instances.js

@@ -65,6 +65,7 @@ export const providerRunners = pgTable('runner_instances', {
         index('runners_runner_instances_workspace_state_updated_idx').on(table.state, table.updatedAt),
         index('runners_runner_instances_stale_reaper_idx').on(table.state, table.updatedAt, table.reportedAt),
         index('runners_runner_instances_provisioner_intended_reservation_idx').on(table.provisionerId, table.intendedReservationId).where(sql`${table.intendedReservationId} is not null and ${table.reservationReleasedAt} is null`),
+        index('runners_runner_instances_intended_reservation_idx').on(table.intendedReservationId).where(sql`${table.intendedReservationId} is not null`),
         index('runners_runner_instances_provisioner_reservation_idx').on(table.provisionerId, table.reservationId).where(sql`${table.reservationId} is not null`),
         index('runners_runner_instances_active_template_counts_idx').on(table.provisionerId, table.state, table.templateKey).where(sql`"state" in ('starting', 'running') and "template_key" is not null`)
     ]);

package/dist/db/schema/runner-instances.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/db/schema/runner-instances.ts"],"sourcesContent":["import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';\nimport {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {RunnerInstance} from '#core/entities/runner-instance.js';\nimport {pgTable} from './common.js';\n\nexport const providerRunnerStateEnum = pgEnum('runners_provider_runner_state', [\n  'starting',\n  'running',\n  'stopping',\n  'stopped',\n  'failed',\n  'terminated',\n]);\n\nexport const providerRunners = pgTable(\n  'runner_instances',\n  {\n    id: uuidv7PrimaryKey(),\n    // Kept during the protocol migration for legacy workspace capacity. New capacity is owned\n    // only by its provisioner and has no workspace assignment.\n    workspaceId: uuid('workspace_id'),\n    provisionerId: uuid('provisioner_id').notNull(),\n    providerRunnerId: text('provider_runner_id'),\n    intendedReservationId: uuid('intended_reservation_id'),\n    reservationId: uuid('reservation_id'),\n    assignedAt: timestamp('assigned_at', {withTimezone: true}),\n    templateKey: text('template_key'),\n    labels: text('labels').array().notNull().default([]),\n    state: providerRunnerStateEnum('state').notNull(),\n    reason: text('reason'),\n    runnerSessionId: uuid('runner_session_id'),\n    firstClaimedAt: timestamp('first_claimed_at', {withTimezone: true}),\n    providerKind: text('provider_kind'),\n    protocolVersion: text('protocol_version'),\n    capabilities: jsonb('capabilities').$type<RunnerToolCapabilitiesDto | null>(),\n    reportedAt: timestamp('reported_at', {withTimezone: true}).notNull(),\n    startedAt: timestamp('started_at', {withTimezone: true}),\n    stoppingAt: timestamp('stopping_at', {withTimezone: true}),\n    stoppedAt: timestamp('stopped_at', {withTimezone: true}),\n    failedAt: timestamp('failed_at', {withTimezone: true}),\n    terminatedAt: timestamp('terminated_at', {withTimezone: true}),\n    reservationReleasedAt: timestamp('reservation_released_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_runner_instances_provisioner_runner_unique')\n      .on(table.provisionerId, table.providerRunnerId)\n      .where(sql`${table.providerRunnerId} is not null`),\n    index('runners_runner_instances_workspace_state_updated_idx').on(table.state, table.updatedAt),\n    index('runners_runner_instances_stale_reaper_idx').on(\n      table.state,\n      table.updatedAt,\n      table.reportedAt,\n    ),\n    index('runners_runner_instances_provisioner_intended_reservation_idx')\n      .on(table.provisionerId, table.intendedReservationId)\n      .where(\n        sql`${table.intendedReservationId} is not null and ${table.reservationReleasedAt} is null`,\n      ),\n    index('runners_runner_instances_provisioner_reservation_idx')\n      .on(table.provisionerId, table.reservationId)\n      .where(sql`${table.reservationId} is not null`),\n    index('runners_runner_instances_active_template_counts_idx')\n      .on(table.provisionerId, table.state, table.templateKey)\n      .where(sql`\"state\" in ('starting', 'running') and \"template_key\" is not null`),\n  ],\n);\n\nexport type RunnerInstanceDb = typeof providerRunners.$inferSelect;\nexport type RunnerInstanceInsertDb = typeof providerRunners.$inferInsert;\n\nexport function toRunnerInstance(row: RunnerInstanceDb): RunnerInstance {\n  if (!row.providerRunnerId) throw new Error('Runner instance has no provider runner identity');\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    provisionerId: row.provisionerId,\n    providerRunnerId: row.providerRunnerId,\n    reservationId: row.reservationId,\n    assignedAt: row.assignedAt,\n    templateKey: row.templateKey,\n    labels: row.labels,\n    state: row.state,\n    reason: row.reason,\n    runnerSessionId: row.runnerSessionId,\n    providerKind: row.providerKind,\n    reportedAt: row.reportedAt,\n    startedAt: row.startedAt,\n    stoppingAt: row.stoppingAt,\n    stoppedAt: row.stoppedAt,\n    failedAt: row.failedAt,\n    terminatedAt: row.terminatedAt,\n    reservationReleasedAt: row.reservationReleasedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","index","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","providerRunnerStateEnum","providerRunners","id","workspaceId","provisionerId","notNull","providerRunnerId","intendedReservationId","reservationId","assignedAt","withTimezone","templateKey","labels","array","default","state","reason","runnerSessionId","firstClaimedAt","providerKind","protocolVersion","capabilities","$type","reportedAt","startedAt","stoppingAt","stoppedAt","failedAt","terminatedAt","reservationReleasedAt","createdAt","defaultNow","updatedAt","table","on","where","toRunnerInstance","row","Error"],"mappings":"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"}
+{"version":3,"sources":["../../../src/db/schema/runner-instances.ts"],"sourcesContent":["import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';\nimport {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {RunnerInstance} from '#core/entities/runner-instance.js';\nimport {pgTable} from './common.js';\n\nexport const providerRunnerStateEnum = pgEnum('runners_provider_runner_state', [\n  'starting',\n  'running',\n  'stopping',\n  'stopped',\n  'failed',\n  'terminated',\n]);\n\nexport const providerRunners = pgTable(\n  'runner_instances',\n  {\n    id: uuidv7PrimaryKey(),\n    // Kept during the protocol migration for legacy workspace capacity. New capacity is owned\n    // only by its provisioner and has no workspace assignment.\n    workspaceId: uuid('workspace_id'),\n    provisionerId: uuid('provisioner_id').notNull(),\n    providerRunnerId: text('provider_runner_id'),\n    intendedReservationId: uuid('intended_reservation_id'),\n    reservationId: uuid('reservation_id'),\n    assignedAt: timestamp('assigned_at', {withTimezone: true}),\n    templateKey: text('template_key'),\n    labels: text('labels').array().notNull().default([]),\n    state: providerRunnerStateEnum('state').notNull(),\n    reason: text('reason'),\n    runnerSessionId: uuid('runner_session_id'),\n    firstClaimedAt: timestamp('first_claimed_at', {withTimezone: true}),\n    providerKind: text('provider_kind'),\n    protocolVersion: text('protocol_version'),\n    capabilities: jsonb('capabilities').$type<RunnerToolCapabilitiesDto | null>(),\n    reportedAt: timestamp('reported_at', {withTimezone: true}).notNull(),\n    startedAt: timestamp('started_at', {withTimezone: true}),\n    stoppingAt: timestamp('stopping_at', {withTimezone: true}),\n    stoppedAt: timestamp('stopped_at', {withTimezone: true}),\n    failedAt: timestamp('failed_at', {withTimezone: true}),\n    terminatedAt: timestamp('terminated_at', {withTimezone: true}),\n    reservationReleasedAt: timestamp('reservation_released_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_runner_instances_provisioner_runner_unique')\n      .on(table.provisionerId, table.providerRunnerId)\n      .where(sql`${table.providerRunnerId} is not null`),\n    index('runners_runner_instances_workspace_state_updated_idx').on(table.state, table.updatedAt),\n    index('runners_runner_instances_stale_reaper_idx').on(\n      table.state,\n      table.updatedAt,\n      table.reportedAt,\n    ),\n    index('runners_runner_instances_provisioner_intended_reservation_idx')\n      .on(table.provisionerId, table.intendedReservationId)\n      .where(\n        sql`${table.intendedReservationId} is not null and ${table.reservationReleasedAt} is null`,\n      ),\n    index('runners_runner_instances_intended_reservation_idx')\n      .on(table.intendedReservationId)\n      .where(sql`${table.intendedReservationId} is not null`),\n    index('runners_runner_instances_provisioner_reservation_idx')\n      .on(table.provisionerId, table.reservationId)\n      .where(sql`${table.reservationId} is not null`),\n    index('runners_runner_instances_active_template_counts_idx')\n      .on(table.provisionerId, table.state, table.templateKey)\n      .where(sql`\"state\" in ('starting', 'running') and \"template_key\" is not null`),\n  ],\n);\n\nexport type RunnerInstanceDb = typeof providerRunners.$inferSelect;\nexport type RunnerInstanceInsertDb = typeof providerRunners.$inferInsert;\n\nexport function toRunnerInstance(row: RunnerInstanceDb): RunnerInstance {\n  if (!row.providerRunnerId) throw new Error('Runner instance has no provider runner identity');\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    provisionerId: row.provisionerId,\n    providerRunnerId: row.providerRunnerId,\n    reservationId: row.reservationId,\n    assignedAt: row.assignedAt,\n    templateKey: row.templateKey,\n    labels: row.labels,\n    state: row.state,\n    reason: row.reason,\n    runnerSessionId: row.runnerSessionId,\n    providerKind: row.providerKind,\n    reportedAt: row.reportedAt,\n    startedAt: row.startedAt,\n    stoppingAt: row.stoppingAt,\n    stoppedAt: row.stoppedAt,\n    failedAt: row.failedAt,\n    terminatedAt: row.terminatedAt,\n    reservationReleasedAt: row.reservationReleasedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","index","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","providerRunnerStateEnum","providerRunners","id","workspaceId","provisionerId","notNull","providerRunnerId","intendedReservationId","reservationId","assignedAt","withTimezone","templateKey","labels","array","default","state","reason","runnerSessionId","firstClaimedAt","providerKind","protocolVersion","capabilities","$type","reportedAt","startedAt","stoppingAt","stoppedAt","failedAt","terminatedAt","reservationReleasedAt","createdAt","defaultNow","updatedAt","table","on","where","toRunnerInstance","row","Error"],"mappings":"AACA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,KAAK,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE7F,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,0BAA0BN,OAAO,iCAAiC;IAC7E;IACA;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMO,kBAAkBF,QAC7B,oBACA;IACEG,IAAIZ;IACJ,0FAA0F;IAC1F,2DAA2D;IAC3Da,aAAaL,KAAK;IAClBM,eAAeN,KAAK,kBAAkBO,OAAO;IAC7CC,kBAAkBX,KAAK;IACvBY,uBAAuBT,KAAK;IAC5BU,eAAeV,KAAK;IACpBW,YAAYb,UAAU,eAAe;QAACc,cAAc;IAAI;IACxDC,aAAahB,KAAK;IAClBiB,QAAQjB,KAAK,UAAUkB,KAAK,GAAGR,OAAO,GAAGS,OAAO,CAAC,EAAE;IACnDC,OAAOf,wBAAwB,SAASK,OAAO;IAC/CW,QAAQrB,KAAK;IACbsB,iBAAiBnB,KAAK;IACtBoB,gBAAgBtB,UAAU,oBAAoB;QAACc,cAAc;IAAI;IACjES,cAAcxB,KAAK;IACnByB,iBAAiBzB,KAAK;IACtB0B,cAAc5B,MAAM,gBAAgB6B,KAAK;IACzCC,YAAY3B,UAAU,eAAe;QAACc,cAAc;IAAI,GAAGL,OAAO;IAClEmB,WAAW5B,UAAU,cAAc;QAACc,cAAc;IAAI;IACtDe,YAAY7B,UAAU,eAAe;QAACc,cAAc;IAAI;IACxDgB,WAAW9B,UAAU,cAAc;QAACc,cAAc;IAAI;IACtDiB,UAAU/B,UAAU,aAAa;QAACc,cAAc;IAAI;IACpDkB,cAAchC,UAAU,iBAAiB;QAACc,cAAc;IAAI;IAC5DmB,uBAAuBjC,UAAU,2BAA2B;QAACc,cAAc;IAAI;IAC/EoB,WAAWlC,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGL,OAAO,GAAG0B,UAAU;IAC7EC,WAAWpC,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGL,OAAO,GAAG0B,UAAU;AAC/E,GACA,CAACE,QAAU;QACTpC,YAAY,sDACTqC,EAAE,CAACD,MAAM7B,aAAa,EAAE6B,MAAM3B,gBAAgB,EAC9C6B,KAAK,CAAC5C,GAAG,CAAC,EAAE0C,MAAM3B,gBAAgB,CAAC,YAAY,CAAC;QACnDd,MAAM,wDAAwD0C,EAAE,CAACD,MAAMlB,KAAK,EAAEkB,MAAMD,SAAS;QAC7FxC,MAAM,6CAA6C0C,EAAE,CACnDD,MAAMlB,KAAK,EACXkB,MAAMD,SAAS,EACfC,MAAMV,UAAU;QAElB/B,MAAM,iEACH0C,EAAE,CAACD,MAAM7B,aAAa,EAAE6B,MAAM1B,qBAAqB,EACnD4B,KAAK,CACJ5C,GAAG,CAAC,EAAE0C,MAAM1B,qBAAqB,CAAC,iBAAiB,EAAE0B,MAAMJ,qBAAqB,CAAC,QAAQ,CAAC;QAE9FrC,MAAM,qDACH0C,EAAE,CAACD,MAAM1B,qBAAqB,EAC9B4B,KAAK,CAAC5C,GAAG,CAAC,EAAE0C,MAAM1B,qBAAqB,CAAC,YAAY,CAAC;QACxDf,MAAM,wDACH0C,EAAE,CAACD,MAAM7B,aAAa,EAAE6B,MAAMzB,aAAa,EAC3C2B,KAAK,CAAC5C,GAAG,CAAC,EAAE0C,MAAMzB,aAAa,CAAC,YAAY,CAAC;QAChDhB,MAAM,uDACH0C,EAAE,CAACD,MAAM7B,aAAa,EAAE6B,MAAMlB,KAAK,EAAEkB,MAAMtB,WAAW,EACtDwB,KAAK,CAAC5C,GAAG,CAAC,iEAAiE,CAAC;KAChF,EACD;AAKF,OAAO,SAAS6C,iBAAiBC,GAAqB;IACpD,IAAI,CAACA,IAAI/B,gBAAgB,EAAE,MAAM,IAAIgC,MAAM;IAC3C,OAAO;QACLpC,IAAImC,IAAInC,EAAE;QACVC,aAAakC,IAAIlC,WAAW;QAC5BC,eAAeiC,IAAIjC,aAAa;QAChCE,kBAAkB+B,IAAI/B,gBAAgB;QACtCE,eAAe6B,IAAI7B,aAAa;QAChCC,YAAY4B,IAAI5B,UAAU;QAC1BE,aAAa0B,IAAI1B,WAAW;QAC5BC,QAAQyB,IAAIzB,MAAM;QAClBG,OAAOsB,IAAItB,KAAK;QAChBC,QAAQqB,IAAIrB,MAAM;QAClBC,iBAAiBoB,IAAIpB,eAAe;QACpCE,cAAckB,IAAIlB,YAAY;QAC9BI,YAAYc,IAAId,UAAU;QAC1BC,WAAWa,IAAIb,SAAS;QACxBC,YAAYY,IAAIZ,UAAU;QAC1BC,WAAWW,IAAIX,SAAS;QACxBC,UAAUU,IAAIV,QAAQ;QACtBC,cAAcS,IAAIT,YAAY;QAC9BC,uBAAuBQ,IAAIR,qBAAqB;QAChDC,WAAWO,IAAIP,SAAS;QACxBE,WAAWK,IAAIL,SAAS;IAC1B;AACF"}

package/dist/db/schema/runner-sessions.d.ts

@@ -78,7 +78,7 @@ export declare const runnerSessions: import("drizzle-orm/pg-core").PgTableWithCo
             tableName: "runner_sessions";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "manual" | "ephemeral" | "activation";
+            data: "activation" | "ephemeral" | "manual";
             driverParam: string;
             notNull: true;
             hasDefault: false;
@@ -176,8 +176,8 @@ export declare const runnerSessions: import("drizzle-orm/pg-core").PgTableWithCo
         }, {}, {
             baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
                 name: "labels";
-                dataType: "string";
-                columnType: "PgText";
+                dataType: 'string';
+                columnType: 'PgText';
                 data: string;
                 enumValues: [string, ...string[]];
                 driverParam: string;
@@ -324,7 +324,7 @@ export declare const runnerSessions: import("drizzle-orm/pg-core").PgTableWithCo
             generated: undefined;
         }, {}, {}>;
     };
-    dialect: "pg";
+    dialect: 'pg';
 }>;
 export type RunnerSessionDb = typeof runnerSessions.$inferSelect;
 export type RunnerSessionInsertDb = typeof runnerSessions.$inferInsert;

package/dist/db/schema/running-job-executions.d.ts

@@ -207,8 +207,8 @@ export declare const runningJobExecutions: import("drizzle-orm/pg-core").PgTable
         }, {}, {
             baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
                 name: "required_labels";
-                dataType: "string";
-                columnType: "PgText";
+                dataType: 'string';
+                columnType: 'PgText';
                 data: string;
                 enumValues: [string, ...string[]];
                 driverParam: string;
@@ -250,8 +250,8 @@ export declare const runningJobExecutions: import("drizzle-orm/pg-core").PgTable
         }, {}, {
             baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
                 name: "runner_labels";
-                dataType: "string";
-                columnType: "PgText";
+                dataType: 'string';
+                columnType: 'PgText';
                 data: string;
                 enumValues: [string, ...string[]];
                 driverParam: string;
@@ -327,7 +327,7 @@ export declare const runningJobExecutions: import("drizzle-orm/pg-core").PgTable
             generated: undefined;
         }, {}, {}>;
     };
-    dialect: "pg";
+    dialect: 'pg';
 }>;
 export type RunningJobExecutionDb = typeof runningJobExecutions.$inferSelect;
 export type RunningJobExecutionInsertDb = typeof runningJobExecutions.$inferInsert;

package/dist/metrics/index.d.ts

@@ -1,3 +1,4 @@
-export { jobExecutionClaimedCount, jobExecutionEnqueuedCount, jobExecutionLeaseExpiredCount, providerRunnerAbsentTerminatedCount, providerRunnerCountDivergenceCount, providerRunnerReconcileCallCount, providerRunnerTerminateIntentHonoredCount, providerRunnerTerminateIntentIssuedCount, recordRunnersRateLimitCheck, recordRunnersRateLimitPruneFailure, } from './instance.js';
+export type { RunnerReservationPromotionFailureReason } from './instance.js';
+export { jobExecutionClaimedCount, jobExecutionEnqueuedCount, jobExecutionLeaseExpiredCount, providerRunnerAbsentTerminatedCount, providerRunnerCountDivergenceCount, providerRunnerReconcileCallCount, providerRunnerTerminateIntentHonoredCount, providerRunnerTerminateIntentIssuedCount, recordRunnerReservationPromotionFailure, recordRunnersRateLimitCheck, recordRunnersRateLimitPruneFailure, } from './instance.js';
 export { registerRunnersServiceMetrics } from './service.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/metrics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/metrics/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,EAC7B,mCAAmC,EACnC,kCAAkC,EAClC,gCAAgC,EAChC,yCAAyC,EACzC,wCAAwC,EACxC,2BAA2B,EAC3B,kCAAkC,GACnC,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,6BAA6B,EAAC,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/metrics/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAC,uCAAuC,EAAC,MAAM,eAAe,CAAC;AAC3E,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,EAC7B,mCAAmC,EACnC,kCAAkC,EAClC,gCAAgC,EAChC,yCAAyC,EACzC,wCAAwC,EACxC,uCAAuC,EACvC,2BAA2B,EAC3B,kCAAkC,GACnC,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,6BAA6B,EAAC,MAAM,cAAc,CAAC"}

package/dist/metrics/index.js

@@ -1,4 +1,4 @@
-export { jobExecutionClaimedCount, jobExecutionEnqueuedCount, jobExecutionLeaseExpiredCount, providerRunnerAbsentTerminatedCount, providerRunnerCountDivergenceCount, providerRunnerReconcileCallCount, providerRunnerTerminateIntentHonoredCount, providerRunnerTerminateIntentIssuedCount, recordRunnersRateLimitCheck, recordRunnersRateLimitPruneFailure } from './instance.js';
+export { jobExecutionClaimedCount, jobExecutionEnqueuedCount, jobExecutionLeaseExpiredCount, providerRunnerAbsentTerminatedCount, providerRunnerCountDivergenceCount, providerRunnerReconcileCallCount, providerRunnerTerminateIntentHonoredCount, providerRunnerTerminateIntentIssuedCount, recordRunnerReservationPromotionFailure, recordRunnersRateLimitCheck, recordRunnersRateLimitPruneFailure } from './instance.js';
 export { registerRunnersServiceMetrics } from './service.js';
 
 //# sourceMappingURL=index.js.map

package/dist/metrics/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/metrics/index.ts"],"sourcesContent":["export {\n  jobExecutionClaimedCount,\n  jobExecutionEnqueuedCount,\n  jobExecutionLeaseExpiredCount,\n  providerRunnerAbsentTerminatedCount,\n  providerRunnerCountDivergenceCount,\n  providerRunnerReconcileCallCount,\n  providerRunnerTerminateIntentHonoredCount,\n  providerRunnerTerminateIntentIssuedCount,\n  recordRunnersRateLimitCheck,\n  recordRunnersRateLimitPruneFailure,\n} from './instance.js';\nexport {registerRunnersServiceMetrics} from './service.js';\n"],"names":["jobExecutionClaimedCount","jobExecutionEnqueuedCount","jobExecutionLeaseExpiredCount","providerRunnerAbsentTerminatedCount","providerRunnerCountDivergenceCount","providerRunnerReconcileCallCount","providerRunnerTerminateIntentHonoredCount","providerRunnerTerminateIntentIssuedCount","recordRunnersRateLimitCheck","recordRunnersRateLimitPruneFailure","registerRunnersServiceMetrics"],"mappings":"AAAA,SACEA,wBAAwB,EACxBC,yBAAyB,EACzBC,6BAA6B,EAC7BC,mCAAmC,EACnCC,kCAAkC,EAClCC,gCAAgC,EAChCC,yCAAyC,EACzCC,wCAAwC,EACxCC,2BAA2B,EAC3BC,kCAAkC,QAC7B,gBAAgB;AACvB,SAAQC,6BAA6B,QAAO,eAAe"}
+{"version":3,"sources":["../../src/metrics/index.ts"],"sourcesContent":["export type {RunnerReservationPromotionFailureReason} from './instance.js';\nexport {\n  jobExecutionClaimedCount,\n  jobExecutionEnqueuedCount,\n  jobExecutionLeaseExpiredCount,\n  providerRunnerAbsentTerminatedCount,\n  providerRunnerCountDivergenceCount,\n  providerRunnerReconcileCallCount,\n  providerRunnerTerminateIntentHonoredCount,\n  providerRunnerTerminateIntentIssuedCount,\n  recordRunnerReservationPromotionFailure,\n  recordRunnersRateLimitCheck,\n  recordRunnersRateLimitPruneFailure,\n} from './instance.js';\nexport {registerRunnersServiceMetrics} from './service.js';\n"],"names":["jobExecutionClaimedCount","jobExecutionEnqueuedCount","jobExecutionLeaseExpiredCount","providerRunnerAbsentTerminatedCount","providerRunnerCountDivergenceCount","providerRunnerReconcileCallCount","providerRunnerTerminateIntentHonoredCount","providerRunnerTerminateIntentIssuedCount","recordRunnerReservationPromotionFailure","recordRunnersRateLimitCheck","recordRunnersRateLimitPruneFailure","registerRunnersServiceMetrics"],"mappings":"AACA,SACEA,wBAAwB,EACxBC,yBAAyB,EACzBC,6BAA6B,EAC7BC,mCAAmC,EACnCC,kCAAkC,EAClCC,gCAAgC,EAChCC,yCAAyC,EACzCC,wCAAwC,EACxCC,uCAAuC,EACvCC,2BAA2B,EAC3BC,kCAAkC,QAC7B,gBAAgB;AACvB,SAAQC,6BAA6B,QAAO,eAAe"}

package/dist/metrics/instance.d.ts

@@ -1,34 +1,39 @@
 export declare const jobExecutionEnqueuedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
 export declare const jobExecutionClaimedCount: import("@shipfox/node-opentelemetry").Counter<{
-    outcome: "claimed" | "empty";
+    outcome: 'claimed' | 'empty';
 }>;
 export declare const jobExecutionLeaseExpiredCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
 export declare const providerRunnerReportCount: import("@shipfox/node-opentelemetry").Counter<{
-    state: "starting" | "running" | "stopping" | "stopped" | "failed" | "terminated";
+    state: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'terminated';
 }>;
 export declare const runnerBootstrapExchangeCount: import("@shipfox/node-opentelemetry").Counter<{
-    outcome: "accepted" | "rejected";
+    outcome: 'accepted' | 'rejected';
 }>;
 export declare const runnerControlHeartbeatCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
 export declare const providerRunnerReapedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
 export declare const providerRunnerCountDivergenceCount: import("@shipfox/node-opentelemetry").Counter<{
     template_key?: string;
-    state: "starting" | "running";
-    direction: "backend-higher" | "advertised-higher";
+    state: 'starting' | 'running';
+    direction: 'backend-higher' | 'advertised-higher';
 }>;
 export declare const providerRunnerReconcileCallCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
 export declare const providerRunnerAbsentTerminatedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
 export declare const providerRunnerTerminateIntentIssuedCount: import("@shipfox/node-opentelemetry").Counter<{
-    surface: "poll-demand" | "reconcile";
-    reason: "job-cancelled" | "terminal-state";
+    surface: 'poll-demand' | 'reconcile';
+    reason: 'job-cancelled' | 'terminal-state';
 }>;
 export declare const providerRunnerTerminateIntentHonoredCount: import("@shipfox/node-opentelemetry").Counter<{
-    reason: "job-cancelled";
+    reason: 'job-cancelled';
 }>;
 export declare const reservationReleasedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export type RunnerReservationPromotionFailureReason = 'reservation-expired' | 'reservation-not-found' | 'already-assigned' | 'not-assignable';
+export declare const runnerReservationPromotionFailureCount: import("@shipfox/node-opentelemetry").Counter<{
+    reason: RunnerReservationPromotionFailureReason;
+}>;
 export type RunnersRateLimitAction = 'provisioner-mint' | 'ephemeral-register';
 export type RunnersRateLimitScope = 'provisioner' | 'ephemeral-token';
 export type RunnersRateLimitOutcome = 'allowed' | 'blocked' | 'unavailable';
+export declare function recordRunnerReservationPromotionFailure(reason: RunnerReservationPromotionFailureReason): void;
 export declare function recordRunnersRateLimitCheck(params: {
     action: RunnersRateLimitAction;
     scope: RunnersRateLimitScope;

package/dist/metrics/instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../src/metrics/instance.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,yBAAyB,sEAKrC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aAAiC,SAAS,GAAG,OAAO;EAGxF,CAAC;AAEF,eAAO,MAAM,6BAA6B,sEAGzC,CAAC;AAEF,eAAO,MAAM,yBAAyB;WAC7B,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY;EAGhF,CAAC;AAEH,eAAO,MAAM,4BAA4B;aAC9B,UAAU,GAAG,UAAU;EAGhC,CAAC;AAEH,eAAO,MAAM,2BAA2B,sEAGvC,CAAC;AAEF,eAAO,MAAM,yBAAyB,sEAKrC,CAAC;AAEF,eAAO,MAAM,kCAAkC;mBAC9B,MAAM;WACd,UAAU,GAAG,SAAS;eAClB,gBAAgB,GAAG,mBAAmB;EAIjD,CAAC;AAEH,eAAO,MAAM,gCAAgC,sEAG5C,CAAC;AAEF,eAAO,MAAM,mCAAmC,sEAM/C,CAAC;AAEF,eAAO,MAAM,wCAAwC;aAC1C,aAAa,GAAG,WAAW;YAC5B,eAAe,GAAG,gBAAgB;EAG1C,CAAC;AAEH,eAAO,MAAM,yCAAyC;YAC5C,eAAe;EAGvB,CAAC;AAEH,eAAO,MAAM,wBAAwB,sEAGpC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAC/E,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG,iBAAiB,CAAC;AACtE,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;AAsB5E,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,qBAAqB,CAAC;IAC7B,OAAO,EAAE,uBAAuB,CAAC;CAClC,GAAG,IAAI,CAQP;AAED,wBAAgB,kCAAkC,IAAI,IAAI,CAEzD"}
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../src/metrics/instance.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,yBAAyB,sEAKrC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aAAiC,SAAS,GAAG,OAAO;EAGxF,CAAC;AAEF,eAAO,MAAM,6BAA6B,sEAGzC,CAAC;AAEF,eAAO,MAAM,yBAAyB;WAC7B,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY;EAGhF,CAAC;AAEH,eAAO,MAAM,4BAA4B;aAC9B,UAAU,GAAG,UAAU;EAGhC,CAAC;AAEH,eAAO,MAAM,2BAA2B,sEAGvC,CAAC;AAEF,eAAO,MAAM,yBAAyB,sEAKrC,CAAC;AAEF,eAAO,MAAM,kCAAkC;mBAC9B,MAAM;WACd,UAAU,GAAG,SAAS;eAClB,gBAAgB,GAAG,mBAAmB;EAIjD,CAAC;AAEH,eAAO,MAAM,gCAAgC,sEAG5C,CAAC;AAEF,eAAO,MAAM,mCAAmC,sEAM/C,CAAC;AAEF,eAAO,MAAM,wCAAwC;aAC1C,aAAa,GAAG,WAAW;YAC5B,eAAe,GAAG,gBAAgB;EAG1C,CAAC;AAEH,eAAO,MAAM,yCAAyC;YAC5C,eAAe;EAGvB,CAAC;AAEH,eAAO,MAAM,wBAAwB,sEAGpC,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAC/C,qBAAqB,GACrB,uBAAuB,GACvB,kBAAkB,GAClB,gBAAgB,CAAC;AAErB,eAAO,MAAM,sCAAsC;YACzC,uCAAuC;EAG/C,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAC/E,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG,iBAAiB,CAAC;AACtE,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;AAsB5E,wBAAgB,uCAAuC,CACrD,MAAM,EAAE,uCAAuC,GAC9C,IAAI,CAEN;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,qBAAqB,CAAC;IAC7B,OAAO,EAAE,uBAAuB,CAAC;CAClC,GAAG,IAAI,CAQP;AAED,wBAAgB,kCAAkC,IAAI,IAAI,CAEzD"}

package/dist/metrics/instance.js

@@ -39,6 +39,9 @@ export const providerRunnerTerminateIntentHonoredCount = meter.createCounter('ru
 export const reservationReleasedCount = meter.createCounter('runners_reservation_released', {
     description: 'Reservation units released from terminal provisioned runner reports'
 });
+export const runnerReservationPromotionFailureCount = meter.createCounter('runners_reservation_promotion_failures', {
+    description: 'Runner reservation promotion failures during enrollment by reason'
+});
 const rateLimitCheckCount = meter.createCounter('runners_rate_limit_checks', {
     description: 'Runners rate limit checks by action, scope, and outcome'
 });
@@ -52,6 +55,11 @@ function recordMetric(record) {
     // Metrics must not affect runner or provisioner request outcomes.
     }
 }
+export function recordRunnerReservationPromotionFailure(reason) {
+    recordMetric(()=>runnerReservationPromotionFailureCount.add(1, {
+            reason
+        }));
+}
 export function recordRunnersRateLimitCheck(params) {
     recordMetric(()=>rateLimitCheckCount.add(1, {
             action: params.action,

package/dist/metrics/instance.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/metrics/instance.ts"],"sourcesContent":["import {instanceMetrics} from '@shipfox/node-opentelemetry';\n\nconst meter = instanceMetrics.getMeter('runners');\n\nexport const jobExecutionEnqueuedCount = meter.createCounter<Record<string, never>>(\n  'runners_job_execution_enqueued',\n  {\n    description: 'Job executions added to the pending queue',\n  },\n);\n\nexport const jobExecutionClaimedCount = meter.createCounter<{outcome: 'claimed' | 'empty'}>(\n  'runners_job_execution_claimed',\n  {description: 'Job execution claim attempts by outcome'},\n);\n\nexport const jobExecutionLeaseExpiredCount = meter.createCounter<Record<string, never>>(\n  'runners_job_execution_lease_expired',\n  {description: 'Job execution leases reaped after passing the heartbeat threshold'},\n);\n\nexport const providerRunnerReportCount = meter.createCounter<{\n  state: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'terminated';\n}>('runners_provider_runner_reported', {\n  description: 'Provisioned runner lifecycle reports accepted by state',\n});\n\nexport const runnerBootstrapExchangeCount = meter.createCounter<{\n  outcome: 'accepted' | 'rejected';\n}>('runners_runner_bootstrap_exchange', {\n  description: 'Runner bootstrap-token exchanges by outcome',\n});\n\nexport const runnerControlHeartbeatCount = meter.createCounter<Record<string, never>>(\n  'runners_runner_control_heartbeat',\n  {description: 'Pre-workspace runner-control heartbeats accepted'},\n);\n\nexport const providerRunnerReapedCount = meter.createCounter<Record<string, never>>(\n  'runners_provider_runner_reaped',\n  {\n    description: 'Stale provisioned runners marked failed by backend maintenance',\n  },\n);\n\nexport const providerRunnerCountDivergenceCount = meter.createCounter<{\n  template_key?: string;\n  state: 'starting' | 'running';\n  direction: 'backend-higher' | 'advertised-higher';\n}>('runners_provider_runner_count_divergence', {\n  description:\n    'Absolute difference between provisioner-advertised and backend-observed provisioned runner counts',\n});\n\nexport const providerRunnerReconcileCallCount = meter.createCounter<Record<string, never>>(\n  'runners_provider_runner_reconcile_called',\n  {description: 'Provisioned runner reconcile calls completed successfully'},\n);\n\nexport const providerRunnerAbsentTerminatedCount = meter.createCounter<Record<string, never>>(\n  'runners_provider_runner_absent_terminated',\n  {\n    description:\n      'Owned provisioned runners marked terminated because they were absent from reconcile',\n  },\n);\n\nexport const providerRunnerTerminateIntentIssuedCount = meter.createCounter<{\n  surface: 'poll-demand' | 'reconcile';\n  reason: 'job-cancelled' | 'terminal-state';\n}>('runners_provider_runner_terminate_intent_issued', {\n  description: 'Provisioned runner terminate intents returned to provisioners',\n});\n\nexport const providerRunnerTerminateIntentHonoredCount = meter.createCounter<{\n  reason: 'job-cancelled';\n}>('runners_provider_runner_terminate_intent_honored', {\n  description: 'Provisioned runner terminate intents honored by first transition to terminated',\n});\n\nexport const reservationReleasedCount = meter.createCounter<Record<string, never>>(\n  'runners_reservation_released',\n  {description: 'Reservation units released from terminal provisioned runner reports'},\n);\n\nexport type RunnersRateLimitAction = 'provisioner-mint' | 'ephemeral-register';\nexport type RunnersRateLimitScope = 'provisioner' | 'ephemeral-token';\nexport type RunnersRateLimitOutcome = 'allowed' | 'blocked' | 'unavailable';\n\nconst rateLimitCheckCount = meter.createCounter<{\n  action: RunnersRateLimitAction;\n  scope: RunnersRateLimitScope;\n  outcome: RunnersRateLimitOutcome;\n}>('runners_rate_limit_checks', {\n  description: 'Runners rate limit checks by action, scope, and outcome',\n});\n\nconst rateLimitPruneFailureCount = meter.createCounter('runners_rate_limit_prune_failures', {\n  description: 'Runners rate limit prune failures',\n});\n\nfunction recordMetric(record: () => void): void {\n  try {\n    record();\n  } catch {\n    // Metrics must not affect runner or provisioner request outcomes.\n  }\n}\n\nexport function recordRunnersRateLimitCheck(params: {\n  action: RunnersRateLimitAction;\n  scope: RunnersRateLimitScope;\n  outcome: RunnersRateLimitOutcome;\n}): void {\n  recordMetric(() =>\n    rateLimitCheckCount.add(1, {\n      action: params.action,\n      scope: params.scope,\n      outcome: params.outcome,\n    }),\n  );\n}\n\nexport function recordRunnersRateLimitPruneFailure(): void {\n  recordMetric(() => rateLimitPruneFailureCount.add(1));\n}\n"],"names":["instanceMetrics","meter","getMeter","jobExecutionEnqueuedCount","createCounter","description","jobExecutionClaimedCount","jobExecutionLeaseExpiredCount","providerRunnerReportCount","runnerBootstrapExchangeCount","runnerControlHeartbeatCount","providerRunnerReapedCount","providerRunnerCountDivergenceCount","providerRunnerReconcileCallCount","providerRunnerAbsentTerminatedCount","providerRunnerTerminateIntentIssuedCount","providerRunnerTerminateIntentHonoredCount","reservationReleasedCount","rateLimitCheckCount","rateLimitPruneFailureCount","recordMetric","record","recordRunnersRateLimitCheck","params","add","action","scope","outcome","recordRunnersRateLimitPruneFailure"],"mappings":"AAAA,SAAQA,eAAe,QAAO,8BAA8B;AAE5D,MAAMC,QAAQD,gBAAgBE,QAAQ,CAAC;AAEvC,OAAO,MAAMC,4BAA4BF,MAAMG,aAAa,CAC1D,kCACA;IACEC,aAAa;AACf,GACA;AAEF,OAAO,MAAMC,2BAA2BL,MAAMG,aAAa,CACzD,iCACA;IAACC,aAAa;AAAyC,GACvD;AAEF,OAAO,MAAME,gCAAgCN,MAAMG,aAAa,CAC9D,uCACA;IAACC,aAAa;AAAmE,GACjF;AAEF,OAAO,MAAMG,4BAA4BP,MAAMG,aAAa,CAEzD,oCAAoC;IACrCC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMI,+BAA+BR,MAAMG,aAAa,CAE5D,qCAAqC;IACtCC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMK,8BAA8BT,MAAMG,aAAa,CAC5D,oCACA;IAACC,aAAa;AAAkD,GAChE;AAEF,OAAO,MAAMM,4BAA4BV,MAAMG,aAAa,CAC1D,kCACA;IACEC,aAAa;AACf,GACA;AAEF,OAAO,MAAMO,qCAAqCX,MAAMG,aAAa,CAIlE,4CAA4C;IAC7CC,aACE;AACJ,GAAG;AAEH,OAAO,MAAMQ,mCAAmCZ,MAAMG,aAAa,CACjE,4CACA;IAACC,aAAa;AAA2D,GACzE;AAEF,OAAO,MAAMS,sCAAsCb,MAAMG,aAAa,CACpE,6CACA;IACEC,aACE;AACJ,GACA;AAEF,OAAO,MAAMU,2CAA2Cd,MAAMG,aAAa,CAGxE,mDAAmD;IACpDC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMW,4CAA4Cf,MAAMG,aAAa,CAEzE,oDAAoD;IACrDC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMY,2BAA2BhB,MAAMG,aAAa,CACzD,gCACA;IAACC,aAAa;AAAqE,GACnF;AAMF,MAAMa,sBAAsBjB,MAAMG,aAAa,CAI5C,6BAA6B;IAC9BC,aAAa;AACf;AAEA,MAAMc,6BAA6BlB,MAAMG,aAAa,CAAC,qCAAqC;IAC1FC,aAAa;AACf;AAEA,SAASe,aAAaC,MAAkB;IACtC,IAAI;QACFA;IACF,EAAE,OAAM;IACN,kEAAkE;IACpE;AACF;AAEA,OAAO,SAASC,4BAA4BC,MAI3C;IACCH,aAAa,IACXF,oBAAoBM,GAAG,CAAC,GAAG;YACzBC,QAAQF,OAAOE,MAAM;YACrBC,OAAOH,OAAOG,KAAK;YACnBC,SAASJ,OAAOI,OAAO;QACzB;AAEJ;AAEA,OAAO,SAASC;IACdR,aAAa,IAAMD,2BAA2BK,GAAG,CAAC;AACpD"}
+{"version":3,"sources":["../../src/metrics/instance.ts"],"sourcesContent":["import {instanceMetrics} from '@shipfox/node-opentelemetry';\n\nconst meter = instanceMetrics.getMeter('runners');\n\nexport const jobExecutionEnqueuedCount = meter.createCounter<Record<string, never>>(\n  'runners_job_execution_enqueued',\n  {\n    description: 'Job executions added to the pending queue',\n  },\n);\n\nexport const jobExecutionClaimedCount = meter.createCounter<{outcome: 'claimed' | 'empty'}>(\n  'runners_job_execution_claimed',\n  {description: 'Job execution claim attempts by outcome'},\n);\n\nexport const jobExecutionLeaseExpiredCount = meter.createCounter<Record<string, never>>(\n  'runners_job_execution_lease_expired',\n  {description: 'Job execution leases reaped after passing the heartbeat threshold'},\n);\n\nexport const providerRunnerReportCount = meter.createCounter<{\n  state: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'terminated';\n}>('runners_provider_runner_reported', {\n  description: 'Provisioned runner lifecycle reports accepted by state',\n});\n\nexport const runnerBootstrapExchangeCount = meter.createCounter<{\n  outcome: 'accepted' | 'rejected';\n}>('runners_runner_bootstrap_exchange', {\n  description: 'Runner bootstrap-token exchanges by outcome',\n});\n\nexport const runnerControlHeartbeatCount = meter.createCounter<Record<string, never>>(\n  'runners_runner_control_heartbeat',\n  {description: 'Pre-workspace runner-control heartbeats accepted'},\n);\n\nexport const providerRunnerReapedCount = meter.createCounter<Record<string, never>>(\n  'runners_provider_runner_reaped',\n  {\n    description: 'Stale provisioned runners marked failed by backend maintenance',\n  },\n);\n\nexport const providerRunnerCountDivergenceCount = meter.createCounter<{\n  template_key?: string;\n  state: 'starting' | 'running';\n  direction: 'backend-higher' | 'advertised-higher';\n}>('runners_provider_runner_count_divergence', {\n  description:\n    'Absolute difference between provisioner-advertised and backend-observed provisioned runner counts',\n});\n\nexport const providerRunnerReconcileCallCount = meter.createCounter<Record<string, never>>(\n  'runners_provider_runner_reconcile_called',\n  {description: 'Provisioned runner reconcile calls completed successfully'},\n);\n\nexport const providerRunnerAbsentTerminatedCount = meter.createCounter<Record<string, never>>(\n  'runners_provider_runner_absent_terminated',\n  {\n    description:\n      'Owned provisioned runners marked terminated because they were absent from reconcile',\n  },\n);\n\nexport const providerRunnerTerminateIntentIssuedCount = meter.createCounter<{\n  surface: 'poll-demand' | 'reconcile';\n  reason: 'job-cancelled' | 'terminal-state';\n}>('runners_provider_runner_terminate_intent_issued', {\n  description: 'Provisioned runner terminate intents returned to provisioners',\n});\n\nexport const providerRunnerTerminateIntentHonoredCount = meter.createCounter<{\n  reason: 'job-cancelled';\n}>('runners_provider_runner_terminate_intent_honored', {\n  description: 'Provisioned runner terminate intents honored by first transition to terminated',\n});\n\nexport const reservationReleasedCount = meter.createCounter<Record<string, never>>(\n  'runners_reservation_released',\n  {description: 'Reservation units released from terminal provisioned runner reports'},\n);\n\nexport type RunnerReservationPromotionFailureReason =\n  | 'reservation-expired'\n  | 'reservation-not-found'\n  | 'already-assigned'\n  | 'not-assignable';\n\nexport const runnerReservationPromotionFailureCount = meter.createCounter<{\n  reason: RunnerReservationPromotionFailureReason;\n}>('runners_reservation_promotion_failures', {\n  description: 'Runner reservation promotion failures during enrollment by reason',\n});\n\nexport type RunnersRateLimitAction = 'provisioner-mint' | 'ephemeral-register';\nexport type RunnersRateLimitScope = 'provisioner' | 'ephemeral-token';\nexport type RunnersRateLimitOutcome = 'allowed' | 'blocked' | 'unavailable';\n\nconst rateLimitCheckCount = meter.createCounter<{\n  action: RunnersRateLimitAction;\n  scope: RunnersRateLimitScope;\n  outcome: RunnersRateLimitOutcome;\n}>('runners_rate_limit_checks', {\n  description: 'Runners rate limit checks by action, scope, and outcome',\n});\n\nconst rateLimitPruneFailureCount = meter.createCounter('runners_rate_limit_prune_failures', {\n  description: 'Runners rate limit prune failures',\n});\n\nfunction recordMetric(record: () => void): void {\n  try {\n    record();\n  } catch {\n    // Metrics must not affect runner or provisioner request outcomes.\n  }\n}\n\nexport function recordRunnerReservationPromotionFailure(\n  reason: RunnerReservationPromotionFailureReason,\n): void {\n  recordMetric(() => runnerReservationPromotionFailureCount.add(1, {reason}));\n}\n\nexport function recordRunnersRateLimitCheck(params: {\n  action: RunnersRateLimitAction;\n  scope: RunnersRateLimitScope;\n  outcome: RunnersRateLimitOutcome;\n}): void {\n  recordMetric(() =>\n    rateLimitCheckCount.add(1, {\n      action: params.action,\n      scope: params.scope,\n      outcome: params.outcome,\n    }),\n  );\n}\n\nexport function recordRunnersRateLimitPruneFailure(): void {\n  recordMetric(() => rateLimitPruneFailureCount.add(1));\n}\n"],"names":["instanceMetrics","meter","getMeter","jobExecutionEnqueuedCount","createCounter","description","jobExecutionClaimedCount","jobExecutionLeaseExpiredCount","providerRunnerReportCount","runnerBootstrapExchangeCount","runnerControlHeartbeatCount","providerRunnerReapedCount","providerRunnerCountDivergenceCount","providerRunnerReconcileCallCount","providerRunnerAbsentTerminatedCount","providerRunnerTerminateIntentIssuedCount","providerRunnerTerminateIntentHonoredCount","reservationReleasedCount","runnerReservationPromotionFailureCount","rateLimitCheckCount","rateLimitPruneFailureCount","recordMetric","record","recordRunnerReservationPromotionFailure","reason","add","recordRunnersRateLimitCheck","params","action","scope","outcome","recordRunnersRateLimitPruneFailure"],"mappings":"AAAA,SAAQA,eAAe,QAAO,8BAA8B;AAE5D,MAAMC,QAAQD,gBAAgBE,QAAQ,CAAC;AAEvC,OAAO,MAAMC,4BAA4BF,MAAMG,aAAa,CAC1D,kCACA;IACEC,aAAa;AACf,GACA;AAEF,OAAO,MAAMC,2BAA2BL,MAAMG,aAAa,CACzD,iCACA;IAACC,aAAa;AAAyC,GACvD;AAEF,OAAO,MAAME,gCAAgCN,MAAMG,aAAa,CAC9D,uCACA;IAACC,aAAa;AAAmE,GACjF;AAEF,OAAO,MAAMG,4BAA4BP,MAAMG,aAAa,CAEzD,oCAAoC;IACrCC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMI,+BAA+BR,MAAMG,aAAa,CAE5D,qCAAqC;IACtCC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMK,8BAA8BT,MAAMG,aAAa,CAC5D,oCACA;IAACC,aAAa;AAAkD,GAChE;AAEF,OAAO,MAAMM,4BAA4BV,MAAMG,aAAa,CAC1D,kCACA;IACEC,aAAa;AACf,GACA;AAEF,OAAO,MAAMO,qCAAqCX,MAAMG,aAAa,CAIlE,4CAA4C;IAC7CC,aACE;AACJ,GAAG;AAEH,OAAO,MAAMQ,mCAAmCZ,MAAMG,aAAa,CACjE,4CACA;IAACC,aAAa;AAA2D,GACzE;AAEF,OAAO,MAAMS,sCAAsCb,MAAMG,aAAa,CACpE,6CACA;IACEC,aACE;AACJ,GACA;AAEF,OAAO,MAAMU,2CAA2Cd,MAAMG,aAAa,CAGxE,mDAAmD;IACpDC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMW,4CAA4Cf,MAAMG,aAAa,CAEzE,oDAAoD;IACrDC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMY,2BAA2BhB,MAAMG,aAAa,CACzD,gCACA;IAACC,aAAa;AAAqE,GACnF;AAQF,OAAO,MAAMa,yCAAyCjB,MAAMG,aAAa,CAEtE,0CAA0C;IAC3CC,aAAa;AACf,GAAG;AAMH,MAAMc,sBAAsBlB,MAAMG,aAAa,CAI5C,6BAA6B;IAC9BC,aAAa;AACf;AAEA,MAAMe,6BAA6BnB,MAAMG,aAAa,CAAC,qCAAqC;IAC1FC,aAAa;AACf;AAEA,SAASgB,aAAaC,MAAkB;IACtC,IAAI;QACFA;IACF,EAAE,OAAM;IACN,kEAAkE;IACpE;AACF;AAEA,OAAO,SAASC,wCACdC,MAA+C;IAE/CH,aAAa,IAAMH,uCAAuCO,GAAG,CAAC,GAAG;YAACD;QAAM;AAC1E;AAEA,OAAO,SAASE,4BAA4BC,MAI3C;IACCN,aAAa,IACXF,oBAAoBM,GAAG,CAAC,GAAG;YACzBG,QAAQD,OAAOC,MAAM;YACrBC,OAAOF,OAAOE,KAAK;YACnBC,SAASH,OAAOG,OAAO;QACzB;AAEJ;AAEA,OAAO,SAASC;IACdV,aAAa,IAAMD,2BAA2BK,GAAG,CAAC;AACpD"}

package/dist/metrics/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/metrics/service.ts"],"names":[],"mappings":"AAGA,wBAAgB,6BAA6B,IAAI,IAAI,CAkBpD"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/metrics/service.ts"],"names":[],"mappings":"AAKA,wBAAgB,6BAA6B,IAAI,IAAI,CAoCpD"}

package/dist/metrics/service.js

@@ -1,5 +1,7 @@
 import { getServiceMetricsProvider } from '@shipfox/node-opentelemetry';
+import { config } from '#config.js';
 import { getJobExecutionQueueDepth } from '#db/job-executions.js';
+import { countStaleEnrolledRunnerInstances } from '#db/runner-instances.js';
 export function registerRunnersServiceMetrics() {
     const meter = getServiceMetricsProvider().getMeter('runners');
     const pendingJobExecutions = meter.createObservableGauge('runners_pending_job_executions', {
@@ -8,13 +10,27 @@ export function registerRunnersServiceMetrics() {
     const runningJobExecutions = meter.createObservableGauge('runners_running_job_executions', {
         description: 'Job executions currently claimed by a runner and in progress'
     });
+    const enrolledRunnersWithoutRecentReport = meter.createObservableGauge('runners_enrolled_without_recent_report', {
+        description: 'Running enrolled runners with a live control session, no workspace or runner session, and no recent provisioner report after the stale-runner grace window'
+    });
     meter.addBatchObservableCallback(async (observer)=>{
-        const depth = await getJobExecutionQueueDepth();
-        observer.observe(pendingJobExecutions, depth.pendingJobExecutions);
-        observer.observe(runningJobExecutions, depth.runningJobExecutions);
+        const [depthResult, staleEnrolledRunnerCountResult] = await Promise.allSettled([
+            getJobExecutionQueueDepth(),
+            countStaleEnrolledRunnerInstances({
+                graceSeconds: config.RUNNER_STALE_PROVISIONED_RUNNER_THRESHOLD_SECONDS
+            })
+        ]);
+        if (depthResult.status === 'fulfilled') {
+            observer.observe(pendingJobExecutions, depthResult.value.pendingJobExecutions);
+            observer.observe(runningJobExecutions, depthResult.value.runningJobExecutions);
+        }
+        if (staleEnrolledRunnerCountResult.status === 'fulfilled') {
+            observer.observe(enrolledRunnersWithoutRecentReport, staleEnrolledRunnerCountResult.value);
+        }
     }, [
         pendingJobExecutions,
-        runningJobExecutions
+        runningJobExecutions,
+        enrolledRunnersWithoutRecentReport
     ]);
 }
 

package/dist/metrics/service.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/metrics/service.ts"],"sourcesContent":["import {getServiceMetricsProvider} from '@shipfox/node-opentelemetry';\nimport {getJobExecutionQueueDepth} from '#db/job-executions.js';\n\nexport function registerRunnersServiceMetrics(): void {\n  const meter = getServiceMetricsProvider().getMeter('runners');\n\n  const pendingJobExecutions = meter.createObservableGauge('runners_pending_job_executions', {\n    description: 'Job executions currently waiting in the queue to be claimed',\n  });\n  const runningJobExecutions = meter.createObservableGauge('runners_running_job_executions', {\n    description: 'Job executions currently claimed by a runner and in progress',\n  });\n\n  meter.addBatchObservableCallback(\n    async (observer) => {\n      const depth = await getJobExecutionQueueDepth();\n      observer.observe(pendingJobExecutions, depth.pendingJobExecutions);\n      observer.observe(runningJobExecutions, depth.runningJobExecutions);\n    },\n    [pendingJobExecutions, runningJobExecutions],\n  );\n}\n"],"names":["getServiceMetricsProvider","getJobExecutionQueueDepth","registerRunnersServiceMetrics","meter","getMeter","pendingJobExecutions","createObservableGauge","description","runningJobExecutions","addBatchObservableCallback","observer","depth","observe"],"mappings":"AAAA,SAAQA,yBAAyB,QAAO,8BAA8B;AACtE,SAAQC,yBAAyB,QAAO,wBAAwB;AAEhE,OAAO,SAASC;IACd,MAAMC,QAAQH,4BAA4BI,QAAQ,CAAC;IAEnD,MAAMC,uBAAuBF,MAAMG,qBAAqB,CAAC,kCAAkC;QACzFC,aAAa;IACf;IACA,MAAMC,uBAAuBL,MAAMG,qBAAqB,CAAC,kCAAkC;QACzFC,aAAa;IACf;IAEAJ,MAAMM,0BAA0B,CAC9B,OAAOC;QACL,MAAMC,QAAQ,MAAMV;QACpBS,SAASE,OAAO,CAACP,sBAAsBM,MAAMN,oBAAoB;QACjEK,SAASE,OAAO,CAACJ,sBAAsBG,MAAMH,oBAAoB;IACnE,GACA;QAACH;QAAsBG;KAAqB;AAEhD"}
+{"version":3,"sources":["../../src/metrics/service.ts"],"sourcesContent":["import {getServiceMetricsProvider} from '@shipfox/node-opentelemetry';\nimport {config} from '#config.js';\nimport {getJobExecutionQueueDepth} from '#db/job-executions.js';\nimport {countStaleEnrolledRunnerInstances} from '#db/runner-instances.js';\n\nexport function registerRunnersServiceMetrics(): void {\n  const meter = getServiceMetricsProvider().getMeter('runners');\n\n  const pendingJobExecutions = meter.createObservableGauge('runners_pending_job_executions', {\n    description: 'Job executions currently waiting in the queue to be claimed',\n  });\n  const runningJobExecutions = meter.createObservableGauge('runners_running_job_executions', {\n    description: 'Job executions currently claimed by a runner and in progress',\n  });\n  const enrolledRunnersWithoutRecentReport = meter.createObservableGauge(\n    'runners_enrolled_without_recent_report',\n    {\n      description:\n        'Running enrolled runners with a live control session, no workspace or runner session, and no recent provisioner report after the stale-runner grace window',\n    },\n  );\n\n  meter.addBatchObservableCallback(\n    async (observer) => {\n      const [depthResult, staleEnrolledRunnerCountResult] = await Promise.allSettled([\n        getJobExecutionQueueDepth(),\n        countStaleEnrolledRunnerInstances({\n          graceSeconds: config.RUNNER_STALE_PROVISIONED_RUNNER_THRESHOLD_SECONDS,\n        }),\n      ]);\n\n      if (depthResult.status === 'fulfilled') {\n        observer.observe(pendingJobExecutions, depthResult.value.pendingJobExecutions);\n        observer.observe(runningJobExecutions, depthResult.value.runningJobExecutions);\n      }\n      if (staleEnrolledRunnerCountResult.status === 'fulfilled') {\n        observer.observe(enrolledRunnersWithoutRecentReport, staleEnrolledRunnerCountResult.value);\n      }\n    },\n    [pendingJobExecutions, runningJobExecutions, enrolledRunnersWithoutRecentReport],\n  );\n}\n"],"names":["getServiceMetricsProvider","config","getJobExecutionQueueDepth","countStaleEnrolledRunnerInstances","registerRunnersServiceMetrics","meter","getMeter","pendingJobExecutions","createObservableGauge","description","runningJobExecutions","enrolledRunnersWithoutRecentReport","addBatchObservableCallback","observer","depthResult","staleEnrolledRunnerCountResult","Promise","allSettled","graceSeconds","RUNNER_STALE_PROVISIONED_RUNNER_THRESHOLD_SECONDS","status","observe","value"],"mappings":"AAAA,SAAQA,yBAAyB,QAAO,8BAA8B;AACtE,SAAQC,MAAM,QAAO,aAAa;AAClC,SAAQC,yBAAyB,QAAO,wBAAwB;AAChE,SAAQC,iCAAiC,QAAO,0BAA0B;AAE1E,OAAO,SAASC;IACd,MAAMC,QAAQL,4BAA4BM,QAAQ,CAAC;IAEnD,MAAMC,uBAAuBF,MAAMG,qBAAqB,CAAC,kCAAkC;QACzFC,aAAa;IACf;IACA,MAAMC,uBAAuBL,MAAMG,qBAAqB,CAAC,kCAAkC;QACzFC,aAAa;IACf;IACA,MAAME,qCAAqCN,MAAMG,qBAAqB,CACpE,0CACA;QACEC,aACE;IACJ;IAGFJ,MAAMO,0BAA0B,CAC9B,OAAOC;QACL,MAAM,CAACC,aAAaC,+BAA+B,GAAG,MAAMC,QAAQC,UAAU,CAAC;YAC7Ef;YACAC,kCAAkC;gBAChCe,cAAcjB,OAAOkB,iDAAiD;YACxE;SACD;QAED,IAAIL,YAAYM,MAAM,KAAK,aAAa;YACtCP,SAASQ,OAAO,CAACd,sBAAsBO,YAAYQ,KAAK,CAACf,oBAAoB;YAC7EM,SAASQ,OAAO,CAACX,sBAAsBI,YAAYQ,KAAK,CAACZ,oBAAoB;QAC/E;QACA,IAAIK,+BAA+BK,MAAM,KAAK,aAAa;YACzDP,SAASQ,OAAO,CAACV,oCAAoCI,+BAA+BO,KAAK;QAC3F;IACF,GACA;QAACf;QAAsBG;QAAsBC;KAAmC;AAEpF"}

package/dist/presentation/dto/admin-provisioner-token.d.ts

@@ -1,7 +1,7 @@
 import type { ProvisionerToken } from '#core/entities/provisioner-token.js';
 export declare function toAdministratorProvisionerTokenDto(token: ProvisionerToken): {
     id: string;
-    scope: "installation";
+    scope: 'installation';
     prefix: string;
     name: string | null;
     status: import("#core/provisioner-tokens.js").InstallationProvisionerTokenStatus;

package/dist/presentation/dto/admin-provisioner-token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"admin-provisioner-token.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/admin-provisioner-token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,qCAAqC,CAAC;AAG1E,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,gBAAgB;;;;;;;;;;;;;EAmBzE"}
+{"version":3,"file":"admin-provisioner-token.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/admin-provisioner-token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,qCAAqC,CAAC;AAG1E,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,gBAAgB;IAMtE,EAAE;IACF,KAAK,EAAE,cAAc;IACrB,MAAM;IACN,IAAI;IACJ,MAAM;IACN,kBAAkB;IAClB,kBAAkB;IAClB,UAAU;IACV,UAAU;IACV,YAAY;IACZ,UAAU;IACV,UAAU;EAEb"}

package/dist/presentation/dto/admin-runner-instances.d.ts

@@ -4,7 +4,7 @@ export declare function toRunnerAdministratorInstanceDto(runner: RunnerAdministr
     lifecycle_state: import("#core/admin-runner-instances.js").RunnerAdministratorLifecycleState;
     compute_state: import("../../core/index.js").RunnerInstanceState;
     enrollment_state: import("#core/admin-runner-instances.js").RunnerAdministratorEnrollmentState;
-    assignment_presence: "unassigned" | "assigned";
+    assignment_presence: "assigned" | "unassigned";
     assigned_workspace: {
         id: string;
     } | null;
@@ -15,7 +15,7 @@ export declare function toRunnerAdministratorInstanceDto(runner: RunnerAdministr
     closed_at: string | null;
     provisioner: {
         id: string;
-        scope: "installation";
+        scope: 'installation';
         name: string | null;
     };
     reconciliation_status: import("#core/admin-runner-instances.js").RunnerAdministratorReconciliationStatus;

package/dist/presentation/dto/admin-runner-instances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"admin-runner-instances.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/admin-runner-instances.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,iCAAiC,CAAC;AAEjF,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;EAgBnF"}
+{"version":3,"file":"admin-runner-instances.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/admin-runner-instances.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,iCAAiC,CAAC;AAEjF,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,2BAA2B;IAEhF,EAAE;IACF,eAAe;IACf,aAAa;IACb,gBAAgB;IAChB,mBAAmB;IACnB,kBAAkB;;;IAClB,MAAM;IACN,UAAU;IACV,iBAAiB;IACjB,cAAc;IACd,SAAS;IACT,WAAW;;;;;IACX,qBAAqB;EAExB"}

package/dist/presentation/routes/poll-demand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"poll-demand.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/poll-demand.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAC,0BAA0B,EAAC,MAAM,+BAA+B,CAAC;AAe9E,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,0BAA+B,mDA4F7E;AAED,eAAO,MAAM,eAAe,iDAA0B,CAAC"}
+{"version":3,"file":"poll-demand.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/poll-demand.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAC,0BAA0B,EAAC,MAAM,+BAA+B,CAAC;AAsB9E,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,0BAA+B,mDAgG7E;AAED,eAAO,MAAM,eAAe,iDAA0B,CAAC"}

package/dist/presentation/routes/poll-demand.js

@@ -5,14 +5,19 @@ import { ClientError, defineRoute } from '@shipfox/node-fastify';
 import { logger } from '@shipfox/node-opentelemetry';
 import { config } from '#config.js';
 import { pollDemand, releaseReservationGrants } from '#core/demand.js';
+import { sanitizeRunnerLabels } from '#core/runner-labels.js';
 import { publishWorkspaceProvisionerCapabilitySnapshot } from '#db/provisioner-capability-snapshots.js';
 import { listQueuedDemandWorkspaceIds, pollInstallationDemandAndReserve } from '#db/reservations.js';
 import { toPollDemandResponseDto } from '#presentation/dto/index.js';
 const TERMINATE_INTENT_LIMIT = 1000;
-function toReservationTemplates(templates) {
+function toReservationTemplates(templates, scope) {
     return templates.map((template)=>({
             templateKey: template.template_key,
-            labels: template.labels,
+            labels: sanitizeRunnerLabels(template.labels, {
+                scope,
+                logLevel: 'debug',
+                source: 'provisioner template advertisement'
+            }),
             availableSlots: template.available_slots,
             starting: template.starting,
             running: template.running
@@ -55,6 +60,7 @@ export function createPollDemandRoute(options = {}) {
                 }
             });
             const provisionerContext = requireProvisionerContext(request);
+            const ttlSeconds = Math.min(request.body.reservation_ttl_seconds ?? config.RESERVATION_TTL_SECONDS, config.RESERVATION_TTL_MAX_SECONDS);
             if (provisionerContext.scope === 'installation') {
                 if (!options.installationProvisioning) {
                     throw new ClientError('Installation provisioner credentials are not accepted on this host', 'forbidden', {
@@ -63,11 +69,11 @@ export function createPollDemandRoute(options = {}) {
                 }
                 const candidateWorkspaceIds = await listQueuedDemandWorkspaceIds();
                 const eligibleWorkspaceIds = await options.installationProvisioning.policy.filterEligibleWorkspaceIds(candidateWorkspaceIds);
-                const templates = toReservationTemplates(request.body.templates);
+                const templates = toReservationTemplates(request.body.templates, 'installation');
                 const result = await pollInstallationDemandAndReserve({
                     provisionerId: provisionerContext.provisionerTokenId,
                     maxReservations: request.body.max_reservations,
-                    ttlSeconds: config.RESERVATION_TTL_SECONDS,
+                    ttlSeconds,
                     templates,
                     capabilityWindowSeconds: config.PROVISIONER_ACTIVE_WINDOW_SECONDS,
                     eligibleWorkspaceIds,
@@ -82,7 +88,7 @@ export function createPollDemandRoute(options = {}) {
                 });
             }
             const { provisionerTokenId, workspaceId } = requireWorkspaceProvisionerContext(request);
-            const templates = toReservationTemplates(request.body.templates);
+            const templates = toReservationTemplates(request.body.templates, 'workspace');
             await publishWorkspaceProvisionerCapabilitySnapshot({
                 workspaceId,
                 provisionerId: provisionerTokenId,
@@ -93,7 +99,7 @@ export function createPollDemandRoute(options = {}) {
                 provisionerId: provisionerTokenId,
                 maxReservations: request.body.max_reservations,
                 waitSeconds: request.body.wait_seconds,
-                ttlSeconds: config.RESERVATION_TTL_SECONDS,
+                ttlSeconds,
                 terminateIntentLimit: TERMINATE_INTENT_LIMIT,
                 templates,
                 signal: abortController.signal

package/dist/presentation/routes/poll-demand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/presentation/routes/poll-demand.ts"],"sourcesContent":["import {\n  requireProvisionerContext,\n  requireWorkspaceProvisionerContext,\n} from '@shipfox/api-auth-context';\nimport type {PollDemandTemplateDto} from '@shipfox/api-runners-dto';\nimport {pollDemandBodySchema, pollDemandResponseSchema} from '@shipfox/api-runners-dto';\nimport {reportError} from '@shipfox/node-error-monitoring';\nimport {ClientError, defineRoute} from '@shipfox/node-fastify';\nimport {logger} from '@shipfox/node-opentelemetry';\nimport {config} from '#config.js';\nimport {pollDemand, releaseReservationGrants} from '#core/demand.js';\nimport {publishWorkspaceProvisionerCapabilitySnapshot} from '#db/provisioner-capability-snapshots.js';\nimport {\n  listQueuedDemandWorkspaceIds,\n  pollInstallationDemandAndReserve,\n  type ReservationGrant,\n  type ReservationTemplate,\n} from '#db/reservations.js';\nimport type {CreateRunnersModuleOptions} from '#installation-provisioning.js';\nimport {toPollDemandResponseDto} from '#presentation/dto/index.js';\n\nconst TERMINATE_INTENT_LIMIT = 1000;\n\nfunction toReservationTemplates(templates: PollDemandTemplateDto[]): ReservationTemplate[] {\n  return templates.map((template) => ({\n    templateKey: template.template_key,\n    labels: template.labels,\n    availableSlots: template.available_slots,\n    starting: template.starting,\n    running: template.running,\n  }));\n}\n\nexport function createPollDemandRoute(options: CreateRunnersModuleOptions = {}) {\n  return defineRoute({\n    method: 'POST',\n    path: '/demand/poll',\n    description: 'Poll aggregate runner demand and reserve capacity for a provisioner',\n    schema: {\n      body: pollDemandBodySchema,\n      response: {\n        200: pollDemandResponseSchema,\n      },\n    },\n    handler: async (request, reply) => {\n      const abortController = new AbortController();\n      let responseFinished = false;\n      let responseReservations: ReservationGrant[] = [];\n      reply.raw.on('finish', () => {\n        responseFinished = true;\n      });\n      reply.raw.on('close', () => {\n        if (!responseFinished) {\n          abortController.abort();\n          void releaseReservationGrants(responseReservations).catch((error) => {\n            logger().error(\n              {err: error, reservationCount: responseReservations.length},\n              'Failed to release reservations after provisioner disconnect',\n            );\n            reportError(error, {\n              boundary: 'runners.cleanup',\n              operation: 'release-disconnected-reservations',\n              extra: {reservationCount: responseReservations.length},\n            });\n          });\n        }\n      });\n      const provisionerContext = requireProvisionerContext(request);\n      if (provisionerContext.scope === 'installation') {\n        if (!options.installationProvisioning) {\n          throw new ClientError(\n            'Installation provisioner credentials are not accepted on this host',\n            'forbidden',\n            {\n              status: 403,\n            },\n          );\n        }\n        const candidateWorkspaceIds = await listQueuedDemandWorkspaceIds();\n        const eligibleWorkspaceIds =\n          await options.installationProvisioning.policy.filterEligibleWorkspaceIds(\n            candidateWorkspaceIds,\n          );\n        const templates = toReservationTemplates(request.body.templates);\n        const result = await pollInstallationDemandAndReserve({\n          provisionerId: provisionerContext.provisionerTokenId,\n          maxReservations: request.body.max_reservations,\n          ttlSeconds: config.RESERVATION_TTL_SECONDS,\n          templates,\n          capabilityWindowSeconds: config.PROVISIONER_ACTIVE_WINDOW_SECONDS,\n          eligibleWorkspaceIds,\n          signal: abortController.signal,\n          onReservations: (reservations) => {\n            responseReservations.push(...reservations);\n          },\n        });\n        return toPollDemandResponseDto({\n          ...result,\n          terminateRunnerInstanceIds: [],\n        });\n      }\n      const {provisionerTokenId, workspaceId} = requireWorkspaceProvisionerContext(request);\n\n      const templates = toReservationTemplates(request.body.templates);\n      await publishWorkspaceProvisionerCapabilitySnapshot({\n        workspaceId,\n        provisionerId: provisionerTokenId,\n        templates,\n      });\n\n      const result = await pollDemand({\n        workspaceId,\n        provisionerId: provisionerTokenId,\n        maxReservations: request.body.max_reservations,\n        waitSeconds: request.body.wait_seconds,\n        ttlSeconds: config.RESERVATION_TTL_SECONDS,\n        terminateIntentLimit: TERMINATE_INTENT_LIMIT,\n        templates,\n        signal: abortController.signal,\n      });\n      responseReservations = result.reservations;\n\n      return toPollDemandResponseDto(result);\n    },\n  });\n}\n\nexport const pollDemandRoute = createPollDemandRoute();\n"],"names":["requireProvisionerContext","requireWorkspaceProvisionerContext","pollDemandBodySchema","pollDemandResponseSchema","reportError","ClientError","defineRoute","logger","config","pollDemand","releaseReservationGrants","publishWorkspaceProvisionerCapabilitySnapshot","listQueuedDemandWorkspaceIds","pollInstallationDemandAndReserve","toPollDemandResponseDto","TERMINATE_INTENT_LIMIT","toReservationTemplates","templates","map","template","templateKey","template_key","labels","availableSlots","available_slots","starting","running","createPollDemandRoute","options","method","path","description","schema","body","response","handler","request","reply","abortController","AbortController","responseFinished","responseReservations","raw","on","abort","catch","error","err","reservationCount","length","boundary","operation","extra","provisionerContext","scope","installationProvisioning","status","candidateWorkspaceIds","eligibleWorkspaceIds","policy","filterEligibleWorkspaceIds","result","provisionerId","provisionerTokenId","maxReservations","max_reservations","ttlSeconds","RESERVATION_TTL_SECONDS","capabilityWindowSeconds","PROVISIONER_ACTIVE_WINDOW_SECONDS","signal","onReservations","reservations","push","terminateRunnerInstanceIds","workspaceId","waitSeconds","wait_seconds","terminateIntentLimit","pollDemandRoute"],"mappings":"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"}
+{"version":3,"sources":["../../../src/presentation/routes/poll-demand.ts"],"sourcesContent":["import {\n  requireProvisionerContext,\n  requireWorkspaceProvisionerContext,\n} from '@shipfox/api-auth-context';\nimport type {PollDemandTemplateDto} from '@shipfox/api-runners-dto';\nimport {pollDemandBodySchema, pollDemandResponseSchema} from '@shipfox/api-runners-dto';\nimport {reportError} from '@shipfox/node-error-monitoring';\nimport {ClientError, defineRoute} from '@shipfox/node-fastify';\nimport {logger} from '@shipfox/node-opentelemetry';\nimport {config} from '#config.js';\nimport {pollDemand, releaseReservationGrants} from '#core/demand.js';\nimport {sanitizeRunnerLabels} from '#core/runner-labels.js';\nimport {publishWorkspaceProvisionerCapabilitySnapshot} from '#db/provisioner-capability-snapshots.js';\nimport {\n  listQueuedDemandWorkspaceIds,\n  pollInstallationDemandAndReserve,\n  type ReservationGrant,\n  type ReservationTemplate,\n} from '#db/reservations.js';\nimport type {CreateRunnersModuleOptions} from '#installation-provisioning.js';\nimport {toPollDemandResponseDto} from '#presentation/dto/index.js';\n\nconst TERMINATE_INTENT_LIMIT = 1000;\n\nfunction toReservationTemplates(\n  templates: PollDemandTemplateDto[],\n  scope: 'installation' | 'workspace',\n): ReservationTemplate[] {\n  return templates.map((template) => ({\n    templateKey: template.template_key,\n    labels: sanitizeRunnerLabels(template.labels, {\n      scope,\n      logLevel: 'debug',\n      source: 'provisioner template advertisement',\n    }),\n    availableSlots: template.available_slots,\n    starting: template.starting,\n    running: template.running,\n  }));\n}\n\nexport function createPollDemandRoute(options: CreateRunnersModuleOptions = {}) {\n  return defineRoute({\n    method: 'POST',\n    path: '/demand/poll',\n    description: 'Poll aggregate runner demand and reserve capacity for a provisioner',\n    schema: {\n      body: pollDemandBodySchema,\n      response: {\n        200: pollDemandResponseSchema,\n      },\n    },\n    handler: async (request, reply) => {\n      const abortController = new AbortController();\n      let responseFinished = false;\n      let responseReservations: ReservationGrant[] = [];\n      reply.raw.on('finish', () => {\n        responseFinished = true;\n      });\n      reply.raw.on('close', () => {\n        if (!responseFinished) {\n          abortController.abort();\n          void releaseReservationGrants(responseReservations).catch((error) => {\n            logger().error(\n              {err: error, reservationCount: responseReservations.length},\n              'Failed to release reservations after provisioner disconnect',\n            );\n            reportError(error, {\n              boundary: 'runners.cleanup',\n              operation: 'release-disconnected-reservations',\n              extra: {reservationCount: responseReservations.length},\n            });\n          });\n        }\n      });\n      const provisionerContext = requireProvisionerContext(request);\n      const ttlSeconds = Math.min(\n        request.body.reservation_ttl_seconds ?? config.RESERVATION_TTL_SECONDS,\n        config.RESERVATION_TTL_MAX_SECONDS,\n      );\n      if (provisionerContext.scope === 'installation') {\n        if (!options.installationProvisioning) {\n          throw new ClientError(\n            'Installation provisioner credentials are not accepted on this host',\n            'forbidden',\n            {\n              status: 403,\n            },\n          );\n        }\n        const candidateWorkspaceIds = await listQueuedDemandWorkspaceIds();\n        const eligibleWorkspaceIds =\n          await options.installationProvisioning.policy.filterEligibleWorkspaceIds(\n            candidateWorkspaceIds,\n          );\n        const templates = toReservationTemplates(request.body.templates, 'installation');\n        const result = await pollInstallationDemandAndReserve({\n          provisionerId: provisionerContext.provisionerTokenId,\n          maxReservations: request.body.max_reservations,\n          ttlSeconds,\n          templates,\n          capabilityWindowSeconds: config.PROVISIONER_ACTIVE_WINDOW_SECONDS,\n          eligibleWorkspaceIds,\n          signal: abortController.signal,\n          onReservations: (reservations) => {\n            responseReservations.push(...reservations);\n          },\n        });\n        return toPollDemandResponseDto({\n          ...result,\n          terminateRunnerInstanceIds: [],\n        });\n      }\n      const {provisionerTokenId, workspaceId} = requireWorkspaceProvisionerContext(request);\n\n      const templates = toReservationTemplates(request.body.templates, 'workspace');\n      await publishWorkspaceProvisionerCapabilitySnapshot({\n        workspaceId,\n        provisionerId: provisionerTokenId,\n        templates,\n      });\n\n      const result = await pollDemand({\n        workspaceId,\n        provisionerId: provisionerTokenId,\n        maxReservations: request.body.max_reservations,\n        waitSeconds: request.body.wait_seconds,\n        ttlSeconds,\n        terminateIntentLimit: TERMINATE_INTENT_LIMIT,\n        templates,\n        signal: abortController.signal,\n      });\n      responseReservations = result.reservations;\n\n      return toPollDemandResponseDto(result);\n    },\n  });\n}\n\nexport const pollDemandRoute = createPollDemandRoute();\n"],"names":["requireProvisionerContext","requireWorkspaceProvisionerContext","pollDemandBodySchema","pollDemandResponseSchema","reportError","ClientError","defineRoute","logger","config","pollDemand","releaseReservationGrants","sanitizeRunnerLabels","publishWorkspaceProvisionerCapabilitySnapshot","listQueuedDemandWorkspaceIds","pollInstallationDemandAndReserve","toPollDemandResponseDto","TERMINATE_INTENT_LIMIT","toReservationTemplates","templates","scope","map","template","templateKey","template_key","labels","logLevel","source","availableSlots","available_slots","starting","running","createPollDemandRoute","options","method","path","description","schema","body","response","handler","request","reply","abortController","AbortController","responseFinished","responseReservations","raw","on","abort","catch","error","err","reservationCount","length","boundary","operation","extra","provisionerContext","ttlSeconds","Math","min","reservation_ttl_seconds","RESERVATION_TTL_SECONDS","RESERVATION_TTL_MAX_SECONDS","installationProvisioning","status","candidateWorkspaceIds","eligibleWorkspaceIds","policy","filterEligibleWorkspaceIds","result","provisionerId","provisionerTokenId","maxReservations","max_reservations","capabilityWindowSeconds","PROVISIONER_ACTIVE_WINDOW_SECONDS","signal","onReservations","reservations","push","terminateRunnerInstanceIds","workspaceId","waitSeconds","wait_seconds","terminateIntentLimit","pollDemandRoute"],"mappings":"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"}

package/dist/presentation/routes/rate-limit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/rate-limit.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAoD1F,wBAAgB,wCAAwC,KACxC,SAAS,cAAc,EAAE,OAAO,YAAY,KAAG,OAAO,CAAC,IAAI,CAAC,CAY3E;AAED,wBAAgB,0CAA0C,KAC1C,SAAS,cAAc,EAAE,OAAO,YAAY,KAAG,OAAO,CAAC,IAAI,CAAC,CAc3E"}
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/rate-limit.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAoD1F,wBAAgB,wCAAwC,cAC/B,cAAc,SAAS,YAAY,KAAG,OAAO,CAAC,IAAI,CAAC,CAY3E;AAED,wBAAgB,0CAA0C,cACjC,cAAc,SAAS,YAAY,KAAG,OAAO,CAAC,IAAI,CAAC,CAc3E"}

package/dist/presentation/routes/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,oCAAoC,CAAC;AAY9E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,qBAAqB,mDAkE9D"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,oCAAoC,CAAC;AAa9E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,qBAAqB,mDAwE9D"}

package/dist/presentation/routes/register.js

@@ -1,6 +1,6 @@
 import { registerRunnerBodySchema, registerRunnerResponseSchema } from '@shipfox/api-runners-dto';
 import { ClientError, defineRoute } from '@shipfox/node-fastify';
-import { EmptyRunnerLabelsError, RegistrationTokenConsumedError, RegistrationTokenExpiredError } from '#core/errors.js';
+import { EmptyRunnerLabelsError, RegistrationTokenConsumedError, RegistrationTokenExpiredError, RunnerLabelsReservedError } from '#core/errors.js';
 import { registerRunnerSession } from '#core/runner-sessions.js';
 import { getRunnerContext } from '#presentation/auth/index.js';
 import { createEphemeralRegisterRateLimitPreHandler } from './rate-limit.js';
@@ -17,6 +17,14 @@ export function createRegisterRoute(auth) {
         },
         preHandler: createEphemeralRegisterRateLimitPreHandler(),
         errorHandler: (error, request)=>{
+            if (error instanceof RunnerLabelsReservedError) {
+                throw new ClientError(error.message, 'runner-labels-reserved', {
+                    details: {
+                        labels: error.labels
+                    },
+                    status: 400
+                });
+            }
             if (error instanceof EmptyRunnerLabelsError) {
                 throw new ClientError(error.message, 'empty-runner-labels', {
                     status: 400