@mark1russell7/kind 0.12.4 → 0.13.0

package/build/{judge-BbzdXnBz.d.ts → judge-B_wVAwjx.d.ts}

@@ -559,6 +559,20 @@ interface BacklogTerm<A = Quantity> {
    * Without it, the drain adds only r, as in SYS-42.
    */
   readonly drains?: boolean | undefined;
+  /**
+   * This time (SYS-45) is the largest drain time of one slow session. In a run, at most one session on
+   * the target drains longer than d.hi, up to this time. Thus the window closes up to
+   * (n − 1) × d.hi + this time after the band end (`backlogEnd`). With `drains`, each session
+   * can fail more requests in the drain (`drainBand`). Without it, each session drains in d.
+   */
+  readonly slowest?: A | undefined;
+  /**
+   * With this flag (SYS-45), the band of the last failed request (`overshootBand`) opens at the
+   * low end of the end band, plus n × d.lo. The last failed request can start up to one
+   * turn before the window closes. The end band also opens one turn before the band end. The judge
+   * already checks the last failure from that low end. Without it, that band opens at n × d.lo.
+   */
+  readonly early?: boolean | undefined;
 }
 /** A replica is one pod of the service at the start of a run. */
 interface Replica {
@@ -648,8 +662,17 @@ declare const showBand: (band: Band) => string;
 /**
  * This function gives the end band of a window with the backlog term (`BacklogTerm`). It adds n × d
  * to each end of `end`, the end band without the term. The value n is the sessions on the target.
+ * A term with `slowest` (SYS-45) adds (n − 1) × d.hi + `slowest` to the high end instead.
+ */
+declare const backlogEnd: (end: Band, term: Pick<BacklogTerm, "drain"> & Partial<Pick<BacklogTerm, "slowest">>, sessions: number) => Band;
+/**
+ * This function gives the band of the start of the last failed request of a window with the backlog
+ * term, from the band end (the high end of `end`). This is the overshoot of a run. Its high end is
+ * the high end of `backlogEnd`. Without `early`, its low end is n × d.lo (SYS-42). With `early`
+ * (SYS-45), the last failed request can start up to one turn before the window closes. Its low end
+ * is then the low end of `end` plus n × d.lo. The end band opens one turn before the band end.
  */
-declare const backlogEnd: (end: Band, term: Pick<BacklogTerm, "drain">, sessions: number) => Band;
+declare const overshootBand: (end: Band, term: Pick<BacklogTerm, "drain"> & Partial<Pick<BacklogTerm, "slowest" | "early">>, sessions: number) => Band;
 /** A count band is a range of counts of requests. */
 interface CountBand {
   readonly lo: number;
@@ -660,9 +683,10 @@ interface CountBand {
  * request each turn until the window closes. With n sessions on the target, the window closes up to
  * n × d.hi after the band end (`backlogEnd`). Thus one session fails 0 to ceil(n × d.hi / turn)
  * requests in the drain. The turn is the mean period of a client (`mean`) times its sessions
- * (`connections`). The term r is not in this band.
+ * (`connections`). The term r is not in this band. With `slowest` (SYS-45), the window closes up to
+ * (n − 1) × d.hi + `slowest` after the band end. Thus one session fails up to that time over the turn.
  */
-declare const drainBand: (term: Pick<BacklogTerm, "drain">, mean: Quantity, connections: number, sessions: number) => CountBand;
+declare const drainBand: (term: Pick<BacklogTerm, "drain"> & Partial<Pick<BacklogTerm, "slowest">>, mean: Quantity, connections: number, sessions: number) => CountBand;
 /**
  * This function gives the failed requests that the backlog term predicts (`BacklogTerm`). Each of
  * the n sessions on the target gets a request each turn. The turn is the measured mean period of a
@@ -672,7 +696,7 @@ declare const drainBand: (term: Pick<BacklogTerm, "drain">, mean: Quantity, conn
  *
  * A term with `drains` (SYS-43) also adds the drain failures of each session (`drainBand`).
  */
-declare const requestBand: (term: Pick<BacklogTerm, "requests"> & Partial<Pick<BacklogTerm, "drain" | "drains">>, span: Quantity, mean: Quantity, connections: number, sessions: number) => CountBand;
+declare const requestBand: (term: Pick<BacklogTerm, "requests"> & Partial<Pick<BacklogTerm, "drain" | "drains" | "slowest">>, span: Quantity, mean: Quantity, connections: number, sessions: number) => CountBand;
 //#endregion
 //#region src/names.d.ts
 /** These are the ports of the app: its server, and its health server for the probes. */
@@ -686,11 +710,6 @@ declare const CLIENT = "client";
 declare const REDIS = "redis";
 //#endregion
 //#region src/observe.d.ts
-/**
- * This module reads a run from its lines. Each time is in milliseconds on CLOCK_MONOTONIC. All the
- * containers of the VM share that clock: the clients, the service, the agents, the injector, the
- * watcher and the prober.
- */
 /**
  * A line is one JSON line of a source of a run, with its stamp `t` in milliseconds on
  * CLOCK_MONOTONIC. It is a request of a client, a record of the service, a line of grpc-go or a probe answer. It is
@@ -1296,16 +1315,23 @@ declare const readRecord: (data: unknown) => KindCellRecord;
 //#region src/stats.d.ts
 /** This fraction, δ_rel, is how far the median of a cell can be outside its band and stay equivalent. */
 declare const RELATIVE = .05;
-/** This function gives the median of sorted values: the middle value, or the mean of the two middle values. */
+/**
+ * This function gives the median of sorted values: the middle value, or the mean of the two middle values.
+ * It is `median` of @mark1russell7/rigor-statistics, which throws a RangeError for an empty list.
+ */
 declare const middle: (sorted: readonly number[]) => number;
-/** This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). */
+/**
+ * This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). It is
+ * `quantileSorted` of @mark1russell7/rigor-statistics with the method `"nearest-rank"`.
+ */
 declare const quantileOf: (sorted: readonly number[], p: number) => number;
 /**
  * This function gives the distribution-free interval of a median: [x_(k), x_(n+1−k)], for the
  * largest k whose two tails each hold 2.5 % or less. For eleven runs, it gives [x_(2), x_(10)],
- * at 98.8 %.
+ * at 98.8 %. It is `medianInterval` of @mark1russell7/rigor-statistics at the level 0.95. An
+ * empty list throws a RangeError.
  */
 declare const medianInterval: (sorted: readonly number[]) => [number, number];
 //#endregion
-export { unitOf as $, scenarioProblems as $n, REDIS as $t, TriggerV1 as A, Trigger as An, recordsOf as At, RunCheck as B, NODE_IMAGES as Bn, sliceReadyAt as Bt, KindCellResult as C, Prediction as Cn, intakeOf as Ct, PredictionV1 as D, ResetReuse as Dn, periodOf as Dt, LoadSample as E, Replica as En, outcomesOf as Et, KIND_NOISE as F, Dataplane as Fn, sessionsAt as Ft, factsOf as G, cidrOverlap as Gn, transitionOf as Gt, checkRun as H, ZONE_KEPT as Hn, slicesOf as Ht, KindDecision as I, KUBE_PROXY_MODES as In, signalOf as It, observationEnd as J, isKubeProxyMode as Jn, ztunnelReplaced as Jt, judgeKind as K, cidrRange as Kn, tunnelsOf as Kt, KindVerdict as L, KindConfig as Ln, signalsOf as Lt, upgrade as M, WindowPrediction as Mn, restartOf as Mt, upgradeCell as N, Workload as Nn, restartsAt as Nt, RunCheckV1 as O, Stack as On, podsAt as Ot, Deleted as P, DATAPLANES as Pn, rulesOf as Pt, reusesReset as Q, scenario as Qn, PORT as Qt, LAST_SLACK as R, KindScenario as Rn, sliceDropOf as Rt, KindCellRecordV1 as S, PodSettings as Sn, failuresOf as St, KindVerdictV1 as T, Reference as Tn, kernelCounts as Tt, cyclesOf as U, ZONE_LABEL as Un, socketsOf as Ut, RunFacts as V, NodeImage as Vn, sliceReadyOf as Vt, deletionsOf as W, ZONE_LOST as Wn, stoppingOf as Wt, propagationSource as X, kubeProxyPatch as Xn, HEALTH_PORT as Xt, propagationOf as Y, kindConfig as Yn, CLIENT as Yt, referenceOf as Z, nodeNames as Zn, LOG_LABEL as Zt, ClusterManifest as _, KubeletProbe as _n, byClients as _t, STAGES as a, requestBand as an, PodLine as at, FORMAT_V1 as b, MeshMode as bn, dropOf as bt, readRecord as c, showBand as cn, Request as ct, calibrationOf as d, Cycle as dn, SliceLine as dt, SERVER as en, zoneOf as er, updatesOf as et, cellsTable as f, Declaration as fn, SocketLine as ft, BandV1 as g, KindRun as gn, backendsAt as gt, timeSpread as h, KindCell as hn, ZtunnelPodLine as ht, quantileOf as i, drainBand as in, Period as it, judge as j, TriggerKind as jn, requestsOf as jt, RunFactsV1 as k, Template as kn, podsOf as kt, Judged as l, BacklogTerm as ln, RulesLine as lt, predictionText as m, Flap as mn, TunnelLine as mt, medianInterval as n, backlogEnd as nn, HBONE_PORT as nt, kindCellRecordSchema as o, seconds as on, PropagationSource as ot, medianText as p, EdgeProtocol as pn, TCP_STATE as pt, observationAfter as q, goDuration as qn, ztunnelPodsOf as qt, middle as r, bandOf as rn, Line as rt, kindCellRecordV1Schema as s, secondsOf as sn, RecordLine as st, RELATIVE as t, CountBand as tn, Endpoint as tt, TimeSpread as u, Band as un, Sessions as ut, EnvironmentManifest as v, Mesh as vn, byNode as vt, KindCellV1 as w, RedisDeclaration as wn, isTunnelState as wt, KindCellRecord as x, NonePrediction as xn, emptyOf as xt, FORMAT as y, MeshFlavor as yn, deletionOf as yt, Propagated as z, KubeProxyMode as zn, sliceEmptyOf as zt };
-//# sourceMappingURL=judge-BbzdXnBz.d.ts.map
+export { unitOf as $, scenario as $n, REDIS as $t, TriggerV1 as A, Template as An, recordsOf as At, RunCheck as B, KubeProxyMode as Bn, sliceReadyAt as Bt, KindCellResult as C, PodSettings as Cn, intakeOf as Ct, PredictionV1 as D, Replica as Dn, periodOf as Dt, LoadSample as E, Reference as En, outcomesOf as Et, KIND_NOISE as F, DATAPLANES as Fn, sessionsAt as Ft, factsOf as G, ZONE_LOST as Gn, transitionOf as Gt, checkRun as H, NodeImage as Hn, slicesOf as Ht, KindDecision as I, Dataplane as In, signalOf as It, observationEnd as J, goDuration as Jn, ztunnelReplaced as Jt, judgeKind as K, cidrOverlap as Kn, tunnelsOf as Kt, KindVerdict as L, KUBE_PROXY_MODES as Ln, signalsOf as Lt, upgrade as M, TriggerKind as Mn, restartOf as Mt, upgradeCell as N, WindowPrediction as Nn, restartsAt as Nt, RunCheckV1 as O, ResetReuse as On, podsAt as Ot, Deleted as P, Workload as Pn, rulesOf as Pt, reusesReset as Q, nodeNames as Qn, PORT as Qt, LAST_SLACK as R, KindConfig as Rn, sliceDropOf as Rt, KindCellRecordV1 as S, NonePrediction as Sn, failuresOf as St, KindVerdictV1 as T, RedisDeclaration as Tn, kernelCounts as Tt, cyclesOf as U, ZONE_KEPT as Un, socketsOf as Ut, RunFacts as V, NODE_IMAGES as Vn, sliceReadyOf as Vt, deletionsOf as W, ZONE_LABEL as Wn, stoppingOf as Wt, propagationSource as X, kindConfig as Xn, HEALTH_PORT as Xt, propagationOf as Y, isKubeProxyMode as Yn, CLIENT as Yt, referenceOf as Z, kubeProxyPatch as Zn, LOG_LABEL as Zt, ClusterManifest as _, KindRun as _n, byClients as _t, STAGES as a, overshootBand as an, PodLine as at, FORMAT_V1 as b, MeshFlavor as bn, dropOf as bt, readRecord as c, secondsOf as cn, Request as ct, calibrationOf as d, Band as dn, SliceLine as dt, SERVER as en, scenarioProblems as er, updatesOf as et, cellsTable as f, Cycle as fn, SocketLine as ft, BandV1 as g, KindCell as gn, backendsAt as gt, timeSpread as h, Flap as hn, ZtunnelPodLine as ht, quantileOf as i, drainBand as in, Period as it, judge as j, Trigger as jn, requestsOf as jt, RunFactsV1 as k, Stack as kn, podsOf as kt, Judged as l, showBand as ln, RulesLine as lt, predictionText as m, EdgeProtocol as mn, TunnelLine as mt, medianInterval as n, backlogEnd as nn, HBONE_PORT as nt, kindCellRecordSchema as o, requestBand as on, PropagationSource as ot, medianText as p, Declaration as pn, TCP_STATE as pt, observationAfter as q, cidrRange as qn, ztunnelPodsOf as qt, middle as r, bandOf as rn, Line as rt, kindCellRecordV1Schema as s, seconds as sn, RecordLine as st, RELATIVE as t, CountBand as tn, zoneOf as tr, Endpoint as tt, TimeSpread as u, BacklogTerm as un, Sessions as ut, EnvironmentManifest as v, KubeletProbe as vn, byNode as vt, KindCellV1 as w, Prediction as wn, isTunnelState as wt, KindCellRecord as x, MeshMode as xn, emptyOf as xt, FORMAT as y, Mesh as yn, deletionOf as yt, Propagated as z, KindScenario as zn, sliceEmptyOf as zt };
+//# sourceMappingURL=judge-B_wVAwjx.d.ts.map

package/build/{judge-45z0yZ-r.js → judge-Bc84w-no.js}

@@ -1,4 +1,5 @@
 import { format, valueIn } from "@mark1russell7/quantity";
+import { median, medianInterval, quantileSorted } from "@mark1russell7/rigor-statistics";
 import { extentSchema, quantitySchema } from "@mark1russell7/quantity/schema";
 import { z } from "zod";
 //#region src/bands.ts
@@ -26,13 +27,38 @@ const showBand = (band) => {
 /** This function rounds a time to the microsecond, thus a band has no float residue. */
 const us = (value) => Math.round(value * 1e6) / 1e6;
 /**
+* This function gives the largest time after the band end at which the window of n sessions closes,
+* in seconds. Each session drains in d, thus it is n × d.hi. With `slowest` (SYS-45), one of the n
+* sessions can drain up to that time, thus it is (n − 1) × d.hi + the larger of `slowest` and d.hi.
+*/
+const closingOf = (term, sessions) => {
+	const hi = valueIn(term.drain.hi, "s");
+	if (term.slowest === void 0 || sessions < 1) return sessions * hi;
+	return (sessions - 1) * hi + Math.max(valueIn(term.slowest, "s"), hi);
+};
+/**
 * This function gives the end band of a window with the backlog term (`BacklogTerm`). It adds n × d
 * to each end of `end`, the end band without the term. The value n is the sessions on the target.
+* A term with `slowest` (SYS-45) adds (n − 1) × d.hi + `slowest` to the high end instead.
 */
 const backlogEnd = (end, term, sessions) => {
 	const ends = secondsOf(end);
 	const drain = secondsOf(term.drain);
-	return bandOf(us(ends.lo + sessions * drain.lo), us(ends.hi + sessions * drain.hi));
+	return bandOf(us(ends.lo + sessions * drain.lo), us(ends.hi + closingOf(term, sessions)));
+};
+/**
+* This function gives the band of the start of the last failed request of a window with the backlog
+* term, from the band end (the high end of `end`). This is the overshoot of a run. Its high end is
+* the high end of `backlogEnd`. Without `early`, its low end is n × d.lo (SYS-42). With `early`
+* (SYS-45), the last failed request can start up to one turn before the window closes. Its low end
+* is then the low end of `end` plus n × d.lo. The end band opens one turn before the band end.
+*/
+const overshootBand = (end, term, sessions) => {
+	const ends = secondsOf(end);
+	const closes = secondsOf(backlogEnd(end, term, sessions));
+	const drain = secondsOf(term.drain);
+	const lo = term.early === true ? closes.lo - ends.hi : sessions * drain.lo;
+	return bandOf(us(lo), us(closes.hi - ends.hi));
 };
 /** This function gives a count rounded to six places, thus 10 s / 20 ms gives 500 and not 499.99999. */
 const counted = (value) => Math.round(value * 1e6) / 1e6;
@@ -47,13 +73,14 @@ const turnOf = (mean, connections) => {
 * request each turn until the window closes. With n sessions on the target, the window closes up to
 * n × d.hi after the band end (`backlogEnd`). Thus one session fails 0 to ceil(n × d.hi / turn)
 * requests in the drain. The turn is the mean period of a client (`mean`) times its sessions
-* (`connections`). The term r is not in this band.
+* (`connections`). The term r is not in this band. With `slowest` (SYS-45), the window closes up to
+* (n − 1) × d.hi + `slowest` after the band end. Thus one session fails up to that time over the turn.
 */
 const drainBand = (term, mean, connections, sessions) => {
 	const turn = turnOf(mean, connections);
 	return {
 		lo: 0,
-		hi: Math.ceil(counted(sessions * valueIn(term.drain.hi, "s") / turn))
+		hi: Math.ceil(counted(closingOf(term, sessions) / turn))
 	};
 };
 /**
@@ -69,7 +96,10 @@ const requestBand = (term, span, mean, connections, sessions) => {
 	const turn = turnOf(mean, connections);
 	const each = counted(valueIn(span, "s") / turn);
 	if (term.drains === true && term.drain === void 0) throw new RangeError("a term with drains has no drain time d");
-	const drained = term.drains === true ? drainBand({ drain: term.drain }, mean, connections, sessions) : {
+	const drained = term.drains === true ? drainBand({
+		drain: term.drain,
+		slowest: term.slowest
+	}, mean, connections, sessions) : {
 		lo: 0,
 		hi: 0
 	};
@@ -90,7 +120,36 @@ const SERVER = "lab";
 const CLIENT = "client";
 const REDIS = "redis";
 //#endregion
+//#region src/stats.ts
+/** This fraction, δ_rel, is how far the median of a cell can be outside its band and stay equivalent. */
+const RELATIVE = .05;
+/**
+* This function gives the median of sorted values: the middle value, or the mean of the two middle values.
+* It is `median` of @mark1russell7/rigor-statistics, which throws a RangeError for an empty list.
+*/
+const middle = (sorted) => median(sorted);
+/**
+* This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). It is
+* `quantileSorted` of @mark1russell7/rigor-statistics with the method `"nearest-rank"`.
+*/
+const quantileOf = (sorted, p) => quantileSorted(sorted, p, "nearest-rank");
+/**
+* This function gives the distribution-free interval of a median: [x_(k), x_(n+1−k)], for the
+* largest k whose two tails each hold 2.5 % or less. For eleven runs, it gives [x_(2), x_(10)],
+* at 98.8 %. It is `medianInterval` of @mark1russell7/rigor-statistics at the level 0.95. An
+* empty list throws a RangeError.
+*/
+const medianInterval$1 = (sorted) => {
+	const interval = medianInterval(sorted, .95);
+	return [interval.low, interval.high];
+};
+//#endregion
 //#region src/observe.ts
+/**
+* This module reads a run from its lines. Each time is in milliseconds on CLOCK_MONOTONIC. All the
+* containers of the VM share that clock: the clients, the service, the agents, the injector, the
+* watcher and the prober.
+*/
 /** This port is the HBONE port of ztunnel in each pod of the ambient mesh of Istio 1.31.3: the mesh leg ends there. */
 const HBONE_PORT = 15008;
 /** These are the states of a TCP socket of Linux that a tunnel line names (include/net/tcp_states.h of Linux v6.17, lines 12–28). */
@@ -152,10 +211,6 @@ const sessionsAt = (lines, at, target, connections) => {
 		byClient
 	};
 };
-const medianOf = (sorted) => {
-	const middle = Math.floor(sorted.length / 2);
-	return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-};
 /**
 * This function gives the measured period of the clients from their request lines that start from
 * `from` to `to`. The timer of a client is late by a different amount at each tick. Thus the median
@@ -181,12 +236,12 @@ const periodOf = (lines, from, to) => {
 		const intervals = mine.slice(1).map((t, at) => t - mine[at]);
 		span += mine.at(-1) - mine[0];
 		all.push(...intervals);
-		byClient[client] = medianOf(intervals.sort((a, b) => a - b));
+		byClient[client] = middle(intervals.sort((a, b) => a - b));
 	}
 	if (all.length === 0) return null;
 	all.sort((a, b) => a - b);
 	return {
-		median: medianOf(all),
+		median: middle(all),
 		mean: span / all.length,
 		low: all[0],
 		high: all.at(-1),
@@ -295,38 +350,6 @@ const restartsAt = (lines, at) => {
 	return out;
 };
 //#endregion
-//#region src/stats.ts
-/** This fraction, δ_rel, is how far the median of a cell can be outside its band and stay equivalent. */
-const RELATIVE = .05;
-/** This function gives the median of sorted values: the middle value, or the mean of the two middle values. */
-const middle = (sorted) => {
-	const half = Math.floor(sorted.length / 2);
-	return sorted.length % 2 === 1 ? sorted[half] : (sorted[half - 1] + sorted[half]) / 2;
-};
-/** This function gives the value at quantile p of sorted values, by nearest rank: x_(⌈p·n⌉). */
-const quantileOf = (sorted, p) => sorted[Math.min(sorted.length, Math.max(1, Math.ceil(p * sorted.length))) - 1];
-/** This function gives P(X ≤ j) for X ~ Binomial(n, 1/2), exactly. */
-const below = (n, j) => {
-	let term = 1;
-	let sum = 0;
-	for (let i = 0; i <= j; i += 1) {
-		sum += term;
-		term = term * (n - i) / (i + 1);
-	}
-	return sum / 2 ** n;
-};
-/**
-* This function gives the distribution-free interval of a median: [x_(k), x_(n+1−k)], for the
-* largest k whose two tails each hold 2.5 % or less. For eleven runs, it gives [x_(2), x_(10)],
-* at 98.8 %.
-*/
-const medianInterval = (sorted) => {
-	const n = sorted.length;
-	let k = 0;
-	while (k + 1 <= n / 2 && below(n, k) <= .025) k += 1;
-	return k === 0 ? [sorted[0], sorted[n - 1]] : [sorted[k - 1], sorted[n - k]];
-};
-//#endregion
 //#region src/verdict.ts
 /**
 * This time is δ for kind: each time of a run lands in its band ± δ. Its parts are the interval of
@@ -482,7 +505,8 @@ const windowOf = (prediction) => prediction.kind === "window" ? prediction : pre
 const observationAfter = (cell) => {
 	const window = windowOf(cell.prediction);
 	if (window === null || window.end === null) return null;
-	const drained = window.backlog === void 0 ? 0 : window.backlog.most * valueIn(window.backlog.drain.hi, "ms");
+	const backlog = window.backlog;
+	const drained = backlog === void 0 ? 0 : backlog.slowest === void 0 || backlog.most < 1 ? backlog.most * valueIn(backlog.drain.hi, "ms") : (backlog.most - 1) * valueIn(backlog.drain.hi, "ms") + Math.max(valueIn(backlog.slowest, "ms"), valueIn(backlog.drain.hi, "ms"));
 	return seconds(sec(valueIn(window.end.band.hi, "ms") + drained + valueIn(cell.workload.timeout, "ms") + NOISE));
 };
 /**
@@ -1171,7 +1195,7 @@ const judgeKind = (cell, runs) => {
 	};
 	if (band !== null && values.length > 0) {
 		const ends = secondsOf(band);
-		const [from, to] = medianInterval(values);
+		const [from, to] = medianInterval$1(values);
 		const wide = {
 			lo: ends.lo * .95,
 			hi: ends.hi * 1.05
@@ -1236,6 +1260,15 @@ const upgradeTrigger = (trigger) => {
 		}
 	};
 };
+/** The format `/1` has no backlog term, but its type does. Each time of the term is in seconds. */
+const upgradeBacklog = (backlog) => {
+	const { slowest, ...rest } = backlog;
+	return {
+		...rest,
+		drain: band(backlog.drain),
+		...slowest === void 0 ? {} : { slowest: seconds(slowest) }
+	};
+};
 const upgradeWindow = (window) => {
 	const { afterReset, propagation, backlog, ...rest } = window;
 	return {
@@ -1253,10 +1286,7 @@ const upgradeWindow = (window) => {
 			outcome: afterReset.outcome
 		} },
 		...propagation === void 0 ? {} : { propagation: band(propagation) },
-		...backlog === void 0 ? {} : { backlog: {
-			...backlog,
-			drain: band(backlog.drain)
-		} }
+		...backlog === void 0 ? {} : { backlog: upgradeBacklog(backlog) }
 	};
 };
 const upgradePrediction = (prediction) => {
@@ -1385,8 +1415,7 @@ const judge = (record) => {
 const timeSpread = (times) => {
 	if (times.length === 0) return null;
 	const sorted = times.map((each) => valueIn(each, "s")).sort((a, b) => a - b);
-	const half = Math.floor(sorted.length / 2);
-	const median = sorted.length % 2 === 1 ? sorted[half] : (sorted[half - 1] + sorted[half]) / 2;
+	const median = middle(sorted);
 	return {
 		count: sorted.length,
 		min: seconds(sorted[0]),
@@ -1404,7 +1433,7 @@ const atBand = (from, band) => {
 const predictionText = (prediction) => {
 	switch (prediction.kind) {
 		case "none": return prediction.outcomes === void 0 ? "no failure" : `no ${prediction.outcomes.join(", ")}`;
-		case "window": return `failures only from ${atBand(prediction.start.from, prediction.start.band)}${prediction.end === null ? "" : ` to ${atBand(prediction.end.from, prediction.end.band)}`}${prediction.each === true ? ", of each deleted replica" : ""}${prediction.flaps === true ? ", in each cycle" : ""}${prediction.nodes === "paused" ? ", on the paused node" : ""}${prediction.certain ? ", at least one" : ""}${prediction.outcomes === void 0 ? "" : `, each one ${prediction.outcomes.join(" or ")}`}${prediction.afterReset === void 0 ? "" : `, or a ${prediction.afterReset.outcome} up to ${format(prediction.afterReset.life)} after a reset on its port`}${prediction.propagation === void 0 ? "" : `, the rules drop the replica in ${showBand(prediction.propagation)}`}${prediction.backlog === void 0 ? "" : `, the end n × ${showBand(prediction.backlog.drain)} later and ${prediction.backlog.requests.lo}–${prediction.backlog.requests.hi} more failures for each of the n sessions on the target${prediction.backlog.drains === true ? ", and its failures each turn in the drain of the n sessions" : ""}, counted at the measured period`}`;
+		case "window": return `failures only from ${atBand(prediction.start.from, prediction.start.band)}${prediction.end === null ? "" : ` to ${atBand(prediction.end.from, prediction.end.band)}`}${prediction.each === true ? ", of each deleted replica" : ""}${prediction.flaps === true ? ", in each cycle" : ""}${prediction.nodes === "paused" ? ", on the paused node" : ""}${prediction.certain ? ", at least one" : ""}${prediction.outcomes === void 0 ? "" : `, each one ${prediction.outcomes.join(" or ")}`}${prediction.afterReset === void 0 ? "" : `, or a ${prediction.afterReset.outcome} up to ${format(prediction.afterReset.life)} after a reset on its port`}${prediction.propagation === void 0 ? "" : `, the rules drop the replica in ${showBand(prediction.propagation)}`}${prediction.backlog === void 0 ? "" : `, the end n × ${showBand(prediction.backlog.drain)} later and ${prediction.backlog.requests.lo}–${prediction.backlog.requests.hi} more failures for each of the n sessions on the target${prediction.backlog.drains === true ? ", and its failures each turn in the drain of the n sessions" : ""}, counted at the measured period${prediction.backlog.slowest === void 0 ? "" : `, one session draining up to ${format(prediction.backlog.slowest)}`}${prediction.backlog.early === true ? ", the last failure up to one turn before the end" : ""}`}`;
 		case "removal": return `Service empty in ${showBand(prediction.band)}${prediction.flaps === true ? " after each fault, and ready again before the next" : ""}${prediction.window === void 0 ? "" : `; ${predictionText(prediction.window)}`}`;
 		case "leaves": return `the replica leaves in ${showBand(prediction.band)}${prediction.window === void 0 ? "" : `; ${predictionText(prediction.window)}`}`;
 		case "restarts": return prediction.band === null ? "no restart" : `each replica SIGTERM in ${showBand(prediction.band)}`;
@@ -1711,7 +1740,9 @@ const recordOf = (a, main) => {
 				hi: count
 			}),
 			most: count,
-			drains: z.boolean().optional()
+			drains: z.boolean().optional(),
+			slowest: a.optional(),
+			early: z.boolean().optional()
 		}).optional(),
 		why: z.string()
 	});
@@ -1938,6 +1969,6 @@ const readRecord = (data) => {
 	throw new Error(`a kind cell record has the format ${FORMAT} or ${FORMAT_V1}, not ${String(format)}`);
 };
 //#endregion
-export { restartsAt as $, RELATIVE as A, dropOf as B, observationEnd as C, drainBand as Ct, reusesReset as D, showBand as Dt, referenceOf as E, secondsOf as Et, TCP_STATE as F, kernelCounts as G, failuresOf as H, backendsAt as I, podsAt as J, outcomesOf as K, byClients as L, middle as M, quantileOf as N, unitOf as O, HBONE_PORT as P, restartOf as Q, byNode as R, observationAfter as S, bandOf as St, propagationSource as T, seconds as Tt, intakeOf as U, emptyOf as V, isTunnelState as W, recordsOf as X, podsOf as Y, requestsOf as Z, checkRun as _, LOG_LABEL as _t, calibrationOf as a, sliceEmptyOf as at, factsOf as b, SERVER as bt, predictionText as c, slicesOf as ct, FORMAT_V1 as d, transitionOf as dt, rulesOf as et, judge as f, tunnelsOf as ft, LAST_SLACK as g, HEALTH_PORT as gt, KIND_NOISE as h, CLIENT as ht, readRecord as i, sliceDropOf as it, medianInterval as j, updatesOf as k, timeSpread as l, socketsOf as lt, upgradeCell as m, ztunnelReplaced as mt, kindCellRecordSchema as n, signalOf as nt, cellsTable as o, sliceReadyAt as ot, upgrade as p, ztunnelPodsOf as pt, periodOf as q, kindCellRecordV1Schema as r, signalsOf as rt, medianText as s, sliceReadyOf as st, STAGES as t, sessionsAt as tt, FORMAT as u, stoppingOf as ut, cyclesOf as v, PORT as vt, propagationOf as w, requestBand as wt, judgeKind as x, backlogEnd as xt, deletionsOf as y, REDIS as yt, deletionOf as z };
+export { signalsOf as $, HBONE_PORT as A, isTunnelState as B, observationEnd as C, drainBand as Ct, reusesReset as D, secondsOf as Dt, referenceOf as E, seconds as Et, deletionOf as F, podsOf as G, outcomesOf as H, dropOf as I, restartOf as J, recordsOf as K, emptyOf as L, backendsAt as M, byClients as N, unitOf as O, showBand as Ot, byNode as P, signalOf as Q, failuresOf as R, observationAfter as S, bandOf as St, propagationSource as T, requestBand as Tt, periodOf as U, kernelCounts as V, podsAt as W, rulesOf as X, restartsAt as Y, sessionsAt as Z, checkRun as _, LOG_LABEL as _t, calibrationOf as a, socketsOf as at, factsOf as b, SERVER as bt, predictionText as c, tunnelsOf as ct, FORMAT_V1 as d, RELATIVE as dt, sliceDropOf as et, judge as f, medianInterval$1 as ft, LAST_SLACK as g, HEALTH_PORT as gt, KIND_NOISE as h, CLIENT as ht, readRecord as i, slicesOf as it, TCP_STATE as j, updatesOf as k, timeSpread as l, ztunnelPodsOf as lt, upgradeCell as m, quantileOf as mt, kindCellRecordSchema as n, sliceReadyAt as nt, cellsTable as o, stoppingOf as ot, upgrade as p, middle as pt, requestsOf as q, kindCellRecordV1Schema as r, sliceReadyOf as rt, medianText as s, transitionOf as st, STAGES as t, sliceEmptyOf as tt, FORMAT as u, ztunnelReplaced as ut, cyclesOf as v, PORT as vt, propagationOf as w, overshootBand as wt, judgeKind as x, backlogEnd as xt, deletionsOf as y, REDIS as yt, intakeOf as z };
 
-//# sourceMappingURL=judge-45z0yZ-r.js.map
+//# sourceMappingURL=judge-Bc84w-no.js.map