@raresportan/marram 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raresportan/marram",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "The gate, ratchet lints and journeys that keep agent-written code from drifting.",
   "license": "MIT",
   "type": "module",

package/src/core/config.mjs

@@ -4,6 +4,7 @@
 //     gate: {
 //       logs: "where each run's logs go",
 //       progress: /lines from a stage worth showing as it runs/,   // besides ✓ and ✗ lines
+//       sleepGapMs: 30000,   // how long a pause counts as the machine sleeping, so a stage that failed runs again
 //       tiers: { fast: [stage, …], default: [stage, …], full: [stage, …] },  // stage: { name, run: [command, …args], env? }
 //     },
 //     review: { classes: "the mistake-classes doc", rungs: ["type", "lint", …] },

package/src/core/gate.mjs

@@ -5,10 +5,12 @@
 //   full      The default gate and more (a build, the slow journeys). Before merging UI work, or nightly.
 // What each tier runs is the project's: `gate.tiers` in marram.config.mjs. Stages run in order and the first failure
 // stops the gate. Each stage's output is kept in its own log under `gate.logs`/gate-<tier>-<time>/, with report.json.
+// A stage that fails after the machine slept during it runs again: timeouts ran out and frames stopped while it slept,
+// so that failure says nothing about the code. A pause counts as sleep past `gate.sleepGapMs`, 30 seconds by default.
 // The default and full gates record their verdict for the working tree (gate-state.mjs), which the hooks reuse.
 import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { treeOf, updateState } from "./gate-state.mjs";
 
@@ -19,7 +21,7 @@ export async function gate(root, config, [tier = "default"]) {
 		console.error(`Unknown gate "${tier}". Usage: marram gate [fast | full]`);
 		process.exit(1);
 	}
-	const { logs, progress, tiers } = config.gate;
+	const { logs, progress, tiers, sleepGapMs = 30_000 } = config.gate;
 	const dir = join(root, logs, `gate-${tier}-${new Date().toISOString().replace(/[:.]/g, "-")}`);
 	await mkdir(dir, { recursive: true });
 	const report = { tier, startedAt: new Date().toISOString(), stages: [], passed: false };
@@ -50,16 +52,26 @@ export async function gate(root, config, [tier = "default"]) {
 		child.stdout.on("data", (chunk) => {
 			for (const line of chunk.toString().split("\n")) if (/^\s*[✓✗]/.test(line) || progress?.test(line)) console.log(`  ${name}: ${line.trim()}`);
 		});
+		let last = Date.now();
+		let slept = 0;
+		const noticeSleep = () => {
+			const gap = Date.now() - last;
+			last += gap;
+			if (gap > sleepGapMs) slept += gap;
+		};
+		const clock = setInterval(noticeSleep, 1000);
 		const code = await new Promise((done) => {
 			child.on("error", () => done(1));
 			child.on("exit", (exit) => done(exit ?? 1));
 		});
+		clearInterval(clock);
+		noticeSleep();
 		log.end();
 		const seconds = Math.round((Date.now() - started) / 1000);
 		report.stages.push({ name, code, seconds });
 		await writeFile(join(dir, "report.json"), JSON.stringify(report, null, 2));
 		console.log(`${code === 0 ? "✓" : "✗"} ${name} (${seconds}s)${code === 0 ? "" : `: see ${join(dir, `${name}.log`)}`}`);
-		return code === 0;
+		return { passed: code === 0, slept };
 	}
 
 	// A fast pass doesn't make a change done, so only the default and full gates record a verdict.
@@ -70,7 +82,12 @@ export async function gate(root, config, [tier = "default"]) {
 
 	console.log(`Gate (${tier}). Logs: ${dir}`);
 	for (const stage of tiers[tier]) {
-		const passed = await runStage(stage);
+		let { passed, slept } = await runStage(stage);
+		while (!passed && slept > 0 && !interrupted) {
+			console.log(`  The machine slept for ${Math.round(slept / 1000)}s during ${stage.name}, so its failure says nothing about the code. Running it again.`);
+			await rename(join(dir, `${stage.name}.log`), join(dir, `${stage.name}-slept.log`));
+			({ passed, slept } = await runStage(stage));
+		}
 		if (interrupted) {
 			console.log(`\nGate interrupted at ${stage.name}.`);
 			process.exit(1);

package/src/react/keyed.ts

@@ -1,19 +1,25 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useReducer } from "react";
+
+type Value<T> = T | ((previous: T) => T);
 
 /**
  * State that belongs to a key (a watch's parameters, a file, a document): under another key it reads as `initial`, so
  * nothing shows the last key's value while the new key's loads, not even for the one render an effect resetting it
  * would leave. Set it with the key the value is for, or with an update of that key's value; a late answer for a key
- * that's gone reads as `initial` too.
+ * that's gone is dropped, so it can't take the place of the current key's value. A key says only what a value is for:
+ * two requests under one key can still answer out of order, so a caller that re-reads puts a version or try in the key.
  */
-export function useKeyed<T>(key: string, initial: T): [T, (forKey: string, value: T | ((previous: T) => T)) => void] {
-	const [held, setHeld] = useState<{ key: string; value: T }>({ key, value: initial });
-	const first = useRef(initial);
-	const set = useCallback((forKey: string, value: T | ((previous: T) => T)) => {
-		setHeld((last) => {
-			const previous = last.key === forKey ? last.value : first.current;
-			return { key: forKey, value: typeof value === "function" ? (value as (previous: T) => T)(previous) : value };
-		});
-	}, []);
+export function useKeyed<T>(key: string, initial: T): [T, (forKey: string, value: Value<T>) => void] {
+	// Written inline because React runs a reducer in the render an update lands in: this one sees that render's key, which
+	// `set`, called from a promise or a listener, can't know.
+	const [held, apply] = useReducer(
+		(last: { key: string; value: T }, { forKey, value }: { forKey: string; value: Value<T> }) => {
+			if (forKey !== key) return last;
+			const previous = last.key === key ? last.value : initial;
+			return { key, value: typeof value === "function" ? (value as (previous: T) => T)(previous) : value };
+		},
+		{ key, value: initial },
+	);
+	const set = useCallback((forKey: string, value: Value<T>) => apply({ forKey, value }), []);
 	return [held.key === key ? held.value : initial, set];
 }