@mark1russell7/harness 0.7.0 → 0.8.0

package/image/procedures/Dockerfile

@@ -0,0 +1,13 @@
+# The procedures image of the harness: @procedures/client 0.3.0 and ws 8.22.0 on Node 24.21.0. Its WebSocket
+# client runs as a container in the client's network namespace, as the harness's own TCP client
+# does, and prints the same JSON lines (client-ws.mjs). A target runs the same image with the
+# script of the procedures server (server-ws.mjs), thus the client and the server share one
+# release of the package. The digest of the image and an npm lockfile pin them.
+# lab.ts stages the build context: this folder, under harness/image/procedures. The lockfile is
+# npm-lock.json here, because npm leaves each package-lock.json out of a published tarball.
+FROM node:24.21.0-alpine@sha256:ebfe2f90462722a7a4de65e91990e97fe0d401c70e0e762c5b53302f905ec1c1
+WORKDIR /opt/harness/procedures
+COPY harness/image/procedures/package.json ./
+COPY harness/image/procedures/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/procedures/lines.mjs harness/image/procedures/client-ws.mjs harness/image/procedures/server-ws.mjs ./

package/image/procedures/client-ws.mjs

@@ -0,0 +1,234 @@
+// client-ws HOST PORT --mode idle|inflight --websocket global|ws
+//           --heartbeat on|off [--heartbeat-interval-ms N --heartbeat-timeout-ms N --heartbeat-misses N]
+//           --reconnect on|off [--reconnect-initial-ms N --reconnect-multiplier X --reconnect-max-ms N
+//                               --reconnect-attempts N --reconnect-jitter X]
+//           --request-timeout-ms N --connection-timeout-ms N [--hold-ms N] [--go PATH] [--max-s N]
+//
+// A cell's client: the WebSocket client of @procedures/client 0.3.0 (WebSocketTransport) on Node
+// 24.21.0. Its sockets are of the global WebSocket of Node, which is undici 7.29.1, or of the
+// WebSocket of the ws package (the option `webSocket`): --websocket. Each setting of the transport
+// is a flag, and the client has no default: a missing flag is a failure. 0.3.0 takes each time as a
+// duration, not a number. Both modes call `harness.echo` first; its reply is `ready`. idle: then
+// hold the connection. inflight: then wait for the file --go, and call `harness.echo` (or
+// `harness.hold` for --hold-ms) into the fault.
+//
+// The lines are those of the harness's TCP client, on CLOCK_MONOTONIC, and the program's own acts:
+//   dial {conn}            before each new socket of the transport (conn counts from 1)
+//   connected {conn, local} the socket opened: its local address
+//   ping {conn, local}     before each ping of the heartbeat
+//   write {conn, type}     before each other frame: a hello, a request, a cancel or a credit
+//   drop {conn, local}     before the transport ends a socket by itself: close() or terminate()
+//   reconnecting {attempt} the transport starts its reconnect timer (onReconnecting)
+//   status {status}        connected, disconnected (with the reason) or error, from the callbacks
+//   conn-end {conn, code}  the close event of each socket, with the errno of its socket error
+//   error {errno} / eof    the end of socket 1, the socket of the run, when the transport did not drop it
+//   sent / ready / data / call-error   each call, its reply, or its failure
+//
+// The client gives the transport a subclass of the class of its sockets. The subclass writes a
+// line, then calls its class: the transport, undici and ws do what they do without it. Its
+// listeners of `open` and `close` are its own, thus the transport cannot remove them. A drop line
+// with no local address is a socket that never opened: a try that failed.
+
+import { subscribe } from "node:diagnostics_channel";
+import { WebSocket as WsWebSocket } from "ws";
+import { bootId, commandLine, emit, now, waitFor } from "./lines.mjs";
+
+const USAGE =
+  "client-ws HOST PORT --mode idle|inflight --websocket global|ws --heartbeat on|off --reconnect on|off --request-timeout-ms N --connection-timeout-ms N";
+const line = commandLine(USAGE, 2);
+const [host, port] = line.args;
+const mode = line.required("--mode");
+if (mode !== "idle" && mode !== "inflight") line.fail("--mode is idle or inflight");
+const socketClass = line.required("--websocket");
+if (socketClass !== "global" && socketClass !== "ws") line.fail("--websocket is global or ws");
+/** This function gives a duration of milliseconds, as 0.3.0 takes each time. */
+const ms = (value) => ({ value, unit: "ms" });
+const heartbeat = line.toggle("--heartbeat")
+  ? {
+      enabled: true,
+      interval: line.number("--heartbeat-interval-ms"),
+      timeout: line.number("--heartbeat-timeout-ms"),
+      misses: line.number("--heartbeat-misses"),
+    }
+  : { enabled: false };
+const reconnect = line.toggle("--reconnect")
+  ? {
+      enabled: true,
+      initialDelay: line.number("--reconnect-initial-ms"),
+      backoffMultiplier: line.number("--reconnect-multiplier"),
+      maxDelay: line.number("--reconnect-max-ms"),
+      maxAttempts: line.number("--reconnect-attempts"),
+      jitter: line.number("--reconnect-jitter"),
+    }
+  : { enabled: false };
+const requestTimeout = line.number("--request-timeout-ms");
+const connectionTimeout = line.number("--connection-timeout-ms");
+const hold = line.flag("--hold-ms") === undefined ? undefined : line.number("--hold-ms");
+const go = line.flag("--go") ?? "/tmp/go";
+const max = Number(line.flag("--max-s") ?? 60) * 1000;
+
+emit("start", {
+  boot_id: bootId(),
+  mode,
+  client: "procedures-ws",
+  package: "@procedures/client 0.3.0",
+  websocket: socketClass,
+  node: process.version,
+  undici: process.versions.undici ?? null,
+  settings: { heartbeat, reconnect, requestTimeout, connectionTimeout, hold: hold ?? null },
+});
+
+/** These are the sockets of the transport, by their WebSocket: the number of each, its local address, and whether the transport dropped it. */
+const sockets = new WeakMap();
+let tries = 0;
+/** This is the last socket error that undici published. The close event of its socket follows it. */
+let pending;
+
+/** This function gives the type of a frame of the transport: its JSON `type`. */
+const typeOf = (data) => {
+  if (typeof data !== "string") return "binary";
+  try {
+    return JSON.parse(data).type ?? "unknown";
+  } catch {
+    return "text";
+  }
+};
+
+/** This function writes the local address of a socket that opened, once. */
+const opened = (socket, local) => {
+  if (socket === undefined || socket.local !== undefined || local === null) return;
+  socket.local = local;
+  emit("connected", { conn: socket.conn, local });
+};
+
+/** This function writes the drop of a socket by the transport, before its close() or its terminate(). */
+const dropped = (websocket, how) => {
+  const socket = sockets.get(websocket);
+  if (socket !== undefined) socket.dropped = true;
+  emit("drop", { conn: socket?.conn ?? null, local: socket?.local ?? null, how });
+};
+
+/**
+ * This function gives a subclass of a class of WebSockets that writes the acts of the transport.
+ * It has terminate() only when its class has it: the transport calls terminate() when it exists.
+ */
+const stamped = (Base) => {
+  class Stamped extends Base {
+    constructor(...args) {
+      const conn = ++tries;
+      emit("dial", { conn });
+      super(...args);
+      const socket = { conn, local: undefined, dropped: false };
+      sockets.set(this, socket);
+      // a socket of ws gives its local address at its open; undici gives it in a diagnostics channel
+      this.addEventListener("open", () => {
+        const raw = this._socket;
+        if (raw?.localAddress !== undefined) opened(socket, `${raw.localAddress}:${raw.localPort}`);
+      });
+      this.addEventListener("error", (event) => {
+        const code = event?.error?.code;
+        if (typeof code === "string") pending = { errno: code, at: now() };
+      });
+      this.addEventListener("close", (event) => {
+        const error = pending;
+        pending = undefined;
+        emit("conn-end", { conn, local: socket.local ?? null, code: event.code, clean: event.wasClean, errno: error?.errno ?? null });
+        // the end of the socket of the run, as the client saw it: an error, or the end of the file
+        if (conn !== 1 || socket.dropped) return;
+        if (error !== undefined) emit("error", { errno: error.errno, local: socket.local ?? null }, error.at);
+        else emit("eof", { local: socket.local ?? null });
+      });
+    }
+
+    send(...args) {
+      const socket = sockets.get(this);
+      const type = typeOf(args[0]);
+      emit(type === "ping" ? "ping" : "write", { conn: socket?.conn ?? null, local: socket?.local ?? null, ...(type === "ping" ? {} : { type }) });
+      return super.send(...args);
+    }
+
+    close(...args) {
+      dropped(this, "close");
+      return super.close(...args);
+    }
+  }
+  const terminate = Base.prototype.terminate;
+  if (typeof terminate === "function")
+    Stamped.prototype.terminate = function (...args) {
+      dropped(this, "terminate");
+      return terminate.apply(this, args);
+    };
+  return Stamped;
+};
+
+subscribe("undici:websocket:open", (message) => {
+  const address = message.address;
+  opened(sockets.get(message.websocket), address === null || address === undefined ? null : `${address.address}:${address.port}`);
+});
+subscribe("undici:websocket:socket_error", (error) => {
+  pending = { errno: error?.code ?? error?.name ?? "unknown", at: now() };
+});
+
+setTimeout(() => {
+  emit("deadline");
+  process.exit(0);
+}, max);
+
+const { Client, WebSocketTransport } = await import("@procedures/client");
+
+let first;
+const firstOpen = new Promise((resolve) => {
+  first = resolve;
+});
+const transport = new WebSocketTransport({
+  url: `ws://${host}:${port}/ws`,
+  // the global class has no terminate(): the subclass of it has none either
+  webSocket: socketClass === "ws" ? stamped(WsWebSocket) : stamped(globalThis.WebSocket),
+  heartbeat: heartbeat.enabled
+    ? { enabled: true, interval: ms(heartbeat.interval), timeout: ms(heartbeat.timeout), misses: heartbeat.misses }
+    : { enabled: false },
+  reconnect: reconnect.enabled
+    ? {
+        enabled: true,
+        initialDelay: ms(reconnect.initialDelay),
+        backoffMultiplier: reconnect.backoffMultiplier,
+        maxDelay: ms(reconnect.maxDelay),
+        maxAttempts: reconnect.maxAttempts,
+        jitter: reconnect.jitter,
+      }
+    : { enabled: false },
+  requestTimeout: ms(requestTimeout),
+  connectionTimeout: ms(connectionTimeout),
+  onConnect: () => {
+    emit("status", { status: "connected" });
+    first?.();
+    first = undefined;
+  },
+  onDisconnect: (reason) => emit("status", { status: "disconnected", reason: reason ?? null }),
+  onReconnecting: (attempt) => emit("reconnecting", { attempt }),
+  onError: (error) => emit("status", { status: "error", message: error?.message ?? null }),
+});
+const client = new Client({ transport });
+
+const ECHO = { service: "harness", operation: "echo" };
+const HOLD = { service: "harness", operation: "hold" };
+
+await firstOpen;
+try {
+  emit("sent");
+  const reply = await client.call(ECHO, {});
+  emit("ready", { reply: JSON.stringify(reply ?? null) });
+} catch (error) {
+  emit("fail", { why: error?.message ?? String(error) });
+  process.exit(1);
+}
+
+if (mode === "inflight") {
+  await waitFor(go);
+  // into the fault: its reply never comes, or comes after the fault
+  emit("sent");
+  client.call(hold === undefined ? ECHO : HOLD, hold === undefined ? {} : { ms: hold }).then(
+    (reply) => emit("data", { n: JSON.stringify(reply ?? null).length }),
+    (error) => emit("call-error", { code: error?.code ?? error?.name ?? null, message: error?.message ?? String(error) }),
+  );
+}

package/image/procedures/lines.mjs

@@ -0,0 +1,68 @@
+// The JSON lines of the procedures programs of the harness: the WebSocket client and the server.
+//
+// Each line has `ev` and `t`, as the TCP client of the harness writes them. `t` is
+// process.hrtime, which libuv reads from CLOCK_MONOTONIC: the clock that the prober stamps the
+// records of the kernel with. A write to a pipe is synchronous on Linux, thus a line goes out
+// before the program does the act that it announces.
+
+import { existsSync, readFileSync } from "node:fs";
+
+/** This function gives the time now, in nanoseconds on CLOCK_MONOTONIC. */
+export const now = () => process.hrtime.bigint();
+
+/** This function writes one line, with the time `at` (the time now when none is given). */
+export const emit = (ev, fields = {}, at = now()) =>
+  process.stdout.write(`${JSON.stringify({ ev, t: Number(at), ...fields })}\n`);
+
+/** This function gives the boot id of the kernel, or null where the file does not exist. */
+export const bootId = () => {
+  try {
+    return readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * This function reads the command line: positional arguments first, then `--name value` pairs.
+ * A setting that the caller must give and does not is a failure: the program has no default.
+ */
+export const commandLine = (usage, positional = 0) => {
+  const argv = process.argv.slice(2);
+  const flag = (name) => {
+    const at = argv.indexOf(name);
+    return at === -1 ? undefined : argv[at + 1];
+  };
+  const fail = (why) => {
+    emit("fail", { why: `${why}. Usage: ${usage}` });
+    process.exit(1);
+  };
+  const required = (name) => {
+    const value = flag(name);
+    if (value === undefined) fail(`no ${name}`);
+    return value;
+  };
+  const number = (name) => {
+    const value = Number(required(name));
+    if (!Number.isFinite(value)) fail(`${name} is not a number`);
+    return value;
+  };
+  const toggle = (name) => {
+    const value = required(name);
+    if (value !== "on" && value !== "off") fail(`${name} is on or off`);
+    return value === "on";
+  };
+  const args = argv.slice(0, positional);
+  if (args.length < positional || args.some((arg) => arg.startsWith("--"))) fail("the positional arguments are missing");
+  return { args, flag, required, number, toggle, fail };
+};
+
+/** This function waits until the file at `path` exists. It looks each 2 ms, as the other clients of the harness do. */
+export const waitFor = (path) =>
+  new Promise((resolve) => {
+    const look = setInterval(() => {
+      if (!existsSync(path)) return;
+      clearInterval(look);
+      resolve();
+    }, 2);
+  });

package/image/procedures/npm-lock.json

@@ -0,0 +1,125 @@
+{
+  "name": "loom-harness-procedures",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "loom-harness-procedures",
+      "dependencies": {
+        "@procedures/client": "0.3.0",
+        "ws": "8.22.0"
+      }
+    },
+    "node_modules/@mark1russell7/algebra": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/@mark1russell7/algebra/-/algebra-0.5.0.tgz",
+      "integrity": "sha512-rNKCWvZBGDUYtA1BOPftPY7+zG6LWdISWrjkZwsHf3IS4bfz6JCeWVpJ0LV/vEvNRz1OnVjh9WgwoEUn1Y4cCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@mark1russell7/quantity": "^0.2.0"
+      },
+      "engines": {
+        "node": ">=22.19"
+      },
+      "peerDependencies": {
+        "zod": "^4.1.0"
+      }
+    },
+    "node_modules/@mark1russell7/quantity": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@mark1russell7/quantity/-/quantity-0.2.0.tgz",
+      "integrity": "sha512-pE2OganjbhstZgoeLVu5YRVQq6bOnV/5T4GYuJhIu0+PF77+DwpfrIZonhNNfEZHz/P4ioiwFowbIwxPq9VkSA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=22.19"
+      },
+      "peerDependencies": {
+        "zod": "^4.1.0"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mark1russell7/service": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@mark1russell7/service/-/service-0.4.0.tgz",
+      "integrity": "sha512-Zby/XIGWTWax927/pkQgeY9ljlzLmBkUnTlDcpGDKnNpEmXhM0WpnK948hnDqvUd2bwXM3/CcM2cYQDAaTA+2A==",
+      "license": "MIT",
+      "dependencies": {
+        "@mark1russell7/algebra": "^0.5.0",
+        "@mark1russell7/quantity": "^0.2.0"
+      },
+      "engines": {
+        "node": ">=22.19"
+      },
+      "peerDependencies": {
+        "ioredis": "^6.0.0",
+        "zod": "^4.1.0"
+      },
+      "peerDependenciesMeta": {
+        "ioredis": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@procedures/client": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@procedures/client/-/client-0.3.0.tgz",
+      "integrity": "sha512-DzOOZIhv1DH87zv3Je/D4gg+Jou386i69hPkQU5bz8Gs1vRzZoTrBcb0kojNMS4Ex1cwDxXYr0GDxVmlpVuEnA==",
+      "license": "MIT",
+      "dependencies": {
+        "@mark1russell7/algebra": "^0.5.0",
+        "@mark1russell7/quantity": "^0.2.0",
+        "@mark1russell7/service": "^0.4.0",
+        "ws": "^8.18.3",
+        "zod": "^4.6.5"
+      },
+      "bin": {
+        "client-registry": "dist/procedures/cli/index.js"
+      },
+      "engines": {
+        "node": ">=22"
+      },
+      "peerDependencies": {
+        "express": "^4.0.0 || ^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "express": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.22.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.22.0.tgz",
+      "integrity": "sha512-Ydggc987+RO0AnWtZ/7Wq9FtNvcrL1b/RO0ud9mWjUPgDrsAAwQSF51sm2hm1XofbU/4jkpGEsLFsZZxU+1DOg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.6.7",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.7.tgz",
+      "integrity": "sha512-g8W2D2kU6a8untc053fX1uVBKzM7yqAxW/3zwk83+6RyF2+SKOuV+c0wBDhUwzV1PaGapmZH+rmcUzPf+3CGwg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

package/image/procedures/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "loom-harness-procedures",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@procedures/client": "0.3.0",
+    "ws": "8.22.0"
+  }
+}

package/image/procedures/server-ws.mjs

@@ -0,0 +1,94 @@
+// server-ws --port N --tcp-keepalive off|N --heartbeat off|on [--heartbeat-interval-ms N --heartbeat-misses N]
+//
+// A cell's target: the procedures server of @procedures/client 0.3.0 (Server and
+// WebSocketServerTransport) on the http.Server of Node 24.21.0, at the path /ws. It has two
+// procedures: `harness.echo` answers at once, and `harness.hold` answers after `ms` milliseconds
+// (a held reply, as BLPOP is for Redis).
+//
+// --tcp-keepalive is the keepalive of each accepted socket: off, or its idle time in ms. Node's
+// default is off (keepAlive of http.Server), and the cell says it.
+//
+// --heartbeat is the heartbeat of the server (roadmap R3): a WebSocket ping to each connection at
+// each interval, and terminate() for a connection that missed `misses` pongs. Each setting is a
+// flag, and the server has no default. 0.3.0 takes each time as a duration, not a number.
+//
+// Each event is a JSON line on the clock of the clients: a connection (`accepted`), a request,
+// a reply, and the close of a connection. The `ws` package does the WebSocket of the server. Its
+// `ping` and `terminate` write a line first (`ping`, `drop`): the heartbeat of the server pings its
+// clients and drops a silent one. Each line names the connection by its peer.
+
+import http from "node:http";
+import { WebSocket } from "ws";
+import { Server, WebSocketServerTransport } from "@procedures/client";
+import { bootId, commandLine, emit } from "./lines.mjs";
+
+const line = commandLine("server-ws --port N --tcp-keepalive off|N --heartbeat off|on [--heartbeat-interval-ms N --heartbeat-misses N]");
+const port = line.number("--port");
+const keepalive = line.required("--tcp-keepalive");
+const keepAliveMs = keepalive === "off" ? null : Number(keepalive);
+if (keepAliveMs !== null && !Number.isFinite(keepAliveMs)) line.fail("--tcp-keepalive is off or a number of ms");
+const heartbeat = line.toggle("--heartbeat")
+  ? { interval: line.number("--heartbeat-interval-ms"), misses: line.number("--heartbeat-misses") }
+  : null;
+
+const peerOf = (socket) => `${socket?.remoteAddress}:${socket?.remotePort}`;
+
+// the acts of a heartbeat of the server, in the package that the transport imports
+const ping = WebSocket.prototype.ping;
+WebSocket.prototype.ping = function (...args) {
+  emit("ping", { peer: peerOf(this._socket) });
+  return ping.apply(this, args);
+};
+const terminate = WebSocket.prototype.terminate;
+WebSocket.prototype.terminate = function (...args) {
+  emit("drop", { peer: peerOf(this._socket) });
+  return terminate.apply(this, args);
+};
+
+const ok = (request, payload) => ({ id: request.id, status: { type: "success", code: 200 }, payload, metadata: {} });
+const server = new Server();
+server.register({ service: "harness", operation: "echo" }, async (request) => {
+  emit("request", { method: "harness.echo" });
+  return ok(request, { ok: true });
+});
+server.register({ service: "harness", operation: "hold" }, async (request) => {
+  const ms = Number(request.payload?.ms ?? 0);
+  emit("request", { method: "harness.hold", ms });
+  await new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    request.signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+  emit("replied", { method: "harness.hold", aborted: request.signal?.aborted === true });
+  return ok(request, { ok: true, held: ms });
+});
+
+const httpServer = http.createServer({
+  keepAlive: keepAliveMs !== null,
+  ...(keepAliveMs === null ? {} : { keepAliveInitialDelay: keepAliveMs }),
+});
+const transport = new WebSocketServerTransport(server, {
+  server: httpServer,
+  path: "/ws",
+  heartbeat: heartbeat === null ? false : { interval: { value: heartbeat.interval, unit: "ms" }, misses: heartbeat.misses },
+  onConnection: (ws, request) => {
+    const peer = peerOf(request.socket);
+    emit("accepted", { peer });
+    ws.on("close", (code) => emit("closed", { peer, code }));
+  },
+});
+server.addTransport(transport);
+await server.start();
+
+httpServer.listen(port, "0.0.0.0", () =>
+  emit("listening", {
+    port,
+    boot_id: bootId(),
+    node: process.version,
+    package: "@procedures/client 0.3.0",
+    tcpKeepalive: keepAliveMs,
+    heartbeat,
+  }),
+);

package/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.7.0",
-  "description": "A fault-injection harness for connection timers: a cell runs a client against a stock target in Docker, through a topology of routers and proxies, a replicated group under Sentinels or a replica set, injects a fault, measures the kernel's own records and judges a prediction. HTTP clients of Go, Node and undici race the keep-alive of a Node server, and the MongoDB driver meets the faults of a replica set.",
+  "version": "0.8.0",
+  "description": "A fault-injection harness for connection timers: a cell runs a client against a stock target in Docker, through a topology of routers and proxies, a replicated group under Sentinels or a replica set, injects a fault, measures the kernel's own records and judges a prediction. HTTP clients of Go, Node and undici race the keep-alive of a Node server, and the MongoDB driver meets the faults of a replica set. The WebSocket client of @procedures/client drops a silent connection on its own heartbeat, and the harness times that detection and the reconnect from the program's lines and the kernel's stamps.",
   "keywords": [
     "fault-injection",
     "chaos-engineering",
@@ -61,6 +61,12 @@
     "image/mongo/stepdown-mongo.mjs",
     "image/mongo/package.json",
     "image/mongo/npm-lock.json",
+    "image/procedures/Dockerfile",
+    "image/procedures/package.json",
+    "image/procedures/npm-lock.json",
+    "image/procedures/lines.mjs",
+    "image/procedures/client-ws.mjs",
+    "image/procedures/server-ws.mjs",
     "image/router/Dockerfile",
     "image/router/mbx.sh",
     "image/router/ctwatch.py",