@gigzen/populace 1.1.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gigzen/populace",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "A simulated population that uses your app through its real API, so you can test what needs more than one person.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -264,9 +264,24 @@ async function run() {
 
   console.log(`\n  Bringing ${agents} people to life across ${cities.join(", ")}…\n`);
 
+  // Sign-ups are counted here rather than in the engine, so the engine keeps
+  // knowing nothing about who is watching.
+  let joinedSoFar = 0;
   const world = World.fromConfig(config, adapter, {
-    joined: (a) => console.log(`   ✓ ${a.persona.name} (${a.persona.city.name}, ${a.persona.platform})`),
-    joinFailed: (p, e) => console.log(`   ✖ ${p.name}: ${e.message}`),
+    joined: (a) => {
+      console.log(`   ✓ ${a.persona.name} (${a.persona.city.name}, ${a.persona.platform})`);
+      progress.joining({
+        done: ++joinedSoFar, total: agents, ok: true,
+        name: a.persona.name, city: a.persona.city.name,
+      });
+    },
+    joinFailed: (p, e) => {
+      console.log(`   ✖ ${p.name}: ${e.message}`);
+      progress.joining({
+        done: ++joinedSoFar, total: agents, ok: false,
+        name: p.name, city: p.city?.name,
+      });
+    },
     // Said out loud, because waiting silently is indistinguishable from hanging.
     // Retrying a throttled sign-up can add seconds per person, and a run that
     // pauses without explanation is a run somebody kills.
@@ -286,10 +301,43 @@ async function run() {
     },
   });
 
-  process.on("SIGINT", () => {
+  const askedToStop = () => {
+    if (world.stopping) return;
     world.stop();
     console.log(`\n  Stopping…\n`);
-  });
+  };
+
+  process.on("SIGINT", askedToStop);
+
+  /*
+   * A second way to ask, because the first one does not exist on Windows.
+   *
+   * `child.kill("SIGTERM")` there does not deliver a signal - Windows has no
+   * POSIX signals, so Node terminates the process outright whatever name is
+   * passed. A parent asking politely therefore killed the run mid-flight and
+   * stranded every account it had created, which is the one promise this tool
+   * makes loudest. Measured on 2026-08-26: pressing Stop during a 200-person
+   * run left all 200 behind.
+   *
+   * stdin works the same on every platform. A line containing "stop" asks for
+   * the same orderly wind-down SIGINT does: finish the tick, tear down, delete
+   * the accounts, write the report.
+   *
+   * unref() so simply having this listener never keeps the process alive, and
+   * resume() because a paused stdin emits nothing.
+   */
+  if (!process.stdin.isTTY) {
+    let pending = "";
+    process.stdin.on("data", (chunk) => {
+      pending += String(chunk);
+      const lines = pending.split("\n");
+      pending = lines.pop() ?? "";
+      if (lines.some((l) => l.trim() === "stop")) askedToStop();
+    });
+    process.stdin.on("error", () => {});   // a closed pipe is not a reason to fail a run
+    process.stdin.resume();
+    process.stdin.unref();
+  }
 
   await world.populate();
   if (!world.agents.length) {

package/src/progress.mjs

@@ -71,7 +71,7 @@ function latencies(metrics) {
  * @param {(line: string) => void} options.write
  */
 export function createProgress({ enabled, everyLatency = 5, write = (l) => process.stdout.write(l) } = {}) {
-  if (!enabled) return { start() {}, tick() {}, done() {} };
+  if (!enabled) return { start() {}, joining() {}, tick() {}, done() {} };
 
   const emit = (event) => {
     try {
@@ -97,6 +97,18 @@ export function createProgress({ enabled, everyLatency = 5, write = (l) => proce
       });
     },
 
+    /**
+     * One event per person as they sign in, before any tick exists.
+     *
+     * Signing 250 people in takes minutes, and until this existed a watcher had
+     * nothing to show for it: every counter read zero, the progress bar stayed
+     * empty and the clock counted down as though the run were already under way.
+     * A window that looks identical to a hung one is a window people kill.
+     */
+    joining({ done, total, name, city, ok }) {
+      emit({ type: "joining", done, total, name, city, ok });
+    },
+
     tick(tickNo, totalTicks, world, metrics) {
       const t = world.totals();
       emit({