cursedops 0.22.0 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedops",
-	"version": "0.22.0",
+	"version": "0.22.1",
 	"description": "The build-and-ops answers this generation's apps wrote independently and identically: finding a generation's roots — and printing a command that runs when pasted — without knowing a path, the generation's whole-tree laws run over one repo from a checkout or a worktree, macOS launchd agent install/replace/remove and the live port a job serves, the check that a launchd job imports only what the LOCKED versions of its packages export (a lib-preview overlay's extra subpath or name is a job that dies at the next forced reinstall), the scaffolding and verdicts of a deployed smoke (origin probe, the smoke's own environment, a network that lies about DNS, a settled version), the static-serving helpers eight apps copied — the path-traversal guard among them — the API floor that keeps an unmatched /api/... from ever being answered with the app shell, the commit and dirty flag a checkout-served process reports, the Cloudflare Worker deploy toolkit four apps copied (the deploy sequence, exact-set secrets over a pipe, origin-first rollback, the curl edge fetch, the row-for-row D1 import proof, the billed-CPU tail check around a deploy's walk and smoke, and each app's worker:secrets and worker:smoke main as one function of its data), the relay a Worker fronts a Mac-bound app with (the Durable Object, the frames, the Mac's dialer and key rotation — lifted from station for roms — and the signed-in stage walk's skeleton and the relay app's whole worker:deploy), the Worker import-graph and await-port checks every Worker app's suite runs over its own source, and the public-surface ratchet three published libraries each carried a forked copy of. Mechanism only — no app knows its name from here. Bun, zero runtime dependencies (typescript is an optional peer, for public-surface only), ships source.",
 	"type": "module",
 	"scripts": {

package/src/stageLook.ts

@@ -86,6 +86,70 @@ export function brokenMediaOf(r: LookResponse): string | null {
 	return null;
 }
 
+/**
+ * A read of the page's OWN that the stage failed — a same-origin `/api/` answer of 5xx — as
+ * `<status> <path>`. A look shot over one is a picture of an error card or a skeleton, not of the
+ * change (forge task 3914: station's `#/deploys` read 503 "station's Mac is not connected", because a
+ * relay stage has a Mac end only while its `worker:stage-walk` runs).
+ */
+export function failedReadOf(r: Pick<LookResponse, "url" | "status">, origin: string): string | null {
+	const url = new URL(r.url());
+	if (url.origin !== origin || !url.pathname.startsWith("/api/") || r.status() < 500) return null;
+	return `${r.status()} ${url.pathname}`;
+}
+
+/** How long the network may stay busy before the look goes on without it — a player streams for good. */
+export const IDLE_CEILING_MS = 15_000;
+/** How long a page's pending regions (`aria-busy="true"`, cursedbelt's skeletons) may read before the look gives up. */
+export const SETTLE_CEILING_MS = 90_000;
+
+/** The slice of a playwright `Page` that {@link settle} drives. */
+export interface SettlePage {
+	waitForLoadState(state: "networkidle", options: { timeout: number }): Promise<unknown>;
+	evaluate<T>(fn: () => T): Promise<T>;
+}
+
+export interface Settled {
+	/** False when the network never went quiet inside {@link IDLE_CEILING_MS} — said, never fatal. */
+	idle: boolean;
+	/** The pending regions still reading at the ceiling, by their text; empty when the page settled. */
+	busy: string[];
+	ms: number;
+}
+
+/**
+ * Wait until the page has DRAWN, not until the network is quiet: both of the looks that went wrong
+ * waited for `networkidle` alone. music's never came (its player keeps a stream open), so the look threw;
+ * station's `#/deploys` came while its read was still in flight, so the look shot four skeleton tiles
+ * and "Reading the apps' deploys…" (forge task 3914). So: `networkidle` with a ceiling, then every
+ * `aria-busy="true"` region gone on two reads in a row, up to {@link SETTLE_CEILING_MS} — and what is
+ * still busy then is SAID, so a look of a loading state never reads as a look of the page.
+ */
+export async function settle(
+	page: SettlePage,
+	options: { idleMs?: number; settleMs?: number; pollMs?: number; sleep?: (ms: number) => Promise<unknown>; now?: () => number } = {},
+): Promise<Settled> {
+	const { idleMs = IDLE_CEILING_MS, settleMs = SETTLE_CEILING_MS, pollMs = 500, sleep = Bun.sleep, now = Date.now } = options;
+	const start = now();
+	const idle = await page.waitForLoadState("networkidle", { timeout: idleMs }).then(
+		() => true,
+		() => false,
+	);
+	const pending = () =>
+		page.evaluate(() =>
+			[...document.querySelectorAll('[aria-busy="true"]')].map((el) => (el.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 80) || el.tagName.toLowerCase()),
+		);
+	let quiet = 0;
+	let busy: string[] = [];
+	while (true) {
+		busy = await pending();
+		quiet = busy.length === 0 ? quiet + 1 : 0;
+		if (quiet >= 2) return { idle, busy: [], ms: now() - start };
+		if (now() - start >= settleMs) return { idle, busy, ms: now() - start };
+		await sleep(pollMs);
+	}
+}
+
 /** The slices of playwright this drives. Structural, so cursedops needs no dependency on it. */
 interface LookRoute {
 	request(): { headers(): Record<string, string> };
@@ -188,14 +252,32 @@ async function main(argv: string[]): Promise<number> {
 	mkdirSync(dir, { recursive: true });
 	let bad = false;
 	for (const width of [390, 1440]) {
-		type ShotPage = LookPage & { screenshot(o: { path: string; fullPage?: boolean }): Promise<unknown>; url(): string };
+		type ShotPage = LookPage & SettlePage & { screenshot(o: { path: string; fullPage?: boolean }): Promise<unknown>; url(): string };
 		const look = await openStagePage<ShotPage>({ app, width });
 		try {
-			const res = await look.page.goto(`${look.origin}${path}`, { waitUntil: "networkidle" });
+			const failed: string[] = [];
+			look.page.on("response", (r) => {
+				const f = failedReadOf(r, look.origin);
+				if (f && !failed.includes(f)) failed.push(f);
+			});
+			const res = await look.page.goto(`${look.origin}${path}`, { waitUntil: "load" });
+			const settled = await settle(look.page);
 			const shot = join(dir, `stage-${app}-${width}.png`);
 			await look.page.screenshot({ path: shot });
-			console.log(`${width}: ${res?.status() ?? "?"} ${look.page.url()} → ${shot}`);
-			if (!res || res.status() >= 400) bad = true;
+			// 🔴 `null` is not a failure: the sign-in callback already landed on `/`, so a `/#/deploys` is a
+			// same-document hash change, which playwright answers with no response (forge task 3914's `?`).
+			console.log(`${width}: ${res?.status() ?? "same document"} ${look.page.url()} → ${shot} (drawn in ${(settled.ms / 1000).toFixed(1)} s)`);
+			if (res && res.status() >= 400) bad = true;
+			if (!settled.idle) console.log(`  · the network never went quiet in ${IDLE_CEILING_MS / 1000} s (a stream or a poll) — the look waited on the page's own pending regions instead`);
+			if (settled.busy.length) {
+				bad = true;
+				console.error(`  🔴 still READING after ${SETTLE_CEILING_MS / 1000} s — this shot is the loading state, not the page: ${settled.busy.slice(0, 3).join(" · ")}`);
+			}
+			if (failed.length) {
+				bad = true;
+				console.error(`  🔴 the stage failed ${failed.length} of the page's own read(s) — the shot shows what it does without them: ${failed.slice(0, 5).join(", ")}`);
+				console.error("     a 503 on a relay app's stage is often its Mac end being down — that end is up only while its `worker:stage-walk` runs");
+			}
 			const broken = look.brokenMedia();
 			if (broken.length) {
 				bad = true;