deepline 0.3.128 → 0.3.129

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

@@ -35,9 +35,47 @@ export type PlayRunnerRateStateAcquireInput = {
   requested: number;
   /** Confirmed provider successes since this runner's previous reservation. */
   observedSuccesses?: number;
+  /**
+   * Completed physical provider calls buffered by this runner since its prior
+   * reservation. The gateway folds these into the durable Gradient2 checkpoint
+   * before it issues the next provider permit.
+   */
+  concurrencyObservations?: PlayRunnerRateStateConcurrencyObservation[];
+  /**
+   * Stable identity for the buffered observation set. A retried acquire must
+   * carry the same identity so the durable controller folds it at most once.
+   */
+  concurrencyObservationBatch?: PlayRunnerRateStateConcurrencyObservationBatch;
   schedulerSchema?: string | null;
 };
 
+/** A bounded, provider-attempt outcome used by the shared concurrency learner. */
+export type PlayRunnerRateStateConcurrencyObservation = {
+  kind: 'success' | 'throttled';
+  latencyMs: number;
+};
+
+export type PlayRunnerRateStateConcurrencyObservationBatch = {
+  /** Random per-runner identity; never a customer or credential identifier. */
+  observerId: string;
+  /** Separates independently refilled rule lanes in the same runner. */
+  laneId: string;
+  /** Monotonic within that runner lane. */
+  sequence: number;
+};
+
+/**
+ * Admission-time facts needed to attribute a later provider 429. The gateway
+ * owns this snapshot because only it sees global concurrent leases.
+ */
+export type PlayRunnerRateStateConcurrencyGrant = {
+  /** Server-minted permit identity; deduplicates its later 429 report. */
+  admissionId: string;
+  inFlightAtStart: number;
+  targetRequestsPerSecond: number | null;
+  minimumRttMs: number | null;
+};
+
 export type PlayRunnerRateStateAcquireResult = {
   granted: number;
   waitMs: number;
@@ -56,6 +94,13 @@ export type PlayRunnerRateStateAcquireResult = {
   effectiveRequestsPerSecond?: number;
   /** One independently-expiring concurrency reservation per granted permit. */
   leaseIds?: string[];
+  /** One concurrency-attribution snapshot per granted permit. */
+  concurrencyGrants?: PlayRunnerRateStateConcurrencyGrant[];
+  /**
+   * One idempotency key per granted rate permit. A runner sends one back only
+   * when that ticket was never dispatched and must be returned to the bucket.
+   */
+  reservationIds?: string[];
   /**
    * Absolute epoch-ms until which the pacer's own cooldown holds (internally
    * capped, e.g. 45min probe cadence). Advisory: exposes the current backoff to
@@ -74,6 +119,8 @@ export type PlayRunnerRateStateReleaseInput = {
   rateScopeToken?: string | null;
   rules: PacingRule[];
   leaseIds: string[];
+  /** Idempotently refund rate reservations that never reached provider fetch. */
+  refundReservationIds?: string[];
   schedulerSchema?: string | null;
 };
 
@@ -81,6 +128,15 @@ export type PlayRunnerRateStatePenalizeInput = {
   bucketId: string;
   rateScopeToken?: string | null;
   cooldownMs: number;
+  /**
+   * The same resolved rules that admitted the attempt. Optional during the
+   * rolling deploy window: old runners retain rate-only backpressure handling.
+   */
+  rules?: PacingRule[];
+  /** Actual provider residence for this 429, when the response was observed. */
+  latencyMs?: number | null;
+  /** The server-authored permit snapshot for the rejected physical call. */
+  concurrencyGrant?: PlayRunnerRateStateConcurrencyGrant | null;
   schedulerSchema?: string | null;
 };
 

package/dist/bundling-sources/shared_libs/play-runtime/provider-capacity/adaptive-provider-capacity-controller.ts

@@ -0,0 +1,192 @@
+import {
+  EpochAimdRateController,
+  type EpochAimdRateControllerOptions,
+  type EpochAimdRateControllerSnapshot,
+} from './epoch-aimd-rate-controller';
+import {
+  Gradient2ConcurrencyController,
+  type Gradient2ConcurrencyControllerOptions,
+  type Gradient2ConcurrencyControllerSnapshot,
+} from './gradient2-concurrency-controller';
+import { classifyProviderThrottle } from './provider-throttle-classifier';
+
+export type AdaptiveProviderCapacityControllerOptions = Readonly<{
+  rate: EpochAimdRateControllerOptions;
+  concurrency: Gradient2ConcurrencyControllerOptions;
+}>;
+
+export type ProviderCapacityLease = Readonly<{
+  id: number;
+  startedAtMs: number;
+  inFlightAtStart: number;
+}>;
+
+export type ProviderCapacityAcquisition =
+  | Readonly<{ kind: 'acquired'; lease: ProviderCapacityLease }>
+  | Readonly<{ kind: 'waiting'; retryAtMs: number }>;
+
+export type ProviderCapacityCompletion = Readonly<{
+  kind: 'success' | 'throttled' | 'transport_error';
+  latencyMs: number;
+  completedAtMs: number;
+  retryAfterMs?: number;
+}>;
+
+export type AdaptiveProviderCapacityControllerSnapshot = Readonly<{
+  active: number;
+  nextAdmissionAtMs: number;
+  rate: EpochAimdRateControllerSnapshot;
+  concurrency: Gradient2ConcurrencyControllerSnapshot;
+}>;
+
+/**
+ * One admission point over independent rate and concurrency estimators.
+ *
+ * Callers share this instance for one provider credential scope. Controllers
+ * only supply budgets; this facade is the sole module allowed to issue a
+ * physical-call lease.
+ */
+export class AdaptiveProviderCapacityController {
+  readonly #rate: EpochAimdRateController;
+  readonly #concurrency: Gradient2ConcurrencyController;
+  readonly #activeLeases = new Map<number, ProviderCapacityLease>();
+  #nextLeaseId = 1;
+  #nextRateAdmissionAtMs = 0;
+  #nextConcurrencyCheckAtMs = 0;
+  #lastObservedAtMs = 0;
+  #observedConcurrencyThrottleAt: number | null = null;
+
+  constructor(options: AdaptiveProviderCapacityControllerOptions) {
+    this.#rate = new EpochAimdRateController(options.rate);
+    this.#concurrency = new Gradient2ConcurrencyController(options.concurrency);
+  }
+
+  tryAcquire(nowMs: number): ProviderCapacityAcquisition {
+    this.#advance(nowMs);
+    const rate = this.#rate.snapshot();
+    const concurrency = this.#concurrency.snapshot();
+    const retryAtMs = Math.max(
+      this.#nextRateAdmissionAtMs,
+      this.#nextConcurrencyCheckAtMs,
+      rate.cooldownUntilMs,
+    );
+    if (nowMs < retryAtMs) {
+      return Object.freeze({ kind: 'waiting', retryAtMs });
+    }
+    if (this.#activeLeases.size >= Math.max(1, Math.floor(concurrency.limit))) {
+      this.#nextConcurrencyCheckAtMs =
+        nowMs + Math.max(1, Math.floor((concurrency.shortRttMs ?? 100) / 4));
+      return Object.freeze({
+        kind: 'waiting',
+        retryAtMs: this.#nextConcurrencyCheckAtMs,
+      });
+    }
+
+    const lease = Object.freeze({
+      id: this.#nextLeaseId,
+      startedAtMs: nowMs,
+      inFlightAtStart: this.#activeLeases.size + 1,
+    });
+    this.#nextLeaseId += 1;
+    this.#activeLeases.set(lease.id, lease);
+    this.#rate.observeStart(nowMs);
+    this.#nextRateAdmissionAtMs =
+      nowMs + 1_000 / this.#rate.snapshot().targetRequestsPerSecond;
+    this.#nextConcurrencyCheckAtMs = nowMs;
+    return Object.freeze({ kind: 'acquired', lease });
+  }
+
+  complete(
+    lease: ProviderCapacityLease,
+    completion: ProviderCapacityCompletion,
+  ): void {
+    this.#advance(completion.completedAtMs);
+    if (!this.#activeLeases.delete(lease.id)) {
+      throw new Error(
+        'Provider-capacity lease is unknown or already complete.',
+      );
+    }
+
+    if (completion.kind === 'success') {
+      this.#rate.observeSuccess(completion.completedAtMs);
+      this.#concurrency.observe({
+        kind: 'success',
+        latencyMs: completion.latencyMs,
+        inFlightAtStart: lease.inFlightAtStart,
+      });
+    } else if (completion.kind === 'transport_error') {
+      // Transport failure is not evidence of a provider's rate or concurrent
+      // occupancy ceiling. The runner-local HTTP window may still apply a
+      // short-lived transport-congestion response, but the shared provider
+      // controller must match Postgres grant learning, which deliberately
+      // drops transport observations.
+    } else {
+      const pressure =
+        completion.kind === 'throttled'
+          ? this.#classifyThrottle(lease)
+          : 'concurrency';
+      if (pressure === 'rate' || pressure === 'ambiguous') {
+        this.#rate.observeThrottle(
+          completion.completedAtMs,
+          completion.retryAfterMs ?? 0,
+        );
+      }
+      if (pressure === 'concurrency' || pressure === 'ambiguous') {
+        this.#observedConcurrencyThrottleAt =
+          this.#observedConcurrencyThrottleAt === null
+            ? lease.inFlightAtStart
+            : Math.min(
+                this.#observedConcurrencyThrottleAt,
+                lease.inFlightAtStart,
+              );
+        this.#concurrency.observe({
+          kind: completion.kind,
+          latencyMs: completion.latencyMs,
+          inFlightAtStart: lease.inFlightAtStart,
+        });
+      }
+    }
+    this.#nextConcurrencyCheckAtMs = completion.completedAtMs;
+  }
+
+  snapshot(): AdaptiveProviderCapacityControllerSnapshot {
+    return Object.freeze({
+      active: this.#activeLeases.size,
+      nextAdmissionAtMs: Math.max(
+        this.#nextRateAdmissionAtMs,
+        this.#nextConcurrencyCheckAtMs,
+        this.#rate.snapshot().cooldownUntilMs,
+      ),
+      rate: this.#rate.snapshot(),
+      concurrency: this.#concurrency.snapshot(),
+    });
+  }
+
+  #advance(nowMs: number): void {
+    if (!Number.isFinite(nowMs) || nowMs < this.#lastObservedAtMs) {
+      throw new Error('Provider-capacity time must be finite and monotonic.');
+    }
+    this.#lastObservedAtMs = nowMs;
+    this.#rate.advanceTo(nowMs);
+  }
+
+  #classifyThrottle(
+    lease: ProviderCapacityLease,
+  ): 'rate' | 'concurrency' | 'ambiguous' {
+    if (
+      this.#observedConcurrencyThrottleAt !== null &&
+      lease.inFlightAtStart >= this.#observedConcurrencyThrottleAt
+    ) {
+      return 'concurrency';
+    }
+    const rate = this.#rate.snapshot().targetRequestsPerSecond;
+    const minimumRttMs = this.#concurrency.snapshot().minimumRttMs;
+    return classifyProviderThrottle({
+      grant: {
+        targetRequestsPerSecond: rate,
+        minimumRttMs,
+      },
+      inFlightAtStart: lease.inFlightAtStart,
+    });
+  }
+}

package/dist/bundling-sources/shared_libs/play-runtime/provider-capacity/epoch-aimd-rate-controller.ts

@@ -0,0 +1,194 @@
+export type EpochAimdRateControllerOptions = Readonly<{
+  initialRequestsPerSecond: number;
+  minimumRequestsPerSecond: number;
+  maximumRequestsPerSecond: number;
+  epochMs: number;
+  additiveIncrease: number;
+  decreaseFactor: number;
+  utilizationThreshold: number;
+  /** Bounded exponential cold-start probe; one or below preserves pure AIMD. */
+  startupProbeMultiplier?: number;
+}>;
+
+export type EpochAimdRateControllerSnapshot = Readonly<{
+  targetRequestsPerSecond: number;
+  cooldownUntilMs: number;
+  epochStartedAtMs: number;
+  startsInEpoch: number;
+  successesInEpoch: number;
+  throttleEpochs: number;
+}>;
+
+function positive(value: number, label: string): number {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${label} must be finite and greater than zero.`);
+  }
+  return value;
+}
+
+function fraction(value: number, label: string): number {
+  if (!Number.isFinite(value) || value <= 0 || value > 1) {
+    throw new Error(`${label} must be greater than zero and at most one.`);
+  }
+  return value;
+}
+
+/**
+ * Epoch-based additive-increase/multiplicative-decrease rate discovery.
+ *
+ * Successful latency never changes this controller. An epoch grows only when
+ * callers used most of the offered starts and those starts completed without
+ * provider throttling. A synchronized 429 burst decreases at most once per
+ * epoch.
+ */
+export class EpochAimdRateController {
+  readonly #minimumRequestsPerSecond: number;
+  readonly #maximumRequestsPerSecond: number;
+  readonly #epochMs: number;
+  readonly #additiveIncrease: number;
+  readonly #decreaseFactor: number;
+  readonly #utilizationThreshold: number;
+  readonly #startupProbeMultiplier: number;
+  #targetRequestsPerSecond: number;
+  #epochStartedAtMs = 0;
+  #initialized = false;
+  #startsInEpoch = 0;
+  #successesInEpoch = 0;
+  #throttledInEpoch = false;
+  #cooldownUntilMs = 0;
+  #throttleEpochs = 0;
+  #hasObservedThrottle = false;
+
+  constructor(options: EpochAimdRateControllerOptions) {
+    this.#minimumRequestsPerSecond = positive(
+      options.minimumRequestsPerSecond,
+      'Minimum requests per second',
+    );
+    this.#maximumRequestsPerSecond = positive(
+      options.maximumRequestsPerSecond,
+      'Maximum requests per second',
+    );
+    if (this.#maximumRequestsPerSecond < this.#minimumRequestsPerSecond) {
+      throw new Error(
+        'Maximum requests per second cannot be below the minimum.',
+      );
+    }
+    this.#targetRequestsPerSecond = Math.min(
+      this.#maximumRequestsPerSecond,
+      Math.max(
+        this.#minimumRequestsPerSecond,
+        positive(
+          options.initialRequestsPerSecond,
+          'Initial requests per second',
+        ),
+      ),
+    );
+    this.#epochMs = positive(options.epochMs, 'Rate epoch');
+    this.#additiveIncrease = positive(
+      options.additiveIncrease,
+      'Additive increase',
+    );
+    this.#decreaseFactor = fraction(options.decreaseFactor, 'Decrease factor');
+    this.#utilizationThreshold = fraction(
+      options.utilizationThreshold,
+      'Utilization threshold',
+    );
+    this.#startupProbeMultiplier = Math.max(
+      1,
+      positive(options.startupProbeMultiplier ?? 1, 'Startup probe multiplier'),
+    );
+  }
+
+  observeStart(startedAtMs: number): void {
+    this.advanceTo(startedAtMs);
+    this.#startsInEpoch += 1;
+  }
+
+  observeSuccess(completedAtMs: number): void {
+    this.advanceTo(completedAtMs);
+    this.#successesInEpoch += 1;
+  }
+
+  observeThrottle(observedAtMs: number, retryAfterMs: number): void {
+    this.advanceTo(observedAtMs);
+    // A 429 is the only authority that ends the initial probe. From this
+    // point forward the lane retains #3943's conservative AIMD recovery.
+    this.#hasObservedThrottle = true;
+    this.#cooldownUntilMs = Math.max(
+      this.#cooldownUntilMs,
+      observedAtMs + Math.max(0, retryAfterMs),
+    );
+    if (this.#throttledInEpoch) return;
+
+    this.#throttledInEpoch = true;
+    this.#throttleEpochs += 1;
+    this.#targetRequestsPerSecond = transitionProviderRateTarget({
+      currentRequestsPerSecond: this.#targetRequestsPerSecond,
+      minimumRequestsPerSecond: this.#minimumRequestsPerSecond,
+      maximumRequestsPerSecond: this.#maximumRequestsPerSecond,
+      event: 'rate_limited',
+      additiveIncrease: this.#additiveIncrease,
+      decreaseFactor: this.#decreaseFactor,
+    });
+  }
+
+  advanceTo(nowMs: number): void {
+    if (!Number.isFinite(nowMs)) {
+      throw new Error('Rate-controller time must be finite and monotonic.');
+    }
+    if (!this.#initialized) {
+      this.#epochStartedAtMs = nowMs;
+      this.#initialized = true;
+      return;
+    }
+    if (nowMs < this.#epochStartedAtMs) {
+      throw new Error('Rate-controller time must be finite and monotonic.');
+    }
+    while (nowMs >= this.#epochStartedAtMs + this.#epochMs) {
+      this.#closeEpoch();
+      this.#epochStartedAtMs += this.#epochMs;
+      this.#startsInEpoch = 0;
+      this.#successesInEpoch = 0;
+      this.#throttledInEpoch = false;
+    }
+  }
+
+  snapshot(): EpochAimdRateControllerSnapshot {
+    return Object.freeze({
+      targetRequestsPerSecond: this.#targetRequestsPerSecond,
+      cooldownUntilMs: this.#cooldownUntilMs,
+      epochStartedAtMs: this.#epochStartedAtMs,
+      startsInEpoch: this.#startsInEpoch,
+      successesInEpoch: this.#successesInEpoch,
+      throttleEpochs: this.#throttleEpochs,
+    });
+  }
+
+  #closeEpoch(): void {
+    const offeredStarts =
+      (this.#targetRequestsPerSecond * this.#epochMs) / 1_000;
+    const utilized =
+      this.#startsInEpoch >= offeredStarts * this.#utilizationThreshold;
+    const healthy =
+      !this.#throttledInEpoch &&
+      this.#successesInEpoch >=
+        this.#startsInEpoch * this.#utilizationThreshold;
+    if (!utilized || !healthy) return;
+
+    this.#targetRequestsPerSecond =
+      !this.#hasObservedThrottle && this.#startupProbeMultiplier > 1
+        ? Math.min(
+            this.#maximumRequestsPerSecond,
+            this.#targetRequestsPerSecond * this.#startupProbeMultiplier,
+          )
+        : transitionProviderRateTarget({
+            currentRequestsPerSecond: this.#targetRequestsPerSecond,
+            minimumRequestsPerSecond: this.#minimumRequestsPerSecond,
+            maximumRequestsPerSecond: this.#maximumRequestsPerSecond,
+            event: 'healthy_epoch',
+            additiveIncrease: this.#additiveIncrease,
+            decreaseFactor: this.#decreaseFactor,
+          });
+  }
+}
+import { transitionProviderRateTarget } from './provider-rate-policy';

package/dist/bundling-sources/shared_libs/play-runtime/provider-capacity/fixture-capacity-simulator.ts

@@ -0,0 +1,220 @@
+import { AdaptiveProviderCapacityController } from './adaptive-provider-capacity-controller';
+import { providerConcurrencyControllerOptions } from './provider-concurrency-policy';
+import { providerRateControllerOptions } from './provider-rate-policy';
+
+export type FixtureCapacityScenario = Readonly<{
+  operationCount: number;
+  providerRps: number;
+  providerConcurrency: number;
+  serviceTimeMs: number;
+  initialRps?: number;
+  maximumExplorationRps?: number;
+  initialConcurrency?: number;
+  maximumExplorationConcurrency?: number;
+  retryAfterMs?: number;
+  analysisWindowMs?: number;
+}>;
+
+export type FixtureCapacitySimulationResult = Readonly<{
+  completedOperations: number;
+  providerStarts: number;
+  provider429s: number;
+  elapsedMs: number;
+  physicalCeilingPerSecond: number;
+  steadyGoodputPerSecond: number;
+  steadyStatePhysicsUtilization: number;
+  finalTargetRps: number;
+  finalConcurrency: number;
+  maximumProviderInFlight: number;
+}>;
+
+type Completion = Readonly<{
+  atMs: number;
+  lease: Parameters<AdaptiveProviderCapacityController['complete']>[0];
+  kind: 'success' | 'throttled';
+}>;
+
+function positive(value: number, label: string): number {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${label} must be finite and greater than zero.`);
+  }
+  return value;
+}
+
+function positiveInteger(value: number, label: string): number {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${label} must be a positive safe integer.`);
+  }
+  return value;
+}
+
+/**
+ * Deterministic fixture-only provider world.
+ *
+ * The controller receives only its conservative seed and exploration
+ * guardrails. Actual provider RPS/concurrency stay inside this simulator and
+ * reveal themselves solely as a real provider would: an unambiguous 429 with
+ * Retry-After. This makes it possible to falsify rate/concurrency discovery
+ * without a paid provider or a second scheduler implementation.
+ */
+export function simulateFixtureCapacityDiscovery(
+  input: FixtureCapacityScenario,
+): FixtureCapacitySimulationResult {
+  const operationCount = positiveInteger(
+    input.operationCount,
+    'Operation count',
+  );
+  const providerRps = positive(input.providerRps, 'Provider RPS');
+  const providerConcurrency = positiveInteger(
+    input.providerConcurrency,
+    'Provider concurrency',
+  );
+  const serviceTimeMs = positive(input.serviceTimeMs, 'Provider service time');
+  const initialRps = positive(input.initialRps ?? 10, 'Initial RPS');
+  const maximumExplorationRps = positive(
+    input.maximumExplorationRps ?? 256,
+    'Maximum exploration RPS',
+  );
+  const initialConcurrency = positiveInteger(
+    input.initialConcurrency ?? 1,
+    'Initial concurrency',
+  );
+  const maximumExplorationConcurrency = positiveInteger(
+    input.maximumExplorationConcurrency ?? 256,
+    'Maximum exploration concurrency',
+  );
+  const retryAfterMs = positiveInteger(
+    input.retryAfterMs ?? 100,
+    'Retry-After',
+  );
+  const analysisWindowMs = positiveInteger(
+    input.analysisWindowMs ?? 30_000,
+    'Analysis window',
+  );
+  const controller = new AdaptiveProviderCapacityController({
+    rate: providerRateControllerOptions({
+      declaredRequestsPerSecond: initialRps,
+      maximumRequestsPerSecond: maximumExplorationRps,
+    }),
+    concurrency: providerConcurrencyControllerOptions({
+      initialLimit: initialConcurrency,
+      maximumLimit: maximumExplorationConcurrency,
+    }),
+  });
+  const pending: number[] = Array.from(
+    { length: operationCount },
+    (_, index) => index,
+  );
+  const completions: Completion[] = [];
+  const providerStartsAtMs: number[] = [];
+  const completedAtMs: number[] = [];
+  let nowMs = 0;
+  let providerStarts = 0;
+  let provider429s = 0;
+  let maximumProviderInFlight = 0;
+  let attempts = 0;
+
+  const advanceCompletions = () => {
+    completions.sort((left, right) => left.atMs - right.atMs);
+    while (completions[0]?.atMs === nowMs) {
+      const completion = completions.shift()!;
+      controller.complete(completion.lease, {
+        kind: completion.kind,
+        latencyMs: completion.kind === 'success' ? serviceTimeMs : 1,
+        completedAtMs: nowMs,
+        ...(completion.kind === 'throttled' ? { retryAfterMs } : {}),
+      });
+      if (completion.kind === 'success') completedAtMs.push(nowMs);
+    }
+  };
+
+  while (completedAtMs.length < operationCount) {
+    advanceCompletions();
+    let nextWakeAtMs = Number.POSITIVE_INFINITY;
+    while (pending.length > 0) {
+      attempts += 1;
+      if (attempts > operationCount * 10_000) {
+        throw new Error('Fixture capacity discovery did not converge.');
+      }
+      const admission = controller.tryAcquire(nowMs);
+      if (admission.kind === 'waiting') {
+        nextWakeAtMs = Math.min(nextWakeAtMs, admission.retryAtMs);
+        break;
+      }
+
+      const recentStarts = providerStartsAtMs.filter(
+        (startedAtMs) => startedAtMs > nowMs - 1_000,
+      );
+      providerStartsAtMs.splice(0, providerStartsAtMs.length, ...recentStarts);
+      const rateLimited = recentStarts.length >= providerRps;
+      const concurrencyLimited = completions.length >= providerConcurrency;
+      if (rateLimited || concurrencyLimited) {
+        provider429s += 1;
+        completions.push({
+          atMs: nowMs + 1,
+          lease: admission.lease,
+          kind: 'throttled',
+        });
+        nextWakeAtMs = Math.min(nextWakeAtMs, nowMs + 1);
+        break;
+      }
+
+      pending.shift();
+      providerStarts += 1;
+      providerStartsAtMs.push(nowMs);
+      completions.push({
+        atMs: nowMs + serviceTimeMs,
+        lease: admission.lease,
+        kind: 'success',
+      });
+      maximumProviderInFlight = Math.max(
+        maximumProviderInFlight,
+        completions.length,
+      );
+    }
+    if (completedAtMs.length === operationCount) break;
+    const completionAtMs = completions.reduce(
+      (soonest, completion) => Math.min(soonest, completion.atMs),
+      Number.POSITIVE_INFINITY,
+    );
+    const controllerWakeAtMs = controller.snapshot().nextAdmissionAtMs;
+    const nextAtMs = Math.min(
+      completionAtMs,
+      nextWakeAtMs,
+      controllerWakeAtMs > nowMs
+        ? controllerWakeAtMs
+        : Number.POSITIVE_INFINITY,
+    );
+    if (!Number.isFinite(nextAtMs) || nextAtMs <= nowMs) {
+      throw new Error(
+        'Fixture capacity discovery reached an invalid wake time.',
+      );
+    }
+    nowMs = nextAtMs;
+  }
+
+  const steadyWindowStartedAtMs = Math.max(0, nowMs - analysisWindowMs);
+  const steadyCompletions = completedAtMs.filter(
+    (completedAt) => completedAt > steadyWindowStartedAtMs,
+  ).length;
+  const measuredWindowMs = Math.max(1, nowMs - steadyWindowStartedAtMs);
+  const steadyGoodputPerSecond = (steadyCompletions * 1_000) / measuredWindowMs;
+  const physicalCeilingPerSecond = Math.min(
+    providerRps,
+    (providerConcurrency * 1_000) / serviceTimeMs,
+  );
+  const snapshot = controller.snapshot();
+  return Object.freeze({
+    completedOperations: completedAtMs.length,
+    providerStarts,
+    provider429s,
+    elapsedMs: nowMs,
+    physicalCeilingPerSecond,
+    steadyGoodputPerSecond,
+    steadyStatePhysicsUtilization:
+      steadyGoodputPerSecond / physicalCeilingPerSecond,
+    finalTargetRps: snapshot.rate.targetRequestsPerSecond,
+    finalConcurrency: snapshot.concurrency.limit,
+    maximumProviderInFlight,
+  });
+}