@mark1russell7/kind 0.13.3 → 0.14.0

package/build/{judge-DhLShDUj.d.ts → judge-Cp3MzMk1.d.ts}

@@ -1,6 +1,7 @@
 import { Extent, Quantity } from "@mark1russell7/quantity";
 import { z } from "zod";
 import { Coupling, Gate, Poll, Stage, Timing } from "@mark1russell7/service";
+import { Substrate } from "@mark1russell7/harness";
 import { RedisKnobs } from "@mark1russell7/service/redis";
 import { SessionCheckKnobs } from "@mark1russell7/service/http-client";
 //#region src/scenario.d.ts
@@ -430,6 +431,10 @@ interface ResetReuse<A = Quantity> {
  *   the socket of its last request before the fault. With `window`, the failed requests also start in that window.
  *   With `of: "tunnel"`, the HBONE connection of the ztunnel of each client ends in the band instead.
  *   With `answer`, the close of the peer in that band is an answer to the close of the client.
+ * - `reconnects`: a producer of a message broker gets its connection again after its broker stops
+ *   (`ReconnectsPrediction`). The lookups name another broker in the band `flip`. Each producer is back
+ *   at the first try of its backoff after that change, and its sends fail only until then.
+ *   With `owner: "either"`, the stopped broker can start again and take the topic back.
  * - `measured`: no document bounds the outcome. The run keeps the measurement.
  */
 type Prediction<A = Quantity> = NonePrediction | WindowPrediction<A> | {
@@ -478,10 +483,49 @@ type Prediction<A = Quantity> = NonePrediction | WindowPrediction<A> | {
    */
   readonly answer?: Band<A> | undefined;
   readonly why: string;
-} | {
+} | ReconnectsPrediction<A> | {
   readonly kind: "measured";
   readonly why: string;
 };
+/**
+ * A backoff is the delays of a client between its tries to connect again. The first delay is
+ * `initial`, and each next delay is two times the last, up to `max`. One delay is shorter: the try
+ * after it comes `mandatoryStop` after the first delay. The client takes a random share of up to
+ * `jitter` from each delay. A failed try takes up to `attempt`.
+ */
+interface Backoff<A = Quantity> {
+  readonly initial: A;
+  readonly max: A;
+  readonly mandatoryStop: A;
+  readonly jitter: number;
+  readonly attempt: A;
+}
+/**
+ * A reconnects prediction is the return of the producers of a broker after the stop of the broker
+ * that owns their topic (SYS-56). Each band is from the fault.
+ */
+interface ReconnectsPrediction<A = Quantity> {
+  readonly kind: "reconnects";
+  /** This band is the first lookup that names another broker as the owner of the topic. */
+  readonly flip: Band<A>;
+  /**
+   * This value says which broker owns the topic after the change. With `other`, the default, a lookup
+   * names another broker. With `either`, the stopped broker can start again and take the topic back.
+   * Then the lookups name one broker before and after the change, and only `flip` bounds the tries.
+   */
+  readonly owner?: "other" | "either" | undefined;
+  /** This time is the most from the change of the owner to the first lookup that names it. */
+  readonly probe: A;
+  /** This band is the first delay of each producer before its first try. */
+  readonly disconnect: Band<A>;
+  /** This backoff is the delays of each producer between its tries. */
+  readonly backoff: Backoff<A>;
+  /** This band is from the try that succeeds to the producer on the new owner. */
+  readonly setup: Band<A>;
+  /** These outcomes are the only failures of a send. */
+  readonly outcomes: readonly string[];
+  readonly why: string;
+}
 /** A prediction of no failure: no request fails in the run, or none with an outcome of `outcomes`. */
 interface NonePrediction {
   readonly kind: "none";
@@ -643,6 +687,8 @@ interface KindRun {
   readonly target: Replica | null;
   /** This node is the node whose kube-proxy paused, or null. */
   readonly paused: string | null;
+  /** This pod is the broker that owned the topic at the fault, for a cell with a broker (`KindCell.pulsar`). */
+  readonly broker?: string | undefined;
   readonly replicas: readonly Replica[];
   readonly void: string | null;
   readonly lines: ReadonlyArray<{
@@ -685,6 +731,18 @@ interface KindCell<A = Quantity> {
    * each request to the VIP. Without it, the cell has no VIP.
    */
   readonly vip?: VipSettings | undefined;
+  /**
+   * This broker is Apache Pulsar (SYS-56). With it, the cluster has Pulsar, and `clients` more pods
+   * send messages to one topic and look up its owner. Without it, the cell has no broker.
+   */
+  readonly pulsar?: PulsarSettings | undefined;
+}
+/** These are the settings of the broker of a cell (`KindCell.pulsar`). */
+interface PulsarSettings {
+  /** This count is the pods of the producers, one on each worker. */
+  readonly clients: number;
+  /** This time is between two lookups of the owner of the topic by each client pod. */
+  readonly probe: Quantity;
 }
 /** This name is an announcer of a VIP: kube-vip in ARP mode (SYS-51), or MetalLB in L2 mode (SYS-53). */
 type VipAnnouncerName = "kube-vip" | "metallb";
@@ -694,6 +752,18 @@ interface VipSettings {
   readonly clients: number;
   /** This name is the announcer of the VIP (`announcer.ts`). Without it, the announcer is kube-vip. */
   readonly announcer?: VipAnnouncerName | undefined;
+  /**
+   * These are the settings of memberlist for the speakers of MetalLB (SYS-57). With them, the install
+   * writes the config file of memberlist, with each other value of `DefaultLANConfig`. Without them,
+   * the install writes no file.
+   */
+  readonly memberlist?: MemberlistSettings | undefined;
+}
+/** A cell can change these settings of memberlist: the probe interval, the wait for an ack, and the multiplier of the suspicion timeout. */
+interface MemberlistSettings {
+  readonly probeInterval: Quantity;
+  readonly probeTimeout: Quantity;
+  readonly suspicionMult: number;
 }
 //#endregion
 //#region src/bands.d.ts
@@ -1108,6 +1178,25 @@ interface RunFacts<A = Quantity> {
    * with fewer than 2 requests of each client does not have it. A record before SYS-41 does not have it.
    */
   readonly period?: Period<A> | undefined;
+  /**
+   * These are the facts of the return of the producers (`reconnects`, SYS-56). They are the first
+   * lookup with another owner, the gap of the lookups before it, each producer, and the failed sends
+   * by outcome. Each time is from the fault, but `gap`.
+   */
+  readonly reconnects?: ReconnectsFacts<A> | undefined;
+}
+/** These are the facts of the return of the producers of a run (`RunFacts.reconnects`). */
+interface ReconnectsFacts<A = Quantity> {
+  readonly flip: A | null;
+  readonly gap: A | null;
+  readonly returns: ReadonlyArray<{
+    readonly pod: string;
+    readonly disconnect: A | null;
+    readonly back: A | null;
+    readonly setup: A | null;
+    readonly tries: number;
+  }>;
+  readonly failures: Readonly<Record<string, number>>;
 }
 /** A deleted replica is a replica of a run that got a deletion. It gives its pod, and the stamps of its intake (or null) and of its deletion. */
 interface Deleted {
@@ -1261,6 +1350,8 @@ interface EnvironmentManifest {
   readonly scenario: KindScenario;
   readonly cluster: ClusterManifest;
   readonly images: Readonly<Record<string, string>>;
+  /** This block tells the layer, the cloud and the kernel of the record. A record from before it reads through `substrateOf`. */
+  readonly substrate?: Substrate;
 }
 /**
  * A kind cell result is a cell, its runs over its environments, the manifest of each environment,
@@ -1390,5 +1481,95 @@ declare const quantileOf: (sorted: readonly number[], p: number) => number;
  */
 declare const medianInterval: (sorted: readonly number[]) => [number, number];
 //#endregion
-export { unitOf as $, cidrRange as $n, OUTSIDE as $t, TriggerV1 as A, Reference as An, recordsOf as At, RunCheck as B, Workload as Bn, sliceReadyAt as Bt, KindCellResult as C, MeshFlavor as Cn, intakeOf as Ct, PredictionV1 as D, PodSettings as Dn, periodOf as Dt, LoadSample as E, PermittedWindow as En, outcomesOf as Et, KIND_NOISE as F, Trigger as Fn, sessionsAt as Ft, factsOf as G, KindScenario as Gn, transitionOf as Gt, checkRun as H, Dataplane as Hn, slicesOf as Ht, KindDecision as I, TriggerKind as In, signalOf as It, observationEnd as J, NodeImage as Jn, ztunnelReplaced as Jt, judgeKind as K, KubeProxyMode as Kn, tunnelsOf as Kt, KindVerdict as L, VipAnnouncerName as Ln, signalsOf as Lt, upgrade as M, ResetReuse as Mn, restartOf as Mt, upgradeCell as N, Stack as Nn, restartsAt as Nt, RunCheckV1 as O, Prediction as On, podsAt as Ot, Deleted as P, Template as Pn, rulesOf as Pt, reusesReset as Q, cidrOverlap as Qn, LOG_LABEL as Qt, LAST_SLACK as R, VipSettings as Rn, sliceDropOf as Rt, KindCellRecordV1 as S, Mesh as Sn, failuresOf as St, KindVerdictV1 as T, NonePrediction as Tn, kernelCounts as Tt, cyclesOf as U, KUBE_PROXY_MODES as Un, socketsOf as Ut, RunFacts as V, DATAPLANES as Vn, sliceReadyOf as Vt, deletionsOf as W, KindConfig as Wn, stoppingOf as Wt, propagationSource as X, ZONE_LABEL as Xn, HEALTH_PORT as Xt, propagationOf as Y, ZONE_KEPT as Yn, CLIENT as Yt, referenceOf as Z, ZONE_LOST as Zn, LB_CLASS as Zt, ClusterManifest as _, EdgeProtocol as _n, byClients as _t, STAGES as a, backlogEnd as an, scenario as ar, PodLine as at, FORMAT_V1 as b, KindRun as bn, dropOf as bt, readRecord as c, overshootBand as cn, Request as ct, calibrationOf as d, secondsOf as dn, SliceLine as dt, PORT as en, goDuration as er, updatesOf as et, cellsTable as f, showBand as fn, SocketLine as ft, BandV1 as g, Declaration as gn, backendsAt as gt, timeSpread as h, Cycle as hn, ZtunnelPodLine as ht, quantileOf as i, CountBand as in, nodeNames as ir, Period as it, judge as j, Replica as jn, requestsOf as jt, RunFactsV1 as k, RedisDeclaration as kn, podsOf as kt, Judged as l, requestBand as ln, RulesLine as lt, predictionText as m, Band as mn, TunnelLine as mt, medianInterval as n, SERVER as nn, kindConfig as nr, HBONE_PORT as nt, kindCellRecordSchema as o, bandOf as on, scenarioProblems as or, PropagationSource as ot, medianText as p, BacklogTerm as pn, TCP_STATE as pt, observationAfter as q, NODE_IMAGES as qn, ztunnelPodsOf as qt, middle as r, VIP_ANNOTATION as rn, kubeProxyPatch as rr, Line as rt, kindCellRecordV1Schema as s, drainBand as sn, zoneOf as sr, RecordLine as st, RELATIVE as t, REDIS as tn, isKubeProxyMode as tr, Endpoint as tt, TimeSpread as u, seconds as un, Sessions as ut, EnvironmentManifest as v, Flap as vn, byNode as vt, KindCellV1 as w, MeshMode as wn, isTunnelState as wt, KindCellRecord as x, KubeletProbe as xn, emptyOf as xt, FORMAT as y, KindCell as yn, deletionOf as yt, Propagated as z, WindowPrediction as zn, sliceEmptyOf as zt };
-//# sourceMappingURL=judge-DhLShDUj.d.ts.map
+//#region src/reconnects.d.ts
+/**
+ * This module judges the return of the producers of a message broker after the stop of the broker
+ * that owns their topic (SYS-56). It knows the backoff of a client and the lines of the lab, and
+ * nothing of Pulsar. Each time is in milliseconds, on the clock of the lines.
+ *
+ * The backoff is the law of `Backoff::next` of the C++ client of Pulsar 4.2.0 (lib/Backoff.cc,
+ * lines 33–57). The first delay is the initial delay, and each next delay is two times the last, up
+ * to the most. The first call keeps its time. If a later call ends after the mandatory stop, it
+ * gets the rest of the time to that stop, once. Then the call takes a random share of up to the
+ * jitter from the delay. The delay is not below the initial delay at any time.
+ */
+/** A try is the earliest and the latest time of one try to connect, after the first delay starts. */
+interface Try {
+  readonly lo: number;
+  readonly hi: number;
+}
+/**
+ * This function gives the band of each try after the first delay starts, up to the first try whose
+ * earliest time is after `until`. The earliest path has the most jitter and no time for a try. The
+ * latest path has no jitter and `attempt` for each failed try. A later call gets a delay that ends no
+ * earlier, thus each try of a path between them is in the band.
+ */
+declare const triesOf: (backoff: Backoff, until: number) => Try[];
+/**
+ * This function gives the latest return of a producer after the fault, from the bands of the
+ * prediction. It adds three terms. The first is the first delay at its latest. The second is the
+ * latest time of the first try that cannot come before the latest change of the owner. The third
+ * is the latest setup.
+ */
+declare const latestReturn: (prediction: ReconnectsPrediction) => number;
+/** A schedule is one call of the backoff of a producer: when, and its delay in milliseconds. */
+interface Schedule {
+  readonly t: number;
+  readonly delay: number;
+}
+/** A return is the facts of one producer in one run. */
+interface Return {
+  readonly pod: string;
+  /** This time is the first call of the backoff after the fault, from the fault. */
+  readonly disconnect: number | null;
+  /** These are the calls of the backoff from the fault to the producer on the new owner. */
+  readonly schedules: readonly Schedule[];
+  /** This time is the producer on the new owner, from the fault, or null. */
+  readonly back: number | null;
+  /** This time is from the try that succeeded to the producer on the new owner. */
+  readonly setup: number | null;
+  /** This count is the tries up to the one that succeeded. */
+  readonly tries: number;
+  readonly ok: boolean;
+  readonly why: string;
+}
+/** A judgement is the facts of one run: the change of the owner, each producer, and the failed sends. */
+interface Reconnects {
+  readonly ok: boolean;
+  readonly why: string;
+  /** This time is the first lookup that names another owner, from the fault, or null. */
+  readonly flip: number | null;
+  /** This time is from the last lookup before that change to it. */
+  readonly gap: number | null;
+  readonly returns: readonly Return[];
+  /** This count is the sends of the producers that failed, by outcome. */
+  readonly failures: Readonly<Record<string, number>>;
+  /** This time is the median return of the producers, from the fault, or null. */
+  readonly value: number | null;
+}
+/**
+ * This function judges one run: the fault at `fault`, the broker `broker` that owned the topic, and
+ * the lines of the run. A lookup line is `{ev: "lookup", t, o, owner}`, a line of the client is
+ * `{ev: "pulsar", t, p, m}`, and a send is `{ev: "send", t, d, o, p}`. `timeout` and `every` are the
+ * timeout and the interval of the sends. Each check has a margin of `noise`.
+ *
+ * For each producer, the delays of its backoff follow the law, from the observed time of each call.
+ * Its last try comes after the last lookup that named the old owner. The try before it comes no
+ * later than the first lookup that named another. Then the setup is in its band. Each failed send
+ * starts between the fault and the return, with an outcome of the prediction. At least one fails.
+ *
+ * With `owner: "either"`, the lookups can name the old owner for the whole run, because it started
+ * again and took the topic back. Then the last try comes after the start of the band `flip`. The
+ * try before it comes no later than the end of that band.
+ */
+declare const judgeReconnects: (prediction: ReconnectsPrediction, run: {
+  readonly fault: number;
+  readonly broker: string;
+  readonly lines: readonly Line[];
+}, sends: {
+  readonly timeout: number;
+  readonly every: number;
+}, noise: number) => Reconnects;
+//#endregion
+export { factsOf as $, DATAPLANES as $n, transitionOf as $t, KindCellResult as A, KubeletProbe as An, failuresOf as At, upgradeCell as B, ReconnectsPrediction as Bn, restartOf as Bt, BandV1 as C, Band as Cn, ZtunnelPodLine as Ct, FORMAT_V1 as D, Flap as Dn, deletionOf as Dt, FORMAT as E, EdgeProtocol as En, byNode as Et, RunCheckV1 as F, NonePrediction as Fn, periodOf as Ft, LAST_SLACK as G, Stack as Gn, signalsOf as Gt, KIND_NOISE as H, Reference as Hn, rulesOf as Ht, RunFactsV1 as I, PermittedWindow as In, podsAt as It, RunCheck as J, TriggerKind as Jn, sliceReadyAt as Jt, Propagated as K, Template as Kn, sliceDropOf as Kt, TriggerV1 as L, PodSettings as Ln, podsOf as Lt, KindVerdictV1 as M, Mesh as Mn, isTunnelState as Mt, LoadSample as N, MeshFlavor as Nn, kernelCounts as Nt, KindCellRecord as O, KindCell as On, dropOf as Ot, PredictionV1 as P, MeshMode as Pn, outcomesOf as Pt, deletionsOf as Q, Workload as Qn, stoppingOf as Qt, judge as R, Prediction as Rn, recordsOf as Rt, timeSpread as S, Backoff as Sn, TunnelLine as St, EnvironmentManifest as T, Declaration as Tn, byClients as Tt, KindDecision as U, Replica as Un, sessionsAt as Ut, Deleted as V, RedisDeclaration as Vn, restartsAt as Vt, KindVerdict as W, ResetReuse as Wn, signalOf as Wt, checkRun as X, VipSettings as Xn, slicesOf as Xt, RunFacts as Y, VipAnnouncerName as Yn, sliceReadyOf as Yt, cyclesOf as Z, WindowPrediction as Zn, socketsOf as Zt, TimeSpread as _, requestBand as _n, scenario as _r, RulesLine as _t, judgeReconnects as a, LB_CLASS as an, NODE_IMAGES as ar, referenceOf as at, medianText as b, showBand as bn, SocketLine as bt, RELATIVE as c, PORT as cn, ZONE_LABEL as cr, updatesOf as ct, quantileOf as d, VIP_ANNOTATION as dn, cidrRange as dr, Line as dt, tunnelsOf as en, Dataplane as er, judgeKind as et, STAGES as f, CountBand as fn, goDuration as fr, Period as ft, Judged as g, overshootBand as gn, nodeNames as gr, Request as gt, readRecord as h, drainBand as hn, kubeProxyPatch as hr, RecordLine as ht, Try as i, HEALTH_PORT as in, KubeProxyMode as ir, propagationSource as it, KindCellV1 as j, MemberlistSettings as jn, intakeOf as jt, KindCellRecordV1 as k, KindRun as kn, emptyOf as kt, medianInterval as l, REDIS as ln, ZONE_LOST as lr, Endpoint as lt, kindCellRecordV1Schema as m, bandOf as mn, kindConfig as mr, PropagationSource as mt, Return as n, ztunnelReplaced as nn, KindConfig as nr, observationEnd as nt, latestReturn as o, LOG_LABEL as on, NodeImage as or, reusesReset as ot, kindCellRecordSchema as p, backlogEnd as pn, isKubeProxyMode as pr, PodLine as pt, ReconnectsFacts as q, Trigger as qn, sliceEmptyOf as qt, Schedule as r, CLIENT as rn, KindScenario as rr, propagationOf as rt, triesOf as s, OUTSIDE as sn, ZONE_KEPT as sr, unitOf as st, Reconnects as t, ztunnelPodsOf as tn, KUBE_PROXY_MODES as tr, observationAfter as tt, middle as u, SERVER as un, cidrOverlap as ur, HBONE_PORT as ut, calibrationOf as v, seconds as vn, scenarioProblems as vr, Sessions as vt, ClusterManifest as w, Cycle as wn, backendsAt as wt, predictionText as x, BacklogTerm as xn, TCP_STATE as xt, cellsTable as y, secondsOf as yn, zoneOf as yr, SliceLine as yt, upgrade as z, PulsarSettings as zn, requestsOf as zt };
+//# sourceMappingURL=judge-Cp3MzMk1.d.ts.map

package/build/judge.d.ts

@@ -1,2 +1,2 @@
-import { $ as unitOf, $t as OUTSIDE, A as TriggerV1, An as Reference, At as recordsOf, B as RunCheck, Bn as Workload, Bt as sliceReadyAt, C as KindCellResult, Cn as MeshFlavor, Ct as intakeOf, D as PredictionV1, Dn as PodSettings, Dt as periodOf, E as LoadSample, En as PermittedWindow, Et as outcomesOf, F as KIND_NOISE, Fn as Trigger, Ft as sessionsAt, G as factsOf, Gt as transitionOf, H as checkRun, Hn as Dataplane, Ht as slicesOf, I as KindDecision, In as TriggerKind, It as signalOf, J as observationEnd, Jt as ztunnelReplaced, K as judgeKind, Kn as KubeProxyMode, Kt as tunnelsOf, L as KindVerdict, Ln as VipAnnouncerName, Lt as signalsOf, M as upgrade, Mn as ResetReuse, Mt as restartOf, N as upgradeCell, Nn as Stack, Nt as restartsAt, O as RunCheckV1, On as Prediction, Ot as podsAt, P as Deleted, Pn as Template, Pt as rulesOf, Q as reusesReset, Qt as LOG_LABEL, R as LAST_SLACK, Rn as VipSettings, Rt as sliceDropOf, S as KindCellRecordV1, Sn as Mesh, St as failuresOf, T as KindVerdictV1, Tn as NonePrediction, Tt as kernelCounts, U as cyclesOf, Ut as socketsOf, V as RunFacts, Vt as sliceReadyOf, W as deletionsOf, Wt as stoppingOf, X as propagationSource, Xt as HEALTH_PORT, Y as propagationOf, Yt as CLIENT, Z as referenceOf, Zt as LB_CLASS, _ as ClusterManifest, _n as EdgeProtocol, _t as byClients, a as STAGES, an as backlogEnd, at as PodLine, b as FORMAT_V1, bn as KindRun, bt as dropOf, c as readRecord, cn as overshootBand, ct as Request, d as calibrationOf, dn as secondsOf, dt as SliceLine, en as PORT, et as updatesOf, f as cellsTable, fn as showBand, ft as SocketLine, g as BandV1, gn as Declaration, gt as backendsAt, h as timeSpread, hn as Cycle, ht as ZtunnelPodLine, i as quantileOf, in as CountBand, it as Period, j as judge, jn as Replica, jt as requestsOf, k as RunFactsV1, kn as RedisDeclaration, kt as podsOf, l as Judged, ln as requestBand, lt as RulesLine, m as predictionText, mn as Band, mt as TunnelLine, n as medianInterval, nn as SERVER, nt as HBONE_PORT, o as kindCellRecordSchema, on as bandOf, ot as PropagationSource, p as medianText, pn as BacklogTerm, pt as TCP_STATE, q as observationAfter, qt as ztunnelPodsOf, r as middle, rn as VIP_ANNOTATION, rt as Line, s as kindCellRecordV1Schema, sn as drainBand, st as RecordLine, t as RELATIVE, tn as REDIS, tt as Endpoint, u as TimeSpread, un as seconds, ut as Sessions, v as EnvironmentManifest, vn as Flap, vt as byNode, w as KindCellV1, wn as MeshMode, wt as isTunnelState, x as KindCellRecord, xn as KubeletProbe, xt as emptyOf, y as FORMAT, yn as KindCell, yt as deletionOf, z as Propagated, zn as WindowPrediction, zt as sliceEmptyOf } from "./judge-DhLShDUj.js";
-export { type BacklogTerm, type Band, type BandV1, CLIENT, type ClusterManifest, type CountBand, type Cycle, type Dataplane, type Declaration, type Deleted, type EdgeProtocol, Endpoint, type EnvironmentManifest, FORMAT, FORMAT_V1, type Flap, HBONE_PORT, HEALTH_PORT, type Judged, KIND_NOISE, type KindCell, type KindCellRecord, type KindCellRecordV1, type KindCellResult, type KindCellV1, type KindDecision, type KindRun, type KindVerdict, type KindVerdictV1, type KubeProxyMode, type KubeletProbe, LAST_SLACK, LB_CLASS, LOG_LABEL, Line, type LoadSample, type Mesh, type MeshFlavor, type MeshMode, type NonePrediction, OUTSIDE, PORT, Period, type PermittedWindow, PodLine, type PodSettings, type Prediction, type PredictionV1, type Propagated, PropagationSource, REDIS, RELATIVE, RecordLine, type RedisDeclaration, type Reference, type Replica, Request, type ResetReuse, RulesLine, type RunCheck, type RunCheckV1, type RunFacts, type RunFactsV1, SERVER, STAGES, Sessions, SliceLine, SocketLine, type Stack, TCP_STATE, type Template, type TimeSpread, type Trigger, type TriggerKind, type TriggerV1, TunnelLine, VIP_ANNOTATION, type VipAnnouncerName, type VipSettings, type WindowPrediction, type Workload, ZtunnelPodLine, backendsAt, backlogEnd, bandOf, byClients, byNode, calibrationOf, cellsTable, checkRun, cyclesOf, deletionOf, deletionsOf, drainBand, dropOf, emptyOf, factsOf, failuresOf, intakeOf, isTunnelState, judge, judgeKind, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, medianInterval, medianText, middle, observationAfter, observationEnd, outcomesOf, overshootBand, periodOf, podsAt, podsOf, predictionText, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, referenceOf, requestBand, requestsOf, restartOf, restartsAt, reusesReset, rulesOf, seconds, secondsOf, sessionsAt, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, sliceReadyAt, sliceReadyOf, slicesOf, socketsOf, stoppingOf, timeSpread, transitionOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, ztunnelPodsOf, ztunnelReplaced };
+import { $ as factsOf, $t as transitionOf, A as KindCellResult, An as KubeletProbe, At as failuresOf, B as upgradeCell, Bn as ReconnectsPrediction, Bt as restartOf, C as BandV1, Cn as Band, Ct as ZtunnelPodLine, D as FORMAT_V1, Dn as Flap, Dt as deletionOf, E as FORMAT, En as EdgeProtocol, Et as byNode, F as RunCheckV1, Fn as NonePrediction, Ft as periodOf, G as LAST_SLACK, Gn as Stack, Gt as signalsOf, H as KIND_NOISE, Hn as Reference, Ht as rulesOf, I as RunFactsV1, In as PermittedWindow, It as podsAt, J as RunCheck, Jn as TriggerKind, Jt as sliceReadyAt, K as Propagated, Kn as Template, Kt as sliceDropOf, L as TriggerV1, Ln as PodSettings, Lt as podsOf, M as KindVerdictV1, Mn as Mesh, Mt as isTunnelState, N as LoadSample, Nn as MeshFlavor, Nt as kernelCounts, O as KindCellRecord, On as KindCell, Ot as dropOf, P as PredictionV1, Pn as MeshMode, Pt as outcomesOf, Q as deletionsOf, Qn as Workload, Qt as stoppingOf, R as judge, Rn as Prediction, Rt as recordsOf, S as timeSpread, Sn as Backoff, St as TunnelLine, T as EnvironmentManifest, Tn as Declaration, Tt as byClients, U as KindDecision, Un as Replica, Ut as sessionsAt, V as Deleted, Vn as RedisDeclaration, Vt as restartsAt, W as KindVerdict, Wn as ResetReuse, Wt as signalOf, X as checkRun, Xn as VipSettings, Xt as slicesOf, Y as RunFacts, Yn as VipAnnouncerName, Yt as sliceReadyOf, Z as cyclesOf, Zn as WindowPrediction, Zt as socketsOf, _ as TimeSpread, _n as requestBand, _t as RulesLine, a as judgeReconnects, an as LB_CLASS, at as referenceOf, b as medianText, bn as showBand, bt as SocketLine, c as RELATIVE, cn as PORT, ct as updatesOf, d as quantileOf, dn as VIP_ANNOTATION, dt as Line, en as tunnelsOf, er as Dataplane, et as judgeKind, f as STAGES, fn as CountBand, ft as Period, g as Judged, gn as overshootBand, gt as Request, h as readRecord, hn as drainBand, ht as RecordLine, i as Try, in as HEALTH_PORT, ir as KubeProxyMode, it as propagationSource, j as KindCellV1, jn as MemberlistSettings, jt as intakeOf, k as KindCellRecordV1, kn as KindRun, kt as emptyOf, l as medianInterval, ln as REDIS, lt as Endpoint, m as kindCellRecordV1Schema, mn as bandOf, mt as PropagationSource, n as Return, nn as ztunnelReplaced, nt as observationEnd, o as latestReturn, on as LOG_LABEL, ot as reusesReset, p as kindCellRecordSchema, pn as backlogEnd, pt as PodLine, q as ReconnectsFacts, qn as Trigger, qt as sliceEmptyOf, r as Schedule, rn as CLIENT, rt as propagationOf, s as triesOf, sn as OUTSIDE, st as unitOf, t as Reconnects, tn as ztunnelPodsOf, tt as observationAfter, u as middle, un as SERVER, ut as HBONE_PORT, v as calibrationOf, vn as seconds, vt as Sessions, w as ClusterManifest, wn as Cycle, wt as backendsAt, x as predictionText, xn as BacklogTerm, xt as TCP_STATE, y as cellsTable, yn as secondsOf, yt as SliceLine, z as upgrade, zn as PulsarSettings, zt as requestsOf } from "./judge-Cp3MzMk1.js";
+export { type BacklogTerm, type Backoff, type Band, type BandV1, CLIENT, type ClusterManifest, type CountBand, type Cycle, type Dataplane, type Declaration, type Deleted, type EdgeProtocol, Endpoint, type EnvironmentManifest, FORMAT, FORMAT_V1, type Flap, HBONE_PORT, HEALTH_PORT, type Judged, KIND_NOISE, type KindCell, type KindCellRecord, type KindCellRecordV1, type KindCellResult, type KindCellV1, type KindDecision, type KindRun, type KindVerdict, type KindVerdictV1, type KubeProxyMode, type KubeletProbe, LAST_SLACK, LB_CLASS, LOG_LABEL, Line, type LoadSample, type MemberlistSettings, type Mesh, type MeshFlavor, type MeshMode, type NonePrediction, OUTSIDE, PORT, Period, type PermittedWindow, PodLine, type PodSettings, type Prediction, type PredictionV1, type Propagated, PropagationSource, type PulsarSettings, REDIS, RELATIVE, type Reconnects, type ReconnectsFacts, type ReconnectsPrediction, RecordLine, type RedisDeclaration, type Reference, type Replica, Request, type ResetReuse, type Return, RulesLine, type RunCheck, type RunCheckV1, type RunFacts, type RunFactsV1, SERVER, STAGES, type Schedule, Sessions, SliceLine, SocketLine, type Stack, TCP_STATE, type Template, type TimeSpread, type Trigger, type TriggerKind, type TriggerV1, type Try, TunnelLine, VIP_ANNOTATION, type VipAnnouncerName, type VipSettings, type WindowPrediction, type Workload, ZtunnelPodLine, backendsAt, backlogEnd, bandOf, byClients, byNode, calibrationOf, cellsTable, checkRun, cyclesOf, deletionOf, deletionsOf, drainBand, dropOf, emptyOf, factsOf, failuresOf, intakeOf, isTunnelState, judge, judgeKind, judgeReconnects, kernelCounts, kindCellRecordSchema, kindCellRecordV1Schema, latestReturn, medianInterval, medianText, middle, observationAfter, observationEnd, outcomesOf, overshootBand, periodOf, podsAt, podsOf, predictionText, propagationOf, propagationSource, quantileOf, readRecord, recordsOf, referenceOf, requestBand, requestsOf, restartOf, restartsAt, reusesReset, rulesOf, seconds, secondsOf, sessionsAt, showBand, signalOf, signalsOf, sliceDropOf, sliceEmptyOf, sliceReadyAt, sliceReadyOf, slicesOf, socketsOf, stoppingOf, timeSpread, transitionOf, triesOf, tunnelsOf, unitOf, updatesOf, upgrade, upgradeCell, ztunnelPodsOf, ztunnelReplaced };

package/build/judge.js

@@ -1 +1 @@
-export { ht as CLIENT, u as FORMAT, d as FORMAT_V1, A as HBONE_PORT, gt as HEALTH_PORT, h as KIND_NOISE, g as LAST_SLACK, _t as LB_CLASS, vt as LOG_LABEL, yt as OUTSIDE, bt as PORT, xt as REDIS, dt as RELATIVE, St as SERVER, t as STAGES, j as TCP_STATE, Ct as VIP_ANNOTATION, M as backendsAt, wt as backlogEnd, Tt as bandOf, N as byClients, P as byNode, a as calibrationOf, o as cellsTable, _ as checkRun, v as cyclesOf, F as deletionOf, y as deletionsOf, Et as drainBand, I as dropOf, L as emptyOf, b as factsOf, R as failuresOf, z as intakeOf, B as isTunnelState, f as judge, x as judgeKind, V as kernelCounts, n as kindCellRecordSchema, r as kindCellRecordV1Schema, ft as medianInterval, s as medianText, pt as middle, S as observationAfter, C as observationEnd, H as outcomesOf, Dt as overshootBand, U as periodOf, W as podsAt, G as podsOf, c as predictionText, w as propagationOf, T as propagationSource, mt as quantileOf, i as readRecord, K as recordsOf, E as referenceOf, Ot as requestBand, q as requestsOf, J as restartOf, Y as restartsAt, D as reusesReset, X as rulesOf, kt as seconds, At as secondsOf, Z as sessionsAt, jt as showBand, Q as signalOf, $ as signalsOf, et as sliceDropOf, tt as sliceEmptyOf, nt as sliceReadyAt, rt as sliceReadyOf, it as slicesOf, at as socketsOf, ot as stoppingOf, l as timeSpread, st as transitionOf, ct as tunnelsOf, O as unitOf, k as updatesOf, p as upgrade, m as upgradeCell, lt as ztunnelPodsOf, ut as ztunnelReplaced } from "./judge-DKrgfhAt.js";
+export { vt as CLIENT, u as FORMAT, d as FORMAT_V1, N as HBONE_PORT, yt as HEALTH_PORT, h as KIND_NOISE, g as LAST_SLACK, bt as LB_CLASS, xt as LOG_LABEL, St as OUTSIDE, Ct as PORT, wt as REDIS, mt as RELATIVE, Tt as SERVER, t as STAGES, P as TCP_STATE, Et as VIP_ANNOTATION, F as backendsAt, Dt as backlogEnd, Ot as bandOf, I as byClients, L as byNode, a as calibrationOf, o as cellsTable, _ as checkRun, v as cyclesOf, R as deletionOf, y as deletionsOf, kt as drainBand, z as dropOf, B as emptyOf, b as factsOf, V as failuresOf, H as intakeOf, U as isTunnelState, f as judge, x as judgeKind, A as judgeReconnects, W as kernelCounts, n as kindCellRecordSchema, r as kindCellRecordV1Schema, j as latestReturn, ht as medianInterval, s as medianText, gt as middle, S as observationAfter, C as observationEnd, G as outcomesOf, At as overshootBand, K as periodOf, q as podsAt, J as podsOf, c as predictionText, w as propagationOf, T as propagationSource, _t as quantileOf, i as readRecord, Y as recordsOf, E as referenceOf, jt as requestBand, X as requestsOf, Z as restartOf, Q as restartsAt, D as reusesReset, $ as rulesOf, Mt as seconds, Nt as secondsOf, et as sessionsAt, Pt as showBand, tt as signalOf, nt as signalsOf, rt as sliceDropOf, it as sliceEmptyOf, at as sliceReadyAt, ot as sliceReadyOf, st as slicesOf, ct as socketsOf, lt as stoppingOf, l as timeSpread, ut as transitionOf, M as triesOf, dt as tunnelsOf, O as unitOf, k as updatesOf, p as upgrade, m as upgradeCell, ft as ztunnelPodsOf, pt as ztunnelReplaced } from "./judge-C6XgY2Pk.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/kind",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "description": "Kubernetes in Docker as a lab for connection timers: a kind cluster from a scenario, faults in the namespaces of its pods, observations on the one monotonic clock of the VM, and predictions from the ordering law. Its judge entry reads and judges a raw record without Docker.",
   "keywords": [
     "kubernetes",
@@ -66,7 +66,7 @@
     "node": ">=22.19"
   },
   "dependencies": {
-    "@mark1russell7/harness": "^0.14.0",
+    "@mark1russell7/harness": "^0.14.3",
     "@mark1russell7/quantity": "^0.3.0",
     "@mark1russell7/rigor-statistics": "^0.1.3",
     "@mark1russell7/service": "^0.6.5",