@mark1russell7/harness 0.11.1 → 0.11.3

package/build/schema.d.ts

@@ -0,0 +1,19 @@
+import { J as Subject, _ as ImageSource, i as ClientImage, r as Client } from "./cell-BmSnJJtn.js";
+import { z } from "zod";
+//#region src/schema.d.ts
+/**
+ * This schema accepts the source of an image (`ImageSource`). It is a pinned image with its digest,
+ * a build context whose paths stay in it, or an image that the harness ships.
+ */
+export declare const imageSourceSchema: z.ZodType<ImageSource>;
+/** This schema accepts a client image (`ClientImage`): a stock image by its name or the source of an image, and its command. */
+export declare const clientImageSchema: z.ZodType<ClientImage>;
+/** This schema accepts the client of a cell (`Cell.client`): a client that the harness ships by its name, or a client image. */
+export declare const clientSchema: z.ZodType<Client | ClientImage>;
+/**
+ * This schema accepts a subject (`Subject`): its name, the source of its image and its stock base.
+ * It also accepts the command of each of its programs.
+ */
+export declare const subjectSchema: z.ZodType<Subject>;
+//#endregion
+//# sourceMappingURL=schema.d.ts.map

package/build/schema.js

@@ -0,0 +1,56 @@
+import { a as SHIPPED_NAMES, t as CLIENT_NAMES, u as imageProblems, x as subjectProblems } from "./image-Q_fs3rCC.js";
+import { z } from "zod";
+//#region src/schema.ts
+/** This function adds each problem that a check finds as an issue of a schema. */
+const issues = (check) => (value, ctx) => {
+	for (const message of check(value)) ctx.addIssue({
+		code: "custom",
+		message
+	});
+};
+/** This schema accepts a command: argv of one text or more. */
+const command = z.array(z.string().min(1)).min(1);
+/** This schema accepts the shape of each kind of image source. The checks of its values come after it. */
+const sourceShape = z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("pinned"),
+		image: z.string()
+	}),
+	z.strictObject({
+		kind: z.literal("build"),
+		name: z.string(),
+		context: z.string(),
+		dockerfile: z.string().optional(),
+		files: z.array(z.string()).optional()
+	}),
+	z.strictObject({
+		kind: z.literal("shipped"),
+		name: z.enum(SHIPPED_NAMES)
+	})
+]);
+/**
+* This schema accepts the source of an image (`ImageSource`). It is a pinned image with its digest,
+* a build context whose paths stay in it, or an image that the harness ships.
+*/
+const imageSourceSchema = sourceShape.superRefine(issues(imageProblems));
+/** This schema accepts a client image (`ClientImage`): a stock image by its name or the source of an image, and its command. */
+const clientImageSchema = z.strictObject({
+	image: z.union([z.string().min(1), imageSourceSchema]),
+	command
+});
+/** This schema accepts the client of a cell (`Cell.client`): a client that the harness ships by its name, or a client image. */
+const clientSchema = z.union([z.enum(CLIENT_NAMES), clientImageSchema]);
+/**
+* This schema accepts a subject (`Subject`): its name, the source of its image and its stock base.
+* It also accepts the command of each of its programs.
+*/
+const subjectSchema = z.strictObject({
+	name: z.string().min(1),
+	image: sourceShape,
+	base: z.string(),
+	programs: z.record(z.string(), command)
+}).superRefine(issues(subjectProblems));
+//#endregion
+export { clientImageSchema, clientSchema, imageSourceSchema, subjectSchema };
+
+//# sourceMappingURL=schema.js.map

package/build/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","names":[],"sources":["../src/schema.ts"],"sourcesContent":["// The entry \"@mark1russell7/harness/schema\": the zod schemas of the data that a caller gives the\n// harness as JSON. These are the source of an image, a client and a subject. The root entry of\n// the package does not import zod.\nimport { z } from \"zod\";\nimport type { Client, ClientImage, ImageSource, Subject } from \"./cell.ts\";\nimport { CLIENT_NAMES, SHIPPED_NAMES, imageProblems, subjectProblems } from \"./image.ts\";\n\n/** This function adds each problem that a check finds as an issue of a schema. */\nconst issues =\n  <T>(check: (value: T) => string[]) =>\n  (value: T, ctx: z.RefinementCtx): void => {\n    for (const message of check(value)) ctx.addIssue({ code: \"custom\", message });\n  };\n\n/** This schema accepts a command: argv of one text or more. */\nconst command = z.array(z.string().min(1)).min(1);\n\n/** This schema accepts the shape of each kind of image source. The checks of its values come after it. */\nconst sourceShape = z.discriminatedUnion(\"kind\", [\n  z.strictObject({ kind: z.literal(\"pinned\"), image: z.string() }),\n  z.strictObject({\n    kind: z.literal(\"build\"),\n    name: z.string(),\n    context: z.string(),\n    dockerfile: z.string().optional(),\n    files: z.array(z.string()).optional(),\n  }),\n  z.strictObject({ kind: z.literal(\"shipped\"), name: z.enum(SHIPPED_NAMES) }),\n]);\n\n/**\n * This schema accepts the source of an image (`ImageSource`). It is a pinned image with its digest,\n * a build context whose paths stay in it, or an image that the harness ships.\n */\nexport const imageSourceSchema: z.ZodType<ImageSource> = sourceShape.superRefine(issues(imageProblems));\n\n/** This schema accepts a client image (`ClientImage`): a stock image by its name or the source of an image, and its command. */\nexport const clientImageSchema: z.ZodType<ClientImage> = z.strictObject({\n  image: z.union([z.string().min(1), imageSourceSchema]),\n  command,\n});\n\n/** This schema accepts the client of a cell (`Cell.client`): a client that the harness ships by its name, or a client image. */\nexport const clientSchema: z.ZodType<Client | ClientImage> = z.union([z.enum(CLIENT_NAMES), clientImageSchema]);\n\n/**\n * This schema accepts a subject (`Subject`): its name, the source of its image and its stock base.\n * It also accepts the command of each of its programs.\n */\nexport const subjectSchema: z.ZodType<Subject> = z\n  .strictObject({\n    name: z.string().min(1),\n    image: sourceShape,\n    base: z.string(),\n    programs: z.record(z.string(), command),\n  })\n  .superRefine(issues(subjectProblems));\n"],"mappings":";;;;AAQA,MAAM,UACA,WACH,OAAU,QAA+B;CACxC,KAAK,MAAM,WAAW,MAAM,KAAK,GAAG,IAAI,SAAS;EAAE,MAAM;EAAU;CAAQ,CAAC;AAC9E;;AAGF,MAAM,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;;AAGhD,MAAM,cAAc,EAAE,mBAAmB,QAAQ;CAC/C,EAAE,aAAa;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAG,OAAO,EAAE,OAAO;CAAE,CAAC;CAC/D,EAAE,aAAa;EACb,MAAM,EAAE,QAAQ,OAAO;EACvB,MAAM,EAAE,OAAO;EACf,SAAS,EAAE,OAAO;EAClB,YAAY,EAAE,OAAO,CAAC,CAAC,SAAS;EAChC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS;CACtC,CAAC;CACD,EAAE,aAAa;EAAE,MAAM,EAAE,QAAQ,SAAS;EAAG,MAAM,EAAE,KAAK,aAAa;CAAE,CAAC;AAC5E,CAAC;;;;;AAMD,MAAa,oBAA4C,YAAY,YAAY,OAAO,aAAa,CAAC;;AAGtG,MAAa,oBAA4C,EAAE,aAAa;CACtE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC;CACrD;AACF,CAAC;;AAGD,MAAa,eAAgD,EAAE,MAAM,CAAC,EAAE,KAAK,YAAY,GAAG,iBAAiB,CAAC;;;;;AAM9G,MAAa,gBAAoC,EAC9C,aAAa;CACZ,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACtB,OAAO;CACP,MAAM,EAAE,OAAO;CACf,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;AACxC,CAAC,CAAC,CACD,YAAY,OAAO,eAAe,CAAC"}

package/image/pg/Dockerfile

@@ -0,0 +1,11 @@
+# The harness's PostgreSQL client: node-postgres (pg 8.23.1 with pg-pool 3.14.0) on Node 24.21.0. It
+# runs as a container in the client's network namespace, as the harness's own TCP client does, and
+# prints the same JSON lines, with the events of the pool beside them.
+# lab.ts stages the build context: this folder, under harness/image/pg. 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/pg
+COPY harness/image/pg/package.json ./
+COPY harness/image/pg/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/pg/client-pg.mjs ./

package/image/pg/client-pg.mjs

@@ -0,0 +1,166 @@
+// client-pg HOST PORT --mode idle|inflight|stream [--interval-ms N] [--max-s N] [--go PATH]
+//           [--query TEXT] [--before] [--options JSON]
+//
+// The client of a PostgreSQL cell: node-postgres (pg 8.23.1 with pg-pool 3.14.0) on Node 24.21.0.
+// Each event is a JSON line with `ev` and `t`, the time on CLOCK_MONOTONIC in nanoseconds
+// (process.hrtime, which libuv reads from it). The prober stamps the records of the kernel on the
+// same clock, and the injector stamps each fault on it.
+//
+// The lines:
+// - start: the versions of pg, pg-pool and Node, the mode and the options of the pool.
+// - connecting: the first query, which makes the first connection of the pool. Its stamp is the
+//   stamp of the first sent line. The pool arms its connect timer in that call.
+// - socket, socket-end, socket-error: each socket of the pool, with its local address.
+// - connected: the first socket. The TCP client of the harness names its own socket so.
+// - pool: each event of the pool: connect, acquire, release, remove, and error with its errno.
+// - ready: the reply to the first query: the connection is idle in the pool (idle, inflight), or
+//   the stream starts (stream).
+// - sent, ack, fail: each query by its sequence number, with its error.
+// - data, error: the end of the query in flight, as the TCP client of the harness tells it. In idle
+//   mode, an error of the pool for the first socket is an error line too: the pool removes it.
+// - done, deadline: the end of the client.
+//
+// The modes: idle sends one query, gives the client back to the pool, then holds until --max-s.
+// inflight sends one query, waits for the file --go, sends one more query into the fault, and holds
+// after its end. stream sends a query each --interval-ms after the reply before, until --max-s or
+// SIGTERM. --before starts the client into a fault that holds already: its first connect meets it.
+
+import { readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
+
+const now = () => process.hrtime.bigint();
+const emit = (ev, fields = {}, at = now()) => process.stdout.write(`${JSON.stringify({ ev, t: Number(at), ...fields })}\n`);
+
+const argv = process.argv.slice(2);
+const flag = (name) => {
+  const at = argv.indexOf(name);
+  return at === -1 ? undefined : argv[at + 1];
+};
+const [host, port] = argv;
+const mode = flag("--mode");
+if (host === undefined || port === undefined || !["idle", "inflight", "stream"].includes(mode)) {
+  emit("fail", { why: "client-pg HOST PORT --mode idle|inflight|stream" });
+  process.exit(1);
+}
+const interval = Number(flag("--interval-ms") ?? 50);
+const max = Number(flag("--max-s") ?? 120) * 1000;
+const go = flag("--go") ?? "/tmp/go";
+const query = flag("--query") ?? "SELECT 1";
+const before = argv.includes("--before");
+// the options of the pool. A cell gives each option that it changes, and pg-pool gives the others
+const options = JSON.parse(flag("--options") ?? "{}");
+
+const { default: pg } = await import("pg");
+const versionOf = (name) => JSON.parse(readFileSync(new URL(`./node_modules/${name}/package.json`, import.meta.url), "utf8")).version;
+
+const bootId = () => {
+  try {
+    return readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+  } catch {
+    return null;
+  }
+};
+emit("start", { boot_id: bootId(), client: "pg", driver: versionOf("pg"), pool: versionOf("pg-pool"), node: process.versions.node, mode, query, options });
+
+const pool = new pg.Pool({ host, port: Number(port), user: "postgres", database: "postgres", ...options });
+
+/** This function gives the error of pg as data: its name, its code, its severity and its message. */
+const failure = (error) =>
+  error === undefined || error === null
+    ? null
+    : { name: error.name, code: error.code ?? null, errno: error.errno ?? null, severity: error.severity ?? null, message: error.message };
+/** This function gives the errno of an error: the code of the socket (ECONNRESET), the SQLSTATE of the server, or the message of pg. */
+const errnoOf = (error) => error?.code ?? error?.message ?? null;
+
+// ---- each socket of the pool: pg-pool emits connect after the first ReadyForQuery of a new client
+let connected = null;
+const localOf = (client) => {
+  const socket = client?.connection?.stream;
+  return socket?.localPort === undefined ? null : `${socket.localAddress}:${socket.localPort}`;
+};
+pool.on("connect", (client) => {
+  const socket = client.connection.stream;
+  const local = localOf(client);
+  emit("socket", { role: "pool", local });
+  emit("pool", { event: "connect", local });
+  if (connected === null && local !== null) {
+    connected = local;
+    emit("connected", { local });
+  }
+  socket.once("close", (hadError) => emit("socket-end", { role: "pool", local, error: hadError }));
+  socket.once("error", (error) => emit("socket-error", { role: "pool", local, errno: errnoOf(error), message: error.message }));
+});
+pool.on("acquire", (client) => emit("pool", { event: "acquire", local: localOf(client) }));
+pool.on("release", (error, client) => emit("pool", { event: "release", local: localOf(client), failure: failure(error) }));
+// the pool removes a client: after its idle timer, its lifetime or an error. A driver band names the close CLOSED
+pool.on("remove", (client) => emit("pool", { event: "remove", name: "CLOSED", local: localOf(client) }));
+// an idle client that fails: the pool removes it and emits error. Without this listener, Node throws
+pool.on("error", (error, client) => {
+  const local = localOf(client);
+  emit("pool", { event: "error", local, failure: failure(error) });
+  // the socket of the client in idle mode: its error is the detection, as for the TCP client
+  if (mode === "idle" && local !== null && local === connected) emit("error", { errno: errnoOf(error) });
+});
+
+// ---- the end of the client
+let stopped = false;
+const stop = (code = 0) => {
+  if (stopped) return;
+  stopped = true;
+  emit("done");
+  pool.end().finally(() => setTimeout(() => process.exit(code), 50));
+};
+process.on("SIGTERM", () => stop(0));
+setTimeout(() => {
+  emit("deadline");
+  stop(0);
+}, max);
+
+/** This function sends query n through the pool. Its stamp is before the call. It gives null for a reply, or the error. */
+const operate = async (n) => {
+  const at = now();
+  const reply = pool.query(query);
+  // a band of a cell that starts into a fault counts from the start of the first connect
+  if (n === 1) emit("connecting", { at: `${host}:${port}` }, at);
+  emit("sent", { n }, at);
+  try {
+    const result = await reply;
+    emit("ack", { n, rows: result.rowCount ?? null });
+    return null;
+  } catch (error) {
+    emit("fail", { n, ...failure(error) });
+    return error;
+  }
+};
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+if (mode === "stream") {
+  emit("ready", { at: `${host}:${port}` });
+  for (let n = 1; !stopped; n += 1) {
+    await operate(n);
+    await sleep(interval);
+  }
+} else {
+  // the first query makes the connection of the pool. Its reply is the last data before the fault
+  const failed = await operate(1);
+  if (failed !== null) {
+    emit("error", { errno: errnoOf(failed), message: failed.message });
+    stop(before ? 0 : 1);
+  } else {
+    // pool.query gives the client back to the pool at its reply: the connection is idle there
+    emit("ready", { reply: "ack" });
+    if (mode === "inflight") {
+      await new Promise((resolve) => {
+        const wait = setInterval(() => {
+          if (!existsSync(go)) return;
+          clearInterval(wait);
+          resolve();
+        }, 2);
+      });
+      const error = await operate(2);
+      if (error === null) emit("data", { n: 2 });
+      else emit("error", { errno: errnoOf(error), message: error.message });
+    }
+  }
+}

package/image/pg/npm-lock.json

@@ -0,0 +1,160 @@
+{
+  "name": "loom-harness-pg-client",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "loom-harness-pg-client",
+      "dependencies": {
+        "pg": "8.23.1",
+        "pg-pool": "3.14.0"
+      }
+    },
+    "node_modules/pg": {
+      "version": "8.23.1",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.23.1.tgz",
+      "integrity": "sha512-aL96AHANtWjPLDOLqnhx+ngp9+UK7ETEU8VJrDCGvsSSi/mGLcWYsS6Herg7lmaBJe4uwrfqsa7gTEFaSizDoQ==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-connection-string": "^2.14.1",
+        "pg-pool": "^3.14.0",
+        "pg-protocol": "^1.16.1",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 16.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.4.1"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.4.1.tgz",
+      "integrity": "sha512-6PQbsFWZcp9EmJEwy5cGQ2La+AMWpP46lgbb8X+U/XsHIUweYDNCpeuKck5RxL2MdVFi7krbbEi5nX4Zh7JhrQ==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.14.1",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.14.1.tgz",
+      "integrity": "sha512-qR3kGNPBLpCNtz0evbKA0Y/MRFXwSSdT+pTJvYp/bXTcReZbvX1kzF0IyTc1QnxqF7AZbOeBhNL8R5mYQZV/MA==",
+      "license": "MIT"
+    },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.14.0.tgz",
+      "integrity": "sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.16.1",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.16.1.tgz",
+      "integrity": "sha512-p9VOFMiHB/ZbJATetbg+99PxssTVSQRnyuPSQ67mN1+1KBOjZaZ83ZQzltnxPhJwSsC3nwVjJ10DVJlerbFzLg==",
+      "license": "MIT"
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
+    "node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz",
+      "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    }
+  }
+}

package/image/pg/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "loom-harness-pg-client",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "pg": "8.23.1",
+    "pg-pool": "3.14.0"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/harness",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "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",
@@ -33,6 +33,10 @@
       "types": "./build/index.d.ts",
       "default": "./build/index.js"
     },
+    "./schema": {
+      "types": "./build/schema.d.ts",
+      "default": "./build/schema.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -61,6 +65,10 @@
     "image/mongo/stepdown-mongo.mjs",
     "image/mongo/package.json",
     "image/mongo/npm-lock.json",
+    "image/pg/Dockerfile",
+    "image/pg/client-pg.mjs",
+    "image/pg/package.json",
+    "image/pg/npm-lock.json",
     "image/procedures/Dockerfile",
     "image/procedures/package.json",
     "image/procedures/npm-lock.json",