iterate 0.2.7 → 0.3.0

package/dist/starter-apps/flake-dashboard/configured-worker.mjs

@@ -0,0 +1,1055 @@
+import { _ as object, b as url, d as _enum, f as array, g as number, h as literal, l as defineProcessorContract, m as discriminatedUnion, o as StreamProcessor, r as StreamProcessorDurableObject, t as _usingCtx, u as ZodISODateTime, v as record, x as _isoDateTime, y as string } from "../../usingCtx-mZx5nsAW.mjs";
+import { t as isIdempotencyConflict } from "../../processors-BoNyeBfQ.mjs";
+//#region ../../node_modules/.pnpm/zod@4.5.4_patch_hash=bf04bb1ec1f0b9f31a7416bf98f83d3451e5011852877ca0ac19c12fcb3129b5/node_modules/zod/v4/classic/iso.js
+function datetime(params) {
+	return _isoDateTime(ZodISODateTime, params);
+}
+//#endregion
+//#region src/starter-apps/flake-dashboard/app-ref.ts
+const flakesStreamPath = "/flakes";
+/**
+* The dashboard's birth certificate. Idempotency-keyed so every caller — the
+* worker's lazy initialization AND the CI reporter script, whichever appends
+* first — may offer it; the config values are immutable birth facts.
+*/
+function flakeDashboardCreationEvents(config) {
+	return [{
+		type: "events.iterate.com/flakes/created",
+		payload: { config },
+		idempotencyKey: "flakes/created"
+	}];
+}
+//#endregion
+//#region ../shared/src/test-support/flake-suite-summary.ts
+/** A full CI suite publishes this even when its flake record list is empty. */
+const FlakeSuiteSummary = object({
+	headSha: string().min(1),
+	branch: string(),
+	status: _enum(["complete", "incomplete"]),
+	startedAt: datetime(),
+	finishedAt: datetime(),
+	testCount: number().int().nonnegative(),
+	tests: array(object({
+		name: string().min(1),
+		outcome: _enum([
+			"pass",
+			"fail",
+			"skip"
+		])
+	})).optional(),
+	unknownFlakeCount: number().int().nonnegative(),
+	failedCount: number().int().nonnegative(),
+	diagnostics: array(string()),
+	runUrl: url()
+}).refine((summary) => summary.status !== "complete" || summary.testCount > 0 && !!summary.branch && summary.diagnostics.length === 0, "A complete suite needs executed tests and no missing-result diagnostics");
+//#endregion
+//#region src/starter-apps/flake-dashboard/contract.ts
+const flakeEventTypes = {
+	created: "events.iterate.com/flakes/created",
+	runRecorded: "events.iterate.com/flakes/run-recorded",
+	transitionProposed: "events.iterate.com/flakes/transition-proposed",
+	dashboardRenderSettled: "events.iterate.com/flakes/dashboard-render-settled"
+};
+const StreamOffset = number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+/**
+* One `createFlake` test outcome. Mirrors `FlakeRecord` in
+* `@iterate-com/shared/test-support/flake-test` — the wrapper writes these
+* lines to `FLAKE_RECORD_DIR` and CI ships them here verbatim.
+*/
+const FlakeOutcome = _enum([
+	"pass",
+	"flake-fail",
+	"unexpected-error",
+	"pinned-fail",
+	"unexpected-pass",
+	"retried-pass"
+]);
+/**
+* Which wrapper (or reporter) produced a record: createFlake, createFailing,
+* or the telemetry reporters' retried-pass records for tests nobody has
+* classified yet. Old events predate the field — they were all createFlake.
+*/
+const FlakeKind = _enum([
+	"flake",
+	"failing",
+	"unknown"
+]);
+const FlakeRecord = object({
+	name: string().min(1).max(1e3),
+	kind: FlakeKind.default("flake"),
+	outcome: FlakeOutcome,
+	pattern: string().min(1).max(2e3).optional(),
+	durationMs: number().nonnegative(),
+	at: string().min(1),
+	error: string().max(4e3).optional()
+});
+const FlakeDashboardConfig = object({
+	repository: object({
+		owner: string().min(1),
+		repo: string().min(1)
+	}),
+	issueTitle: string().min(1).max(200),
+	defaultBranch: string().min(1)
+});
+const FlakeRunRecorded = object({
+	runId: string().min(1).max(200),
+	suite: string().min(1).max(200),
+	branch: string().min(1).max(500),
+	commit: string().min(1).max(100),
+	records: array(FlakeRecord).max(1e4),
+	summary: FlakeSuiteSummary.optional()
+});
+const MainSuiteRun = object({
+	runId: string(),
+	commit: string(),
+	summary: FlakeSuiteSummary
+});
+const FlakeTransition = _enum([
+	"unwrap",
+	"switch-to-failing",
+	"unwrap-failing"
+]);
+const FlakeTransitionProposed = object({
+	testName: string().min(1),
+	transition: FlakeTransition,
+	evidence: object({
+		consecutiveRuns: number().int().positive(),
+		firstAt: string().min(1),
+		lastAt: string().min(1)
+	})
+});
+const FlakeDashboardRenderResult = discriminatedUnion("status", [object({
+	status: literal("succeeded"),
+	issueNumber: number().int().positive(),
+	issueUrl: string().url()
+}), object({
+	status: literal("failed"),
+	error: string().min(1).max(8e3)
+})]);
+/**
+* A run of consecutive same-outcome recorded runs on the default branch.
+* `unexpected-error` outcomes and outcome changes reset it. The streak is the
+* whole input to transition proposals, so it lives in reduced state rather
+* than being recomputed from history.
+*/
+const DefaultBranchStreak = object({
+	outcome: FlakeOutcome,
+	runs: number().int().positive(),
+	firstAt: string().min(1),
+	lastAt: string().min(1)
+});
+const TrackedTest = object({
+	/** Latest record's kind wins: adopting an unknown flake into createFlake migrates its row. */
+	kind: FlakeKind.default("flake"),
+	/** Empty for kind "unknown" — those rows show error samples instead. */
+	pattern: string().default(""),
+	suites: array(string()).default([]),
+	/**
+	* Per suite, the offset of the newest run-recorded event (any branch) whose
+	* records included this test. Compared against the suite's
+	* `recentRunOffsets` window at render time: a test absent from all of its
+	* suite's last few ingested runs is retired from the table — hidden, not
+	* deleted, so a transient absence self-heals on the next record.
+	*/
+	lastSeenOffset: record(string(), StreamOffset).default({}),
+	/**
+	* The latest (up to) 10 outcomes on any branch, ordered by test time — the
+	* render's emoji streak bar, each entry carrying the commit that produced
+	* it so the square can link straight to that commit's checks. All branches,
+	* like the counts, for debugging PR failures too. The numeric
+	* defaultBranchStreak below stays main-only and carries the
+	* transition-threshold counts past what 10 entries can show.
+	*/
+	recent: array(object({
+		outcome: FlakeOutcome,
+		commit: string().min(1).max(100),
+		at: string()
+	})).max(10).default([]),
+	/** Keyed by outcome value ("pass", "pinned-fail", …). */
+	counts: record(string(), number().int().nonnegative()).default({}),
+	/**
+	* The last few error samples worth showing (retried-pass and
+	* unexpected-error records) — for unknown flakes these are the copy-paste
+	* material for the createFlake pattern.
+	*/
+	recentErrors: array(object({
+		error: string().max(4e3),
+		commit: string(),
+		at: string()
+	})).max(3).default([]),
+	lastFlakeAt: string().nullable().default(null),
+	firstRecordedAt: string(),
+	lastRecordedAt: string(),
+	defaultBranchStreak: DefaultBranchStreak.nullable().default(null),
+	/** Older retry evidence cannot undo a wrapper observed on main in this suite. */
+	lastMainWrapperAt: record(string(), string()).default({}),
+	/**
+	* One entry per proposal already made, keyed `${transition}:${streak.firstAt}`
+	* — a streak proposes at most once however long it grows.
+	*/
+	proposed: array(string()).default([])
+});
+const FlakeDashboardState = object({
+	birthCertificate: object({ config: FlakeDashboardConfig }).nullable().default(null),
+	tests: record(string(), TrackedTest).default({}),
+	/**
+	* Main-only unknowns, isolated by suite. Healthy rows are hidden, retaining
+	* their streak so late failures can correct an apparent recovery.
+	*/
+	unknownFlakes: record(string(), record(string(), object({
+		record: FlakeRecord,
+		passStreak: number().int().nonnegative(),
+		/** Newest run that actually contained this test, including skips. */
+		lastRunAt: string(),
+		recent: array(object({
+			outcome: FlakeOutcome,
+			commit: string(),
+			at: string()
+		})).max(10)
+	}))).default({}),
+	mainRuns: record(string(), object({
+		latest: MainSuiteRun,
+		complete: MainSuiteRun.nullable(),
+		inventory: object({
+			startedAt: datetime(),
+			names: array(string())
+		}).nullable().default(null)
+	})).default({}),
+	/**
+	* The newest three ingested results across all branches retire absent
+	* tracked tests. This preserves visibility during partial PR runs. Unknown
+	* flakes retire after 20 main passes, wrapper adoption, or proven absence
+	* from their suite's full main inventory.
+	*/
+	suites: record(string(), object({ recentRunOffsets: array(StreamOffset).max(3).default([]) })).default({}),
+	/**
+	* Offset of the newest reduced DATA event (created / run-recorded /
+	* transition-proposed). Render settlements deliberately do not bump it —
+	* that is what stops a settled render from demanding another render.
+	*/
+	lastDataOffset: StreamOffset.default(0),
+	render: object({
+		throughOffset: StreamOffset,
+		issueNumber: number().int().positive().nullable(),
+		issueUrl: string().nullable()
+	}).nullable().default(null)
+});
+/**
+* Suggest unwrapping createFlake after 20 consecutive main passes, regardless
+* of elapsed time. Unknown flakes retire automatically at the same count.
+* Propose createFailing after 25 matched failures over >=2 days.
+* Tunable constants. Sentinel tests are excluded from proposals entirely —
+* they are designed to flake.
+*/
+const flakeTransitionThresholds = {
+	unwrap: {
+		runs: 20,
+		minSpanMs: 0
+	},
+	"switch-to-failing": {
+		runs: 25,
+		minSpanMs: 2880 * 60 * 1e3
+	},
+	"unwrap-failing": {
+		runs: 10,
+		minSpanMs: 2880 * 60 * 1e3
+	}
+};
+/**
+* The exact shape of a delivered event this app ingests: a platform-verified
+* GitHub webhook for a COMPLETED check_run on a connection stream. This
+* repo's test suites run on Depot CI, whose jobs are GitHub check runs (NOT
+* GitHub Actions workflow runs — `workflow_run` never fires for them). Zod
+* strips the rest of GitHub's (huge) payload; only these fields are read.
+*/
+const CheckRunWebhookEvent = object({
+	type: literal("events.iterate.com/github/webhook-received"),
+	path: string().regex(/^\/integrations\/github\/[^/]+$/),
+	payload: object({
+		delivery: object({ name: literal("check_run") }),
+		body: object({
+			action: literal("completed"),
+			check_run: object({
+				conclusion: _enum(["success", "failure"]),
+				head_sha: string().min(1),
+				check_suite: object({ head_branch: string().nullish() }).optional()
+			}),
+			repository: object({
+				name: string().min(1),
+				owner: object({ login: string().min(1) }),
+				default_branch: string().nullish()
+			})
+		})
+	})
+});
+const FlakeDashboardProcessorContract = defineProcessorContract({
+	slug: "flake-dashboard",
+	version: "0.8.0",
+	description: "Folds createFlake test outcomes reported by CI into per-test flake stats, renders the GitHub 'Flake dashboard' issue, and proposes data-provable lifecycle transitions.",
+	stateSchema: FlakeDashboardState,
+	events: {
+		[flakeEventTypes.created]: {
+			description: "The flake dashboard exists: target repository, issue title, and which branch counts for transitions.",
+			payloadSchema: object({ config: FlakeDashboardConfig }),
+			examples: [{
+				description: "The dogfood dashboard for this repo.",
+				payload: { config: {
+					repository: {
+						owner: "iterate",
+						repo: "iterate"
+					},
+					issueTitle: "Flake dashboard",
+					defaultBranch: "main"
+				} }
+			}]
+		},
+		[flakeEventTypes.runRecorded]: {
+			description: "One CI run+suite's createFlake outcomes, appended by the CI reporter script (never by this processor). Idempotency-keyed on run+suite so CI retries cannot double-count.",
+			payloadSchema: FlakeRunRecorded
+		},
+		[flakeEventTypes.transitionProposed]: {
+			description: "A test's default-branch streak crossed a lifecycle threshold; downstream automation (an agent) should open the unwrap / switch-to-failing PR. The file-edit guard (a streak is only trustworthy if the test file did not change during it) is applied by that agent, which can read git history — the fold cannot.",
+			payloadSchema: FlakeTransitionProposed
+		},
+		[flakeEventTypes.dashboardRenderSettled]: {
+			description: "Terminal fact for one dashboard render attempt: the GitHub issue reached (or the error), and the data offset it covered.",
+			payloadSchema: object({
+				throughOffset: StreamOffset,
+				result: FlakeDashboardRenderResult
+			})
+		}
+	},
+	consumes: [...Object.values(flakeEventTypes)],
+	emits: [flakeEventTypes.transitionProposed, flakeEventTypes.dashboardRenderSettled]
+});
+//#endregion
+//#region src/starter-apps/flake-dashboard/worker.ts
+const ARTIFACT_PREFIX = "flake-records-";
+const MAX_ARTIFACT_BYTES = 5 * 1024 * 1024;
+/**
+* The whole app is this worker: everything is processEvent and reduce.
+* `FlakeDashboardApp.processEvent` ingests workflow_run webhooks (CI's
+* credential-free reporting signal) into run-recorded events and wakes the
+* processor for /flakes events; `FlakeDashboardProcessor.reduce` folds them;
+* the processor's own processEvent drives the issue render and transition
+* proposals. No HTTP is served.
+*/
+var FlakeDashboardApp = class extends StreamProcessorDurableObject {
+	streamPath = flakesStreamPath;
+	recovery = true;
+	createProcessor(deps) {
+		return new FlakeDashboardProcessor({
+			...deps,
+			renderDashboard: async (state) => {
+				try {
+					var _usingCtx$1 = _usingCtx();
+					return await renderFlakeDashboardIssue(_usingCtx$1.u(await this.env.ITX.get()), state);
+				} catch (_) {
+					_usingCtx$1.e = _;
+				} finally {
+					_usingCtx$1.d();
+				}
+			}
+		});
+	}
+	/**
+	* Every flake-relevant event lands here — the same override point the
+	* platform's own delivery uses (widened public so the config worker can
+	* forward events over RPC). A /flakes event is a wake hint: catch-up
+	* re-reads committed events from the stream and owns validation, ordering,
+	* checkpointing, and dedupe.
+	*/
+	async processEvent(event, options) {
+		const webhook = CheckRunWebhookEvent.safeParse(event);
+		if (webhook.success) {
+			if (!options?.depot) return;
+			try {
+				await this.#ingestCheckRunFlakeArtifacts(webhook.data, options.depot);
+			} catch (error) {
+				console.error(`[flake-ingest] ingestion failed for sha ${webhook.data.payload.body.check_run.head_sha} (records dropped):`, error);
+			}
+			return;
+		}
+		if (event.path !== "/flakes") return;
+		await (await this.registry()).catchUp("flake-dashboard");
+	}
+	/**
+	* Artifact-pull ingestion for flake telemetry. This repo's suites run on
+	* Depot CI, so a completed check_run is the signal: resolve the Depot run
+	* by commit sha, list its `flake-records-<suite>` artifacts, fetch each
+	* via a short-lived signed URL, and append one run-recorded event per
+	* artifact to /flakes. CI holds no iterate credential; the Depot read
+	* token is a platform-held project secret. Any check_run completing on the
+	* same Depot run re-scans it — repeated appends dedupe on the
+	* run+attempt+suite idempotency key, so redeliveries and sibling checks
+	* are harmless.
+	*/
+	async #ingestCheckRunFlakeArtifacts(webhook, depot) {
+		try {
+			var _usingCtx3 = _usingCtx();
+			const { check_run: checkRun, repository } = webhook.payload.body;
+			const params = {
+				owner: repository.owner.login,
+				repo: repository.name
+			};
+			const itx = _usingCtx3.u(await this.env.ITX.get());
+			const token = await itx.secrets.get(depot.secretPath).reveal();
+			const depotRpc = async (method, body) => {
+				const response = await fetch(`https://api.depot.dev/depot.ci.v1.CIService/${method}`, {
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+						authorization: `Bearer ${token}`,
+						"x-depot-org": depot.orgId
+					},
+					body: JSON.stringify(body)
+				});
+				if (!response.ok) throw new Error(`depot ${method} failed: HTTP ${response.status} ${await response.text()}`);
+				return await response.json();
+			};
+			const runs = await depotRpc("ListRuns", {
+				repo: `${params.owner}/${params.repo}`,
+				sha: checkRun.head_sha,
+				pageSize: 10
+			});
+			for (const run of runs.runs || []) {
+				const flakeArtifacts = ((await depotRpc("ListArtifacts", {
+					runId: run.runId,
+					pageSize: 100
+				})).artifacts || []).filter((artifact) => artifact.name.startsWith(ARTIFACT_PREFIX));
+				if (flakeArtifacts.length === 0) continue;
+				const stream = itx.streams.get(flakesStreamPath);
+				try {
+					await stream.append(...flakeDashboardCreationEvents({
+						repository: params,
+						issueTitle: "Flake dashboard",
+						defaultBranch: repository.default_branch || "main"
+					}));
+				} catch (error) {
+					if (!isIdempotencyConflict(error)) throw error;
+				}
+				for (const artifact of flakeArtifacts) {
+					if (Number(artifact.sizeBytes || 0) > MAX_ARTIFACT_BYTES) {
+						console.warn(`[flake-ingest] skipping oversized artifact ${artifact.name} (${artifact.sizeBytes} bytes)`);
+						continue;
+					}
+					const suite = artifact.name.slice(14);
+					const download = await depotRpc("GetArtifactDownloadURL", { artifactId: artifact.artifactId });
+					if (!download.url) {
+						console.warn(`[flake-ingest] no download url for artifact ${artifact.name}`);
+						continue;
+					}
+					const zipResponse = await fetch(download.url);
+					if (!zipResponse.ok) throw new Error(`artifact download failed: HTTP ${zipResponse.status}`);
+					const files = await unzip(new Uint8Array(await zipResponse.arrayBuffer()));
+					const malformedRecords = [];
+					const records = Object.entries(files).filter(([name]) => name.endsWith(".jsonl")).flatMap(([name, bytes]) => new TextDecoder().decode(bytes).split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+						let json;
+						try {
+							json = JSON.parse(line);
+						} catch {
+							malformedRecords.push(`Malformed record in ${name}`);
+							return [];
+						}
+						const parsed = FlakeRecord.safeParse(json);
+						if (!parsed.success) {
+							malformedRecords.push(`Malformed record in ${name}`);
+							return [];
+						}
+						return [parsed.data];
+					}));
+					const summaryBytes = Object.entries(files).find(([name]) => name === "suite-summary.json" || name.endsWith("/suite-summary.json"))?.[1];
+					let summary;
+					if (summaryBytes) try {
+						summary = FlakeSuiteSummary.parse(JSON.parse(new TextDecoder().decode(summaryBytes)));
+					} catch {
+						console.error(`[flake-ingest] invalid suite-summary.json in ${artifact.name}; skipping artifact`);
+						continue;
+					}
+					if (summary && summary.unknownFlakeCount !== records.filter((record) => record.kind === "unknown").length) malformedRecords.push("Unknown flake records do not match the full runner result");
+					if (summary?.tests && summary.tests.length !== summary.testCount) malformedRecords.push("Per-test results do not match the full runner test count");
+					if (summary && malformedRecords.length > 0) {
+						summary.status = "incomplete";
+						summary.diagnostics.push(...new Set(malformedRecords));
+					}
+					if (records.length === 0 && !summary) continue;
+					const runId = `${run.runId}-${artifact.attempt || 1}`;
+					try {
+						await stream.append({
+							type: "events.iterate.com/flakes/run-recorded",
+							idempotencyKey: `flakes/run:${runId}:${suite}`,
+							payload: {
+								runId,
+								suite,
+								branch: summary ? summary.branch : checkRun.check_suite?.head_branch || "unknown",
+								commit: summary ? summary.headSha : checkRun.head_sha,
+								records,
+								summary
+							}
+						});
+					} catch (error) {
+						if (!isIdempotencyConflict(error)) throw error;
+					}
+					console.log(`[flake-ingest] ingested ${records.length} records from ${artifact.name} (run ${runId})`);
+				}
+			}
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+	}
+	/** Internal RPC surface used by smoke checks and debugging. */
+	async getState() {
+		await (await this.registry()).catchUp("flake-dashboard");
+		return (await this.snapshot()).state;
+	}
+};
+/**
+* One instance runs on the project's `/flakes` stream. CI appends
+* `run-recorded` events; this processor folds them into per-test stats, owns
+* the GitHub issue render as its durable obligation, and proposes lifecycle
+* transitions when a default-branch streak crosses a threshold.
+*/
+var FlakeDashboardProcessor = class extends StreamProcessor {
+	contract = FlakeDashboardProcessorContract;
+	/**
+	* Runtime-only render attempt guard. The render-settled stream event is the
+	* durable truth: after an eviction this is false and the next caught-up
+	* pass re-drives any still-unrendered data.
+	*/
+	#liveRender = false;
+	reduce({ event, state }) {
+		switch (event.type) {
+			case flakeEventTypes.created:
+				if (state.birthCertificate !== null) return state;
+				return {
+					...state,
+					birthCertificate: event.payload,
+					lastDataOffset: event.offset
+				};
+			case flakeEventTypes.runRecorded: {
+				const config = state.birthCertificate?.config;
+				if (config === void 0) return state;
+				const onDefaultBranch = event.payload.branch === config.defaultBranch;
+				const { summary, suite, runId, commit, records } = event.payload;
+				const tests = { ...state.tests };
+				for (const record of event.payload.records) {
+					const existing = tests[record.name];
+					const runAt = summary?.startedAt || record.at;
+					const wrapperAt = existing?.lastMainWrapperAt[suite];
+					const unknownAt = state.unknownFlakes[suite]?.[record.name]?.lastRunAt;
+					const staleKind = existing && onDefaultBranch && (record.kind === "unknown" ? wrapperAt && runAt < wrapperAt : unknownAt && runAt < unknownAt);
+					const kind = staleKind ? existing.kind : record.kind;
+					const counts = { ...existing?.counts };
+					counts[record.outcome] = (counts[record.outcome] || 0) + 1;
+					const streak = existing?.defaultBranchStreak || null;
+					const nextStreak = !onDefaultBranch || staleKind ? streak : record.outcome === "unexpected-error" ? null : streak && streak.outcome === record.outcome ? {
+						...streak,
+						runs: streak.runs + 1,
+						lastAt: record.at
+					} : {
+						outcome: record.outcome,
+						runs: 1,
+						firstAt: record.at,
+						lastAt: record.at
+					};
+					const flakeStruck = record.outcome === "flake-fail" || record.outcome === "retried-pass";
+					const errorSample = record.error !== void 0 && (record.outcome === "retried-pass" || record.outcome === "unexpected-error") ? {
+						error: record.error,
+						commit: event.payload.commit,
+						at: record.at
+					} : null;
+					tests[record.name] = {
+						kind,
+						pattern: staleKind ? existing.pattern : record.pattern || existing?.pattern || "",
+						suites: existing?.suites.includes(event.payload.suite) ? existing.suites : [...existing?.suites || [], event.payload.suite],
+						lastSeenOffset: {
+							...existing?.lastSeenOffset,
+							[event.payload.suite]: event.offset
+						},
+						recent: [...existing?.recent || [], {
+							outcome: record.outcome,
+							commit: event.payload.commit,
+							at: record.at
+						}].sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).slice(-10),
+						counts,
+						recentErrors: errorSample ? [...existing?.recentErrors || [], errorSample].sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).slice(-3) : existing?.recentErrors || [],
+						lastFlakeAt: flakeStruck && (!existing?.lastFlakeAt || Date.parse(record.at) > Date.parse(existing.lastFlakeAt)) ? record.at : existing?.lastFlakeAt || null,
+						firstRecordedAt: existing && existing.kind === kind ? existing.firstRecordedAt : record.at,
+						lastRecordedAt: existing && Date.parse(existing.lastRecordedAt) > Date.parse(record.at) ? existing.lastRecordedAt : record.at,
+						defaultBranchStreak: nextStreak,
+						lastMainWrapperAt: onDefaultBranch && record.kind !== "unknown" ? {
+							...existing?.lastMainWrapperAt,
+							[suite]: wrapperAt && wrapperAt > runAt ? wrapperAt : runAt
+						} : existing?.lastMainWrapperAt || {},
+						proposed: existing?.proposed || []
+					};
+				}
+				const suites = {
+					...state.suites,
+					[event.payload.suite]: { recentRunOffsets: [...state.suites[event.payload.suite]?.recentRunOffsets || [], ...(event.payload.summary ? event.payload.summary.status === "complete" : event.payload.records.length > 0) ? [event.offset] : []].slice(-3) }
+				};
+				const mainRuns = { ...state.mainRuns };
+				const previousInventory = mainRuns[suite]?.inventory || null;
+				const inventory = onDefaultBranch && summary?.status === "complete" && summary.tests && (!previousInventory || summary.startedAt >= previousInventory.startedAt) ? {
+					startedAt: summary.startedAt,
+					names: [...new Set(summary.tests.map((test) => test.name))]
+				} : previousInventory;
+				const unknownFlakes = { ...state.unknownFlakes };
+				if (onDefaultBranch) {
+					const unknowns = { ...unknownFlakes[suite] };
+					const recordedNames = new Set(records.map((record) => record.name));
+					const results = /* @__PURE__ */ new Map();
+					for (const test of summary?.tests || []) {
+						const previous = results.get(test.name);
+						results.set(test.name, previous === "fail" || test.outcome === "fail" ? "fail" : previous === "skip" || test.outcome === "skip" ? "skip" : "pass");
+					}
+					if (summary) for (const [name, test] of Object.entries(unknowns)) {
+						if (recordedNames.has(name)) continue;
+						const wrapperAt = tests[name]?.lastMainWrapperAt[suite];
+						if (wrapperAt && summary.startedAt < wrapperAt) continue;
+						const outcome = results.get(name);
+						if (!outcome) continue;
+						const pass = outcome === "pass" && summary.status === "complete";
+						const fail = outcome === "fail";
+						if (!fail && summary.startedAt <= test.lastRunAt) continue;
+						const passStreak = fail ? 0 : test.passStreak + Number(pass);
+						unknowns[name] = {
+							...test,
+							passStreak,
+							lastRunAt: summary.startedAt > test.lastRunAt ? summary.startedAt : test.lastRunAt,
+							recent: pass || fail ? test.recent.concat({
+								outcome: pass ? "pass" : "unexpected-error",
+								commit,
+								at: summary.startedAt
+							}).sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).slice(-10) : test.recent
+						};
+					}
+					for (const record of records) {
+						const previous = unknowns[record.name];
+						const lastRunAt = summary?.startedAt || record.at;
+						const wrapperAt = tests[record.name]?.lastMainWrapperAt[suite];
+						if (record.kind === "unknown" && wrapperAt && lastRunAt < wrapperAt) continue;
+						if (record.kind !== "unknown") {
+							if (previous && lastRunAt <= previous.lastRunAt) continue;
+							delete unknowns[record.name];
+							continue;
+						}
+						unknowns[record.name] = {
+							record: previous && Date.parse(previous.record.at) > Date.parse(record.at) ? previous.record : record,
+							passStreak: 0,
+							lastRunAt: previous && previous.lastRunAt > lastRunAt ? previous.lastRunAt : lastRunAt,
+							recent: [...previous?.recent || [], {
+								outcome: record.outcome,
+								commit,
+								at: record.at
+							}].sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).slice(-10)
+						};
+					}
+					if (inventory) {
+						const names = new Set(inventory.names);
+						for (const [name, test] of Object.entries(unknowns)) if (test.lastRunAt <= inventory.startedAt && !names.has(name)) delete unknowns[name];
+					}
+					unknownFlakes[suite] = unknowns;
+				}
+				if (onDefaultBranch && summary) {
+					const previous = mainRuns[suite];
+					const incoming = {
+						runId,
+						commit,
+						summary: {
+							...summary,
+							tests: void 0
+						}
+					};
+					mainRuns[suite] = {
+						inventory,
+						latest: !previous || summary.startedAt >= previous.latest.summary.startedAt ? incoming : previous.latest,
+						complete: summary.status === "complete" && (!previous?.complete || summary.startedAt >= previous.complete.summary.startedAt) ? incoming : previous?.complete || null
+					};
+				}
+				return {
+					...state,
+					tests,
+					suites,
+					mainRuns,
+					unknownFlakes,
+					lastDataOffset: event.offset
+				};
+			}
+			case flakeEventTypes.transitionProposed: {
+				const test = state.tests[event.payload.testName];
+				if (test === void 0) return {
+					...state,
+					lastDataOffset: event.offset
+				};
+				const marker = `${event.payload.transition}:${event.payload.evidence.firstAt}`;
+				return {
+					...state,
+					tests: {
+						...state.tests,
+						[event.payload.testName]: {
+							...test,
+							proposed: test.proposed.includes(marker) ? test.proposed : [...test.proposed, marker]
+						}
+					},
+					lastDataOffset: event.offset
+				};
+			}
+			case flakeEventTypes.dashboardRenderSettled:
+				if (event.payload.result.status !== "succeeded") return state;
+				return {
+					...state,
+					render: {
+						throughOffset: event.payload.throughOffset,
+						issueNumber: event.payload.result.issueNumber,
+						issueUrl: event.payload.result.issueUrl
+					}
+				};
+		}
+	}
+	processEvent(args) {
+		const { append, blockProcessorWhile, delivery, event, runInBackground, state } = args;
+		if (event?.type === flakeEventTypes.runRecorded) for (const [testName, test] of Object.entries(state.tests)) {
+			if (isSentinel(testName)) continue;
+			const streak = test.defaultBranchStreak;
+			if (streak === null) continue;
+			const transition = streak.outcome === "pass" ? "unwrap" : streak.outcome === "flake-fail" ? "switch-to-failing" : streak.outcome === "unexpected-pass" ? "unwrap-failing" : null;
+			if (transition === null) continue;
+			const threshold = flakeTransitionThresholds[transition];
+			const spanMs = Date.parse(streak.lastAt) - Date.parse(streak.firstAt);
+			if (streak.runs < threshold.runs || spanMs < threshold.minSpanMs) continue;
+			const marker = `${transition}:${streak.firstAt}`;
+			if (test.proposed.includes(marker)) continue;
+			blockProcessorWhile(() => this.#appendTolerantOfSettledRace(append, {
+				type: flakeEventTypes.transitionProposed,
+				idempotencyKey: this.idempotencyKey(`transition:${testName}:${marker}`),
+				payload: {
+					testName,
+					transition,
+					evidence: {
+						consecutiveRuns: streak.runs,
+						firstAt: streak.firstAt,
+						lastAt: streak.lastAt
+					}
+				}
+			}));
+		}
+		if (!delivery.caughtUp) return;
+		if (state.birthCertificate === null) return;
+		if (state.lastDataOffset <= (state.render?.throughOffset || 0)) return;
+		if (this.#liveRender) return;
+		const throughOffset = state.lastDataOffset;
+		this.#liveRender = true;
+		runInBackground(async () => {
+			let result;
+			try {
+				result = await this.deps.renderDashboard(state);
+			} catch (error) {
+				result = {
+					status: "failed",
+					error: (error instanceof Error ? error.message : String(error)).slice(0, 8e3) || "Unknown render failure."
+				};
+			}
+			try {
+				await this.#appendTolerantOfSettledRace(append, {
+					type: flakeEventTypes.dashboardRenderSettled,
+					idempotencyKey: this.idempotencyKey(`dashboard-render:${throughOffset}:${result.status}`),
+					payload: {
+						throughOffset,
+						result
+					}
+				});
+			} finally {
+				this.#liveRender = false;
+			}
+		});
+	}
+	/**
+	* Growing streaks and overlapping render attempts can race on one
+	* processor-owned key with fresher bodies. The first committed fact wins;
+	* a same-key/different-body rejection means the work is already settled.
+	*/
+	async #appendTolerantOfSettledRace(append, event) {
+		try {
+			await append(event);
+		} catch (error) {
+			if (!isIdempotencyConflict(error)) throw error;
+		}
+	}
+};
+const DASHBOARD_MARKER = "<!-- iterate-flake-dashboard -->";
+/**
+* Upsert the GitHub "Flake dashboard" issue from folded state. Mechanical by
+* design (the AI-linter publication stance): all decisions were made when the
+* events reduced. The processor is the single writer, so a plain body
+* overwrite is race-free; the marker plus remembered issue number make the
+* upsert idempotent across retried renders.
+*/
+async function renderFlakeDashboardIssue(itx, state) {
+	const config = state.birthCertificate?.config;
+	if (config === void 0) throw new Error("Flake dashboard has no birth certificate.");
+	const repos = await itx.repos.list();
+	const link = (await Promise.all(repos.map(async ({ path }) => (await itx.repos.get(path).processor.snapshot()).state.github))).find((candidate) => candidate !== null && candidate.owner === config.repository.owner && candidate.repo === config.repository.repo);
+	if (link === null || link === void 0) throw new Error(`No linked GitHub connection for ${config.repository.owner}/${config.repository.repo}; link a repo to that repository before the dashboard can render.`);
+	const octokit = itx.integrations.github.get(link.connection).octokit;
+	const params = {
+		owner: config.repository.owner,
+		repo: config.repository.repo
+	};
+	const body = renderBody(state);
+	const rememberedIssueNumber = state.render?.issueNumber || null;
+	if (rememberedIssueNumber !== null) return {
+		status: "succeeded",
+		issueNumber: rememberedIssueNumber,
+		issueUrl: (await octokit.rest.issues.update({
+			...params,
+			issue_number: rememberedIssueNumber,
+			body,
+			title: config.issueTitle
+		})).data.html_url
+	};
+	const existing = (await octokit.paginate("GET /repos/{owner}/{repo}/issues", {
+		...params,
+		state: "open",
+		per_page: 100
+	})).find((issue) => issue.body?.includes(DASHBOARD_MARKER) === true);
+	if (existing !== void 0) {
+		await octokit.rest.issues.update({
+			...params,
+			issue_number: existing.number,
+			body,
+			title: config.issueTitle
+		});
+		return {
+			status: "succeeded",
+			issueNumber: existing.number,
+			issueUrl: existing.html_url
+		};
+	}
+	const created = await octokit.rest.issues.create({
+		...params,
+		title: config.issueTitle,
+		body
+	});
+	return {
+		status: "succeeded",
+		issueNumber: created.data.number,
+		issueUrl: created.data.html_url
+	};
+}
+const OUTCOME_EMOJI = {
+	pass: "🟩",
+	"unexpected-pass": "🟩",
+	"flake-fail": "🟥",
+	"pinned-fail": "🟥",
+	"retried-pass": "🟥",
+	"unexpected-error": "❌"
+};
+/**
+* The deliberate canary flakes are identified by naming convention — every
+* suite's sentinel test contains this phrase ("flake sentinel",
+* "flake sentinel (specs)", …). A convention beats a record flag: it needs no
+* wire-format field and holds for all historical records.
+*/
+function isSentinel(testName) {
+	return testName.includes("flake sentinel");
+}
+const MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+/** "Sep 4, 7:16am" (UTC) — ISO timestamps read like log spam in the table. */
+function shortDate(iso) {
+	const date = new Date(iso);
+	if (Number.isNaN(date.getTime())) return iso;
+	const hours = date.getUTCHours();
+	const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+	return `${MONTHS[date.getUTCMonth()]} ${date.getUTCDate()}, ${hours % 12 || 12}:${minutes}${hours >= 12 ? "pm" : "am"}`;
+}
+/** Exported for tests: the table is a pure projection of folded state. */
+function renderBody(state) {
+	const tests = Object.entries(state.tests).sort(([a], [b]) => a.localeCompare(b));
+	const lastRecordedAt = [...tests.map(([, test]) => test.lastRecordedAt), ...Object.values(state.mainRuns).map((result) => result.latest.summary.finishedAt)].sort().at(-1);
+	const tracked = tests.filter(([, test]) => test.kind !== "unknown");
+	const visible = tracked.filter(([, test]) => Object.entries(test.lastSeenOffset).some(([suite, seen]) => {
+		const windowStart = state.suites[suite]?.recentRunOffsets[0];
+		return windowStart === void 0 || seen >= windowStart;
+	}));
+	const retiredCount = tracked.length - visible.length;
+	const config = state.birthCertificate?.config;
+	const count = (test, outcome) => test.counts[outcome] || 0;
+	const row = ([name, test]) => {
+		const runs = Object.values(test.counts).reduce((total, n) => total + n, 0);
+		const info = [
+			`pattern: \`${`/${test.pattern}/`.replaceAll(/\s+/gu, " ").replaceAll("`", "'").replaceAll("|", "\\|")}\``,
+			`suites: ${test.suites.join(", ")}`,
+			...test.proposed.length === 0 ? [] : [`proposed: ${test.proposed.map((p) => p.split(":")[0]).join(", ")}`]
+		].join("<br>");
+		const gated = count(test, "pass") + count(test, "flake-fail");
+		const stats = (test.kind === "failing" ? [
+			`runs: ${runs}`,
+			`pin held: ${count(test, "pinned-fail")}`,
+			`unexpected passes: ${count(test, "unexpected-pass")}`,
+			`pinned since: ${shortDate(test.firstRecordedAt)}`
+		] : [
+			`runs: ${runs}`,
+			`flake rate: ${gated === 0 ? "—" : `${Math.round(count(test, "flake-fail") / gated * 100)}%`}`,
+			`last flake: ${test.lastFlakeAt ? shortDate(test.lastFlakeAt) : "never"}`
+		]).join("<br>");
+		const streak = [test.recent.map((entry) => {
+			const emoji = OUTCOME_EMOJI[entry.outcome];
+			if (config === void 0) return emoji;
+			const { owner, repo } = config.repository;
+			return `[${emoji}](https://github.com/${owner}/${repo}/commit/${entry.commit})`;
+		}).join("") || "—", ...test.defaultBranchStreak === null || config === void 0 ? [] : [`${test.defaultBranchStreak.runs}× ${test.defaultBranchStreak.outcome} (${config.defaultBranch})`]].join("<br>");
+		return [
+			`\`${name}\``,
+			info,
+			stats,
+			streak
+		].join(" | ");
+	};
+	const sections = [
+		{
+			title: "Flakes",
+			legend: `_createFlake-wrapped: 🟩 passed · 🟥 the known flake struck · ❌ failed differently than expected. Suggest removing the wrapper after ${flakeTransitionThresholds.unwrap.runs} consecutive main passes, with no minimum elapsed time._`,
+			tests: visible.filter(([name, test]) => test.kind === "flake" && !isSentinel(name))
+		},
+		{
+			title: "Failures",
+			legend: "_createFailing pins: 🟥 the pinned bug is present · 🟩 passed unexpectedly — the bug may be fixed · ❌ failed differently than expected._",
+			tests: visible.filter(([, test]) => test.kind === "failing")
+		},
+		{
+			title: "Sentinels",
+			legend: "_Deliberate canary flakes proving the recording pipeline works: 🟩 passed · 🟥 the known flake struck · ❌ failed differently than expected._",
+			tests: visible.filter(([name, test]) => test.kind === "flake" && isSentinel(name))
+		}
+	].filter((section) => section.tests.length > 0);
+	return [
+		DASHBOARD_MARKER,
+		"Test health, folded from CI-reported runs: [`createFlake`](https://github.com/iterate/iterate/blob/main/packages/shared/src/test-support/flake-test.ts) wraps, [`createFailing`](https://github.com/iterate/iterate/blob/main/packages/shared/src/test-support/failing-test.ts) pins, and unclassified flaky tests caught by CI retries. Maintained automatically — edits to this body will be overwritten. Squares show the last 10 outcomes, oldest→newest, and link to their commits. Wrapped tests show all branches; unknown flakes show main only. Lifecycle streak counts use main only.",
+		...sections.filter((section) => section.title !== "Sentinels").flatMap(renderSection),
+		...renderUnknownFlakes(state),
+		...sections.filter((section) => section.title === "Sentinels").flatMap(renderSection),
+		"",
+		`_Last recorded outcome: ${lastRecordedAt || "none"}._`,
+		...retiredCount === 0 ? [] : [`_${retiredCount} retired ${retiredCount === 1 ? "test" : "tests"} hidden (absent from the last 3 runs of their suite)._`]
+	].join("\n");
+	function renderSection(section) {
+		const collapsed = section.title === "Failures" || section.title === "Sentinels";
+		const suiteCounts = /* @__PURE__ */ new Map();
+		for (const [, test] of section.tests) for (const suite of test.suites) suiteCounts.set(suite, (suiteCounts.get(suite) || 0) + 1);
+		const summary = [`${section.tests.length} ${section.tests.length === 1 ? "test" : "tests"}`, ...[...suiteCounts].sort(([a], [b]) => a.localeCompare(b)).map(([suite, count]) => `${suite}: ${count}`)].join(" · ");
+		return [
+			"",
+			`## ${section.title}`,
+			"",
+			...collapsed ? [
+				"<details>",
+				`<summary>${summary}</summary>`,
+				""
+			] : [],
+			section.legend,
+			"",
+			"test | info | stats | streak",
+			"--- | --- | --- | ---",
+			...section.tests.map(row),
+			...collapsed ? ["", "</details>"] : []
+		];
+	}
+}
+function renderUnknownFlakes(state) {
+	const suites = [...new Set([...Object.keys(state.suites), ...Object.keys(state.mainRuns)])].sort();
+	const escape = (text) => text.replaceAll(/\s+/gu, " ").replaceAll(/([\\`*_[\]|<>])/gu, "\\$1");
+	const rows = suites.flatMap((suite) => Object.entries(state.unknownFlakes[suite] || {}).filter(([, test]) => test.passStreak < flakeTransitionThresholds.unwrap.runs).sort(([a], [b]) => a.localeCompare(b)).map(([, test]) => {
+		const record = test.record;
+		const config = state.birthCertificate.config;
+		const squares = test.recent.map(({ outcome, commit }) => `[${OUTCOME_EMOJI[outcome]}](https://github.com/${config.repository.owner}/${config.repository.repo}/commit/${commit})`).join("");
+		return [
+			escape(record.name),
+			`\`${(record.error || "No error sample recorded").replaceAll(/\s+/gu, " ").replaceAll("`", "'").replaceAll("|", "\\|").slice(0, 300)}\``,
+			escape(suite),
+			`${squares}<br>${test.passStreak}/${flakeTransitionThresholds.unwrap.runs} consecutive passes`
+		].join(" | ");
+	}));
+	const completeCount = suites.filter((suite) => state.mainRuns[suite]?.complete).length;
+	return [
+		"",
+		"## Unknown flakes",
+		"",
+		`_Any main retry adds a test here. Remove it after ${flakeTransitionThresholds.unwrap.runs} consecutive main passes, wrapper adoption, or absence from a complete main run's full test list. Failures reset the streak. Skips and incomplete results cannot advance it or prove deletion. 🟩 passed · 🟥 needed a retry · ❌ failed. PR results do not affect this table._`,
+		"",
+		...suites.map((suite) => {
+			const result = state.mainRuns[suite];
+			if (!result) return `- **${escape(suite)}:** awaiting a complete main result.`;
+			const complete = result.complete;
+			const incomplete = result.latest.summary.status === "incomplete" ? ` Latest attempt [${result.latest.commit.slice(0, 7)}](${result.latest.summary.runUrl}) incomplete: ${escape(result.latest.summary.diagnostics.join("; "))}.` : "";
+			if (!complete) return `- **${escape(suite)}:** awaiting a complete main result.${incomplete}`;
+			return `- **${escape(suite)}:** [${complete.commit.slice(0, 7)}](${complete.summary.runUrl}) · ${shortDate(complete.summary.finishedAt)} UTC · ${complete.summary.testCount} tests · ${complete.summary.failedCount} failed.${incomplete}`;
+		}),
+		"",
+		...rows.length > 0 ? [
+			"test | first failure | suite | streak (main)",
+			"--- | --- | --- | ---",
+			...rows
+		] : [completeCount === 0 ? "_Awaiting the first complete main results._" : "_No active unknown flakes. Passing streaks are evidence of stability, not proof that the root cause is fixed._"]
+	];
+}
+/**
+* Minimal zip reader on the runtime's own DecompressionStream — deliberately
+* not a dependency. The format surface is narrow by construction: one
+* producer (GitHub's artifact service), a 5MB size cap upstream, and reading
+* via the central directory (sizes come from there, so streaming-writer data
+* descriptors don't matter). No zip64 — impossible under the size cap — and
+* anything unexpected throws, which ingestion treats as a logged drop.
+*/
+async function unzip(bytes) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let eocd = -1;
+	for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 22 - 65535); i--) if (view.getUint32(i, true) === 101010256) {
+		eocd = i;
+		break;
+	}
+	if (eocd < 0) throw new Error("not a zip: no end-of-central-directory record");
+	const entryCount = view.getUint16(eocd + 10, true);
+	const files = {};
+	let offset = view.getUint32(eocd + 16, true);
+	for (let i = 0; i < entryCount; i++) {
+		if (view.getUint32(offset, true) !== 33639248) throw new Error("corrupt zip: bad central directory entry signature");
+		const method = view.getUint16(offset + 10, true);
+		const compressedSize = view.getUint32(offset + 20, true);
+		const nameLength = view.getUint16(offset + 28, true);
+		const extraLength = view.getUint16(offset + 30, true);
+		const commentLength = view.getUint16(offset + 32, true);
+		const localHeaderOffset = view.getUint32(offset + 42, true);
+		const name = new TextDecoder().decode(bytes.subarray(offset + 46, offset + 46 + nameLength));
+		const localNameLength = view.getUint16(localHeaderOffset + 26, true);
+		const localExtraLength = view.getUint16(localHeaderOffset + 28, true);
+		const dataStart = localHeaderOffset + 30 + localNameLength + localExtraLength;
+		const data = bytes.slice(dataStart, dataStart + compressedSize);
+		if (method === 0) files[name] = data;
+		else if (method === 8) {
+			const inflated = new Response(data).body.pipeThrough(new DecompressionStream("deflate-raw"));
+			files[name] = new Uint8Array(await new Response(inflated).arrayBuffer());
+		} else throw new Error(`unsupported zip compression method ${method} for ${name}`);
+		offset += 46 + nameLength + extraLength + commentLength;
+	}
+	return files;
+}
+//#endregion
+export { FlakeDashboardApp };
+
+//# sourceMappingURL=configured-worker.mjs.map