@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/task-scheduler/graph.ts

@@ -1,9 +1,19 @@
 import { validatePreparedTaskGraph } from "./graph-validation.ts";
+import type { SchedulerGraphSnapshot } from "../../project-definition/project-definition.ts";
+import { snapshotClosedRecord } from "../../data-boundary/closed-values.ts";
+
+export interface NamedResourceUnits {
+  readonly resourceId: string;
+  readonly units: number;
+}
 
 export interface TaskNode {
+  readonly admissionPriority?: number;
   readonly id: string;
   readonly dependsOn?: readonly string[];
   readonly mutex?: readonly string[];
+  readonly observes?: readonly string[];
+  readonly resourceClaims?: Readonly<Record<string, number>>;
   readonly scopeId?: string;
 }
 
@@ -20,14 +30,18 @@ export interface TaskScope {
 }
 
 export interface TaskGraph {
+  readonly resourceCapacities?: Readonly<Record<string, number>>;
   readonly tasks: readonly TaskNode[];
   readonly scopes?: readonly TaskScope[];
 }
 
 export interface PlannedTask {
+  readonly admissionPriority: number;
   readonly id: string;
   readonly dependsOn: readonly string[];
   readonly mutex: readonly string[];
+  readonly observes: readonly string[];
+  readonly resourceClaims: readonly NamedResourceUnits[];
   readonly scopeId: string | undefined;
 }
 
@@ -39,12 +53,23 @@ export interface PlannedTaskScope {
 }
 
 export interface PlannedTaskGraph {
+  readonly resourceCapacities: readonly NamedResourceUnits[];
+  /** Immutable public projection shared by every decision and terminal measurement in one run. */
+  readonly schedulerGraphSnapshot: SchedulerGraphSnapshot;
   readonly tasks: readonly PlannedTask[];
   readonly scopes: readonly PlannedTaskScope[];
 }
 
-const TASK_GRAPH_KEYS = ["tasks", "scopes"] as const;
-const TASK_NODE_KEYS = ["id", "dependsOn", "mutex", "scopeId"] as const;
+const TASK_GRAPH_KEYS = ["resourceCapacities", "tasks", "scopes"] as const;
+const TASK_NODE_KEYS = [
+  "admissionPriority",
+  "id",
+  "dependsOn",
+  "mutex",
+  "observes",
+  "resourceClaims",
+  "scopeId"
+] as const;
 const TASK_SCOPE_KEYS = ["id", "maxParallel", "activationTaskIds", "terminalTaskId"] as const;
 
 /** Validates untrusted graph-shaped input without admitting it to scheduler execution. */
@@ -54,19 +79,65 @@ export function validateTaskGraph(graph: unknown): void {
 
 export function prepareTaskGraph(graph: unknown, rootMaxParallel?: number): PlannedTaskGraph {
   const data = record(graph, "task graph", TASK_GRAPH_KEYS);
+  const resourceCapacities = resourceMapping(
+    data.resourceCapacities,
+    "task graph resourceCapacities"
+  );
   const tasks = normalizeTasks(data.tasks);
   const scopes = normalizeScopes(data.scopes);
   const taskById = new Map(tasks.map((task) => [task.id, task] as const));
   const scopeById = new Map(scopes.map((scope) => [scope.id, scope] as const));
 
-  validatePreparedTaskGraph({ rootMaxParallel, scopeById, scopes, taskById, tasks });
+  validatePreparedTaskGraph({
+    resourceCapacities,
+    rootMaxParallel,
+    scopeById,
+    scopes,
+    taskById,
+    tasks
+  });
 
   return Object.freeze({
+    resourceCapacities,
+    schedulerGraphSnapshot: schedulerGraphSnapshot(tasks, scopes, resourceCapacities),
     tasks: Object.freeze(tasks),
     scopes: Object.freeze(scopes)
   });
 }
 
+function schedulerGraphSnapshot(
+  tasks: readonly PlannedTask[],
+  scopes: readonly PlannedTaskScope[],
+  resourceCapacities: readonly NamedResourceUnits[]
+): SchedulerGraphSnapshot {
+  return Object.freeze({
+    resourceCapacities,
+    scopes: Object.freeze(
+      scopes.map((scope) =>
+        Object.freeze({
+          activationTaskIds: Object.freeze([...scope.activationTaskIds]),
+          id: scope.id,
+          maxParallel: scope.maxParallel,
+          terminalTaskId: scope.terminalTaskId
+        })
+      )
+    ),
+    tasks: Object.freeze(
+      tasks.map((task) =>
+        Object.freeze({
+          admissionPriority: task.admissionPriority,
+          dependsOn: Object.freeze([...task.dependsOn]),
+          mutex: Object.freeze([...task.mutex]),
+          observes: Object.freeze([...task.observes]),
+          resourceClaims: task.resourceClaims,
+          scopeId: task.scopeId ?? null,
+          taskId: task.id
+        })
+      )
+    )
+  });
+}
+
 function normalizeTasks(value: unknown): PlannedTask[] {
   if (!Array.isArray(value)) {
     throw new TypeError("task graph tasks must be an array");
@@ -81,12 +152,16 @@ function normalizeTasks(value: unknown): PlannedTask[] {
       throw new TypeError(`duplicate task id: ${id}`);
     }
     ids.add(id);
+    const admissionPriority = admissionPriorityOrDefault(data.admissionPriority, id);
     const scopeId = optionalNonEmptyString(data.scopeId, `task ${id}.scopeId`);
     tasks.push(
       Object.freeze({
+        admissionPriority,
         id,
         dependsOn: Object.freeze(stringList(data.dependsOn, `task ${id}.dependsOn`)),
         mutex: Object.freeze(stringList(data.mutex, `task ${id}.mutex`)),
+        observes: Object.freeze(stringList(data.observes, `task ${id}.observes`)),
+        resourceClaims: resourceMapping(data.resourceClaims, `task ${id}.resourceClaims`),
         scopeId
       })
     );
@@ -177,9 +252,42 @@ function requiredStringList(value: unknown, fieldName: string): string[] {
   return stringList(value, fieldName);
 }
 
+function resourceMapping(value: unknown, fieldName: string): readonly NamedResourceUnits[] {
+  if (value === undefined) return Object.freeze([]);
+  const data = snapshotClosedRecord(value);
+  if (data === undefined) throw new TypeError(`${fieldName} must be a closed object`);
+  const entries: NamedResourceUnits[] = [];
+  for (const resourceId of Object.keys(data).sort(compareText)) {
+    if (resourceId.trim().length === 0) {
+      throw new TypeError(`${fieldName} resource ids must be non-empty strings`);
+    }
+    entries.push(
+      Object.freeze({
+        resourceId,
+        units: positiveSafeInteger(data[resourceId], `${fieldName}.${resourceId}`)
+      })
+    );
+  }
+  return Object.freeze(entries);
+}
+
 function positiveSafeInteger(value: unknown, fieldName: string): number {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
     throw new TypeError(`${fieldName} must be a positive safe integer`);
   }
   return value;
 }
+
+function admissionPriorityOrDefault(value: unknown, taskId: string): number {
+  if (value === undefined) return 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    throw new TypeError(`task ${taskId}.admissionPriority must be a safe integer`);
+  }
+  return value;
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}

package/src/project-run/task-scheduler/measurement/diagnostics.ts

@@ -0,0 +1,267 @@
+import type {
+  AdmissionPolicyMeasurement,
+  SchedulerDecisionMeasurementCumulative,
+  SchedulerMeasurementAdmission,
+  SchedulerMeasurementEffect,
+  SchedulerTerminalEffect,
+  SchedulerRawMeasurement
+} from "../../../project-definition/project-definition.ts";
+import { diagnosticTags, type DiagnosticLogger } from "../../diagnostic-logging/logger.ts";
+import type { AdmissionDelayBreakdown } from "./integrals.ts";
+import { summaryFromSchedulerMeasurement } from "./summary.ts";
+import { SchedulerPerformanceTiming } from "./timing.ts";
+import { SchedulerPolicyMeasurement } from "./policy.ts";
+
+/** Explicit, enabled-only private handoff; the Scheduler never infers this from logger behavior. */
+export type SchedulerPerformanceDiagnosticsInput = Readonly<{
+  readonly clock: Readonly<{ now(): number }>;
+  readonly declarativeFingerprint: string;
+  readonly logger?: DiagnosticLogger;
+}>;
+
+type AdmissionChronology = {
+  readonly admissionDelay: AdmissionDelayBreakdown;
+  readonly admittedAt: number;
+  settledAt: number | undefined;
+};
+
+export type AdmissionViablePendingTask = Readonly<{
+  readonly kind: "admissible-pending" | "capacity-blocked" | "mutex-blocked";
+  readonly taskId: string;
+}>;
+
+export type SchedulerPerformanceState = Readonly<{
+  readonly admissionViablePendingTasks: readonly AdmissionViablePendingTask[];
+  readonly effectiveMaxParallel: number;
+  readonly rootMaxParallel: number;
+  readonly running: number;
+}>;
+
+/**
+ * Scheduler-owned, invocation-local lifecycle projection. Clock boundaries and
+ * numeric interval accumulation remain private collaborators of this owner.
+ */
+export class SchedulerPerformanceDiagnostics {
+  readonly #declarativeFingerprint: string;
+  readonly #logger: DiagnosticLogger | undefined;
+  readonly #timing: SchedulerPerformanceTiming;
+  #lastSettledTaskId: string | undefined;
+  #completionTailActiveTaskIds: readonly string[] = Object.freeze([]);
+  readonly #admittedTaskIds = new Set<string>();
+  readonly #chronologyByTaskId = new Map<string, AdmissionChronology>();
+  readonly #policyMeasurement = new SchedulerPolicyMeasurement();
+
+  public constructor(
+    input: SchedulerPerformanceDiagnosticsInput,
+    initial: SchedulerPerformanceState
+  ) {
+    this.#declarativeFingerprint = input.declarativeFingerprint;
+    this.#logger = input.logger;
+    this.#timing = new SchedulerPerformanceTiming(input.clock, initial);
+  }
+
+  public measureControlPath<T>(operation: () => T): T {
+    return this.#timing.measureControlPath(operation);
+  }
+
+  public observeDecision(observation: () => void): void {
+    this.#timing.observeDecision(observation);
+  }
+
+  /** Flushes the old state before admission changes the real Scheduler state. */
+  public beforeAdmission(taskId: string, runningTaskIds: readonly string[]): void {
+    this.#admittedTaskIds.add(taskId);
+    this.#completionTailActiveTaskIds = Object.freeze([...runningTaskIds, taskId]);
+    const boundary = this.#timing.boundary();
+    if (boundary === undefined) return;
+    const admissionDelay = this.#timing.takeAdmissionDelay(taskId);
+    if (admissionDelay === undefined) {
+      this.#timing.invalidate("integral-invalid");
+      return;
+    }
+    this.#chronologyByTaskId.set(taskId, {
+      admissionDelay,
+      admittedAt: boundary,
+      settledAt: undefined
+    });
+  }
+
+  /** Flushes the old state before blocked/cancelled changes the real Scheduler state. */
+  public beforePendingSettlement(taskIds: readonly string[] = []): void {
+    const lastTaskId = taskIds.at(-1);
+    if (lastTaskId !== undefined) this.#lastSettledTaskId = lastTaskId;
+    this.#timing.boundary();
+  }
+
+  /** Flushes the old running interval before removing the actual running Task. */
+  public beforeRunningSettlement(taskId: string): void {
+    this.#lastSettledTaskId = taskId;
+    const boundary = this.#timing.boundary();
+    if (boundary === undefined) return;
+    this.#timing.closeAcceptedWait(boundary);
+    const chronology = this.#chronologyByTaskId.get(taskId);
+    if (chronology === undefined) {
+      this.#timing.invalidate("integral-invalid");
+      return;
+    }
+    chronology.settledAt = boundary;
+  }
+
+  public beforeAcceptedWait(): void {
+    this.#timing.beginAcceptedWait();
+  }
+
+  public captureState(state: SchedulerPerformanceState): void {
+    this.#timing.captureState(state);
+  }
+
+  public rawMeasurement(): SchedulerRawMeasurement {
+    return this.#measurement(true);
+  }
+
+  public beginSelectedPolicyAction(taskId: string): void {
+    this.#policyMeasurement.beginSelected(taskId, this.#timing.snapshot().totals);
+  }
+
+  public beginWaitPolicyAction(): void {
+    this.#policyMeasurement.beginWait(this.#timing.snapshot().totals);
+  }
+
+  public recordEffect(effect: SchedulerMeasurementEffect): void {
+    this.#policyMeasurement.recordEffect(effect);
+  }
+
+  public policyMeasurement(): AdmissionPolicyMeasurement {
+    this.#timing.boundary();
+    this.#completePolicyAction();
+    return this.#policyMeasurement.snapshot(this.#cumulativeMeasurement());
+  }
+
+  public completePendingActionObservation(): void {
+    this.#timing.boundary();
+    this.#completePolicyAction();
+  }
+
+  public admittedTaskIds(): readonly string[] {
+    return Object.freeze([...this.#admittedTaskIds]);
+  }
+
+  /** Internal default terminal hook; it contains writer failure without runner special-casing. */
+  public defaultSummaryHook(): SchedulerTerminalEffect | undefined {
+    if (this.#logger === undefined) return undefined;
+    const logger = this.#logger;
+    return (context) => {
+      try {
+        logger.observe({
+          event: "scheduler.summary",
+          tags: diagnosticTags("SUMMARY"),
+          details: summaryFromSchedulerMeasurement(context.rawMeasurement)
+        });
+      } catch {
+        // Summary writer failure is contained by this hook, not the shared runner.
+      }
+    };
+  }
+
+  #completePolicyAction(): void {
+    const timing = this.#timing.snapshot();
+    this.#policyMeasurement.complete(timing.totals, timing.timing);
+  }
+
+  #cumulativeMeasurement(): SchedulerDecisionMeasurementCumulative {
+    const snapshot = this.#timing.snapshot();
+    const facts = Object.freeze({
+      declarativeFingerprint: this.#declarativeFingerprint,
+      discrete: Object.freeze({
+        acceptedWaitCount: snapshot.acceptedWaitCount,
+        admittedCount: this.#admittedTaskIds.size,
+        maxRunning: snapshot.maxRunning
+      }),
+      peaks: snapshot.peaks
+    });
+    if (snapshot.timing.availability === "unavailable") {
+      return Object.freeze({ ...facts, timing: snapshot.timing });
+    }
+    return Object.freeze({
+      ...facts,
+      timing: snapshot.timing,
+      timingFacts: Object.freeze({
+        acceptedWaitMs: snapshot.acceptedWaitMs,
+        effectiveCapacitySlotMs: snapshot.totals.effectiveCapacitySlotMs,
+        rootCapacitySlotMs: snapshot.totals.rootCapacitySlotMs,
+        taskSlotMs: snapshot.totals.taskSlotMs
+      })
+    });
+  }
+
+  #measurement(terminal: boolean): SchedulerRawMeasurement {
+    const endedAt = this.#timing.boundary();
+    if (terminal && endedAt !== undefined) this.#timing.closeAcceptedWait(endedAt);
+    const snapshot = this.#timing.snapshot();
+    const facts = Object.freeze({
+      declarativeFingerprint: this.#declarativeFingerprint,
+      discrete: Object.freeze({
+        acceptedWaitCount: snapshot.acceptedWaitCount,
+        admittedCount: this.#admittedTaskIds.size,
+        completionTailActiveTaskIds: Object.freeze([...this.#completionTailActiveTaskIds]),
+        lastSettledTaskId: this.#lastSettledTaskId ?? null,
+        maxRunning: snapshot.maxRunning
+      }),
+      peaks: snapshot.peaks
+    });
+    if (snapshot.timing.availability === "unavailable") {
+      return Object.freeze({ ...facts, timing: snapshot.timing });
+    }
+    if (endedAt === undefined)
+      throw new Error("available Scheduler timing has no terminal boundary");
+    return Object.freeze({
+      ...facts,
+      timing: snapshot.timing,
+      timingFacts: Object.freeze({
+        acceptedWaitMs: snapshot.acceptedWaitMs,
+        admissions: Object.freeze(this.#admissionMeasurements()),
+        effectiveCapacitySlotMs: snapshot.totals.effectiveCapacitySlotMs,
+        endedAtMonotonicMs: endedAt,
+        rootCapacitySlotMs: snapshot.totals.rootCapacitySlotMs,
+        schedulerControlPathMs: snapshot.schedulerControlPathMs,
+        schedulerDecisionObservationMs: snapshot.decisionObservationMs,
+        startedAtMonotonicMs: snapshot.startedAtMonotonicMs ?? endedAt,
+        taskSlotMs: snapshot.totals.taskSlotMs
+      })
+    });
+  }
+
+  #admissionMeasurements(): SchedulerMeasurementAdmission[] {
+    const pendingByTaskId = new Map(
+      this.#timing
+        .pendingAdmissionDelays()
+        .map(({ admissionDelay, taskId }) => [taskId, admissionDelay])
+    );
+    const taskIds = new Set([...pendingByTaskId.keys(), ...this.#chronologyByTaskId.keys()]);
+    return [...taskIds]
+      .map((taskId) => this.#admissionMeasurement(taskId, pendingByTaskId))
+      .sort((left, right) => compareText(left.taskId, right.taskId));
+  }
+
+  #admissionMeasurement(
+    taskId: string,
+    pendingByTaskId: ReadonlyMap<string, AdmissionDelayBreakdown>
+  ): SchedulerMeasurementAdmission {
+    const chronology = this.#chronologyByTaskId.get(taskId);
+    const admissionDelay = chronology?.admissionDelay ?? pendingByTaskId.get(taskId);
+    if (admissionDelay === undefined)
+      throw new Error(`missing admission measurement for ${taskId}`);
+    return Object.freeze({
+      admissionDelay,
+      admittedAtMonotonicMs: chronology?.admittedAt ?? null,
+      settledAtMonotonicMs: chronology?.settledAt ?? null,
+      taskId
+    });
+  }
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}

package/src/project-run/task-scheduler/measurement/integrals.ts

@@ -0,0 +1,177 @@
+import type { SchedulerMeasurementIntervalContribution } from "../../../project-definition/project-definition.ts";
+import type { AdmissionViablePendingTask, SchedulerPerformanceState } from "./diagnostics.ts";
+
+export type AdmissionDelayBreakdown = Readonly<{
+  readonly admissiblePendingMs: number;
+  readonly capacityBlockedMs: number;
+  readonly mutexBlockedMs: number;
+}>;
+
+type MutableAdmissionDelayBreakdown = {
+  admissiblePendingMs: number;
+  capacityBlockedMs: number;
+  mutexBlockedMs: number;
+};
+
+export type SchedulerPerformancePeaks = Readonly<{
+  readonly admissionViablePendingTaskCount: number;
+  readonly admissiblePendingTaskCount: number;
+  readonly capacityBlockedTaskCount: number;
+  readonly mutexBlockedTaskCount: number;
+}>;
+
+/** Accumulates interval-weighted capacity and admission-delay measurements. */
+export class SchedulerPerformanceIntegrals {
+  #taskSlotMs = 0;
+  #rootCapacitySlotMs = 0;
+  #effectiveCapacitySlotMs = 0;
+  #mutexBlockedTaskMs = 0;
+  #capacityBlockedTaskMs = 0;
+  #admissiblePendingTaskMs = 0;
+  #peakAdmissionViablePendingTaskCount = 0;
+  #peakMutexBlockedTaskCount = 0;
+  #peakCapacityBlockedTaskCount = 0;
+  #peakAdmissiblePendingTaskCount = 0;
+  readonly #admissionDelayByTaskId = new Map<string, MutableAdmissionDelayBreakdown>();
+
+  public installPendingProjection(
+    pendingTasks: readonly AdmissionViablePendingTask[],
+    timingAvailable: boolean
+  ): void {
+    this.#peakAdmissionViablePendingTaskCount = Math.max(
+      this.#peakAdmissionViablePendingTaskCount,
+      pendingTasks.length
+    );
+    this.#peakMutexBlockedTaskCount = Math.max(
+      this.#peakMutexBlockedTaskCount,
+      pendingCount(pendingTasks, "mutex-blocked")
+    );
+    this.#peakCapacityBlockedTaskCount = Math.max(
+      this.#peakCapacityBlockedTaskCount,
+      pendingCount(pendingTasks, "capacity-blocked")
+    );
+    this.#peakAdmissiblePendingTaskCount = Math.max(
+      this.#peakAdmissiblePendingTaskCount,
+      pendingCount(pendingTasks, "admissible-pending")
+    );
+    if (!timingAvailable) return;
+    for (const pendingTask of pendingTasks) {
+      if (this.#admissionDelayByTaskId.has(pendingTask.taskId)) continue;
+      this.#admissionDelayByTaskId.set(pendingTask.taskId, {
+        admissiblePendingMs: 0,
+        capacityBlockedMs: 0,
+        mutexBlockedMs: 0
+      });
+    }
+  }
+
+  /** Returns false when an interval cannot be represented as finite non-negative totals. */
+  public addInterval(elapsedMs: number, state: SchedulerPerformanceState): boolean {
+    const contribution = intervalContribution(elapsedMs, state);
+    if (contribution === undefined) return false;
+    this.#taskSlotMs += contribution.taskSlotMs;
+    this.#rootCapacitySlotMs += contribution.rootCapacitySlotMs;
+    this.#effectiveCapacitySlotMs += contribution.effectiveCapacitySlotMs;
+    this.#mutexBlockedTaskMs += contribution.mutexBlockedTaskMs;
+    this.#capacityBlockedTaskMs += contribution.capacityBlockedTaskMs;
+    this.#admissiblePendingTaskMs += contribution.admissiblePendingTaskMs;
+    if (!finiteContribution(this.totals())) return false;
+    return this.#addAdmissionDelay(elapsedMs, state.admissionViablePendingTasks);
+  }
+
+  public takeAdmissionDelay(taskId: string): AdmissionDelayBreakdown | undefined {
+    const delay = this.#admissionDelayByTaskId.get(taskId);
+    if (delay === undefined) return undefined;
+    this.#admissionDelayByTaskId.delete(taskId);
+    return Object.freeze({ ...delay });
+  }
+
+  public pendingAdmissionDelays(): readonly Readonly<{
+    readonly admissionDelay: AdmissionDelayBreakdown;
+    readonly taskId: string;
+  }>[] {
+    return Object.freeze(
+      [...this.#admissionDelayByTaskId].map(([taskId, admissionDelay]) =>
+        Object.freeze({ admissionDelay: Object.freeze({ ...admissionDelay }), taskId })
+      )
+    );
+  }
+
+  public peaks(): SchedulerPerformancePeaks {
+    return Object.freeze({
+      admissionViablePendingTaskCount: this.#peakAdmissionViablePendingTaskCount,
+      admissiblePendingTaskCount: this.#peakAdmissiblePendingTaskCount,
+      capacityBlockedTaskCount: this.#peakCapacityBlockedTaskCount,
+      mutexBlockedTaskCount: this.#peakMutexBlockedTaskCount
+    });
+  }
+
+  public totals(): SchedulerMeasurementIntervalContribution {
+    return Object.freeze({
+      admissiblePendingTaskMs: this.#admissiblePendingTaskMs,
+      acceptedWaitMs: 0,
+      capacityBlockedTaskMs: this.#capacityBlockedTaskMs,
+      effectiveCapacitySlotMs: this.#effectiveCapacitySlotMs,
+      mutexBlockedTaskMs: this.#mutexBlockedTaskMs,
+      rootCapacitySlotMs: this.#rootCapacitySlotMs,
+      taskSlotMs: this.#taskSlotMs
+    });
+  }
+
+  #addAdmissionDelay(
+    elapsedMs: number,
+    pendingTasks: readonly AdmissionViablePendingTask[]
+  ): boolean {
+    for (const pendingTask of pendingTasks) {
+      const delay = this.#admissionDelayByTaskId.get(pendingTask.taskId);
+      if (delay === undefined) continue;
+      addDelay(delay, pendingTask.kind, elapsedMs);
+      if (!finiteAdmissionDelay(delay)) return false;
+    }
+    return true;
+  }
+}
+
+function intervalContribution(
+  elapsedMs: number,
+  state: SchedulerPerformanceState
+): SchedulerMeasurementIntervalContribution | undefined {
+  const contribution = Object.freeze({
+    admissiblePendingTaskMs:
+      elapsedMs * pendingCount(state.admissionViablePendingTasks, "admissible-pending"),
+    acceptedWaitMs: 0,
+    capacityBlockedTaskMs:
+      elapsedMs * pendingCount(state.admissionViablePendingTasks, "capacity-blocked"),
+    effectiveCapacitySlotMs: elapsedMs * state.effectiveMaxParallel,
+    mutexBlockedTaskMs:
+      elapsedMs * pendingCount(state.admissionViablePendingTasks, "mutex-blocked"),
+    rootCapacitySlotMs: elapsedMs * state.rootMaxParallel,
+    taskSlotMs: elapsedMs * state.running
+  });
+  return finiteContribution(contribution) ? contribution : undefined;
+}
+
+function finiteContribution(contribution: SchedulerMeasurementIntervalContribution): boolean {
+  return Object.values(contribution).every((value) => Number.isFinite(value) && value >= 0);
+}
+
+function addDelay(
+  delay: MutableAdmissionDelayBreakdown,
+  kind: AdmissionViablePendingTask["kind"],
+  elapsedMs: number
+): void {
+  if (kind === "mutex-blocked") delay.mutexBlockedMs += elapsedMs;
+  if (kind === "capacity-blocked") delay.capacityBlockedMs += elapsedMs;
+  if (kind === "admissible-pending") delay.admissiblePendingMs += elapsedMs;
+}
+
+function finiteAdmissionDelay(delay: MutableAdmissionDelayBreakdown): boolean {
+  return Object.values(delay).every((value) => Number.isFinite(value) && value >= 0);
+}
+
+function pendingCount(
+  pendingTasks: readonly AdmissionViablePendingTask[],
+  kind: AdmissionViablePendingTask["kind"]
+): number {
+  return pendingTasks.filter((task) => task.kind === kind).length;
+}