pi-roundtable 0.17.3 → 0.19.0

package/src/core/images/codex-image.ts

@@ -0,0 +1,257 @@
+// A client for ChatGPT's undocumented Codex backend, signed in with an openai-codex login, that draws one image.
+
+import type { ReferenceImage } from "../contract/providers.ts";
+
+const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const REQUEST_TIMEOUT_MS = 5 * 60_000;
+const MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+const MAX_IMAGE_BASE64 = Math.ceil(MAX_IMAGE_BYTES / 3) * 4;
+
+/** The Pi provider whose login pays for the images. */
+export const CODEX_IMAGES_PROVIDER = "openai-codex";
+/** Routes the Codex request; the backend picks the image model itself. */
+export const CODEX_IMAGE_MODEL = "gpt-6-sol";
+
+/**
+ * Codex ran the image tool but returned no image, or answered without one; usually it refused
+ * the prompt. Asking again with the same prompt fails again.
+ */
+export class ImageNotGeneratedError extends Error {
+	override name = "ImageNotGeneratedError";
+}
+
+/** The part of `fetch` the client uses, so a test can stand in for the network. `typeof fetch` is assignable. */
+export type CodexFetch = (url: string, init: RequestInit) => Promise<Response>;
+
+export interface CodexImageRequest {
+	/** The openai-codex login's access token; read it again for each drawing, because the login refreshes. */
+	token: string;
+	prompt: string;
+	references?: readonly ReferenceImage[];
+	/** The model that routes the request; default `CODEX_IMAGE_MODEL`. */
+	model?: string;
+	/** Aborts the request and the read of its stream; the five-minute limit applies as well. */
+	signal?: AbortSignal;
+	/** The request function; default the global `fetch`. */
+	fetch?: CodexFetch;
+}
+
+export interface CodexImage {
+	/** PNG bytes. */
+	data: Uint8Array;
+	/** The prompt Codex says it drew, when it tells. */
+	revisedPrompt?: string;
+}
+
+/** What bounds one drawing; the core's tests lower these, the public client always uses the defaults. */
+export interface CodexImageLimits {
+	timeoutMs: number;
+	maxStreamBytes: number;
+}
+
+export const CODEX_IMAGE_LIMITS: CodexImageLimits = {
+	timeoutMs: REQUEST_TIMEOUT_MS,
+	maxStreamBytes: MAX_IMAGE_BYTES,
+};
+
+/** The ChatGPT account the login token belongs to, from the token's claims. */
+function chatGptAccountId(token: string): string {
+	const [, payload] = token.split(".");
+	if (!payload) throw new Error("the Codex token is not a JWT");
+	let claims: Record<string, unknown>;
+	try {
+		claims = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+	} catch {
+		throw new Error("the Codex token's claims are not JSON");
+	}
+	const auth = claims[JWT_CLAIM_PATH] as
+		| { chatgpt_account_id?: unknown }
+		| undefined;
+	const id = auth?.chatgpt_account_id;
+	if (typeof id !== "string" || !id)
+		throw new Error("the Codex token has no ChatGPT account");
+	return id;
+}
+
+function object(value: unknown): Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: {};
+}
+
+/** The one image an `image_generation_call` item carries; anything else is not an image. */
+function imageOf(value: unknown): CodexImage | undefined {
+	const item = object(value);
+	if (item.type !== "image_generation_call") return undefined;
+	if (
+		item.status !== "completed" ||
+		typeof item.result !== "string" ||
+		!item.result
+	) {
+		const { result: _result, ...detail } = item;
+		throw new ImageNotGeneratedError(
+			`Codex image generation did not complete (status ${String(item.status)}): ${JSON.stringify(detail).slice(0, 300)}`,
+		);
+	}
+	if (item.result.length > MAX_IMAGE_BASE64)
+		throw new Error("the image exceeds 32 MiB");
+	const data = new Uint8Array(Buffer.from(item.result, "base64"));
+	return typeof item.revised_prompt === "string" && item.revised_prompt
+		? { data, revisedPrompt: item.revised_prompt }
+		: { data };
+}
+
+/** The frames of a server-sent event stream: the text between blank lines. */
+async function* frames(
+	body: ReadableStream<Uint8Array>,
+	signal: AbortSignal,
+	maxBytes: number,
+): AsyncGenerator<string> {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let read = 0;
+	for await (const chunk of body) {
+		signal.throwIfAborted();
+		read += chunk.byteLength;
+		if (read > maxBytes) throw new Error("Codex image response too large");
+		buffer += decoder.decode(chunk, { stream: true });
+		let match = /\r?\n\r?\n/.exec(buffer);
+		while (match) {
+			yield buffer.slice(0, match.index);
+			buffer = buffer.slice(match.index + match[0].length);
+			match = /\r?\n\r?\n/.exec(buffer);
+		}
+	}
+	if (buffer.trim()) yield buffer;
+}
+
+/** The event a frame carries, or undefined for a frame without data. */
+function eventOf(frame: string): Record<string, unknown> | undefined {
+	const data = frame
+		.split(/\r?\n/)
+		.flatMap((line) => (line.startsWith("data:") ? [line.slice(5).trim()] : []))
+		.join("\n");
+	if (!data || data === "[DONE]") return undefined;
+	try {
+		return object(JSON.parse(data));
+	} catch {
+		throw new Error(`Codex sent a malformed event: ${data.slice(0, 200)}`);
+	}
+}
+
+/** Reads the events until the response completes, and returns its first image. */
+async function parseImageStream(
+	response: Response,
+	signal: AbortSignal,
+	maxBytes: number,
+): Promise<CodexImage> {
+	if (!response.body) throw new Error("Codex returned no body");
+	let image: CodexImage | undefined;
+	for await (const frame of frames(response.body, signal, maxBytes)) {
+		const event = eventOf(frame);
+		switch (event?.type) {
+			case "error":
+			case "response.failed": {
+				const error = object(object(event.response).error ?? event.error);
+				throw new Error(
+					`Codex failed: ${String(error.message ?? error.code ?? "unknown error")}`,
+				);
+			}
+			case "response.incomplete":
+				throw new Error("the Codex response was incomplete");
+			case "response.output_item.done":
+				image ??= imageOf(event.item);
+				break;
+			case "response.completed": {
+				const output = object(event.response).output;
+				if (Array.isArray(output))
+					for (const item of output) image ??= imageOf(item);
+				if (!image)
+					throw new ImageNotGeneratedError("Codex answered without an image");
+				return image;
+			}
+			default:
+				break;
+		}
+	}
+	throw new Error("the Codex stream ended before completion");
+}
+
+async function send(
+	request: CodexImageRequest,
+	signal: AbortSignal,
+	maxBytes: number,
+): Promise<CodexImage> {
+	const fetchImpl = request.fetch ?? fetch;
+	const response = await fetchImpl(CODEX_RESPONSES_URL, {
+		method: "POST",
+		redirect: "error",
+		signal,
+		headers: {
+			authorization: `Bearer ${request.token}`,
+			"chatgpt-account-id": chatGptAccountId(request.token),
+			originator: "pi",
+			"openai-beta": "responses=experimental",
+			accept: "text/event-stream",
+			"content-type": "application/json",
+		},
+		body: JSON.stringify({
+			model: request.model ?? CODEX_IMAGE_MODEL,
+			store: false,
+			stream: true,
+			instructions:
+				"You are generating bitmap image assets. For this request, call the image_generation tool exactly once. Do not answer with only text unless image generation is unavailable.",
+			input: [
+				{
+					role: "user",
+					content: [
+						{ type: "input_text", text: request.prompt },
+						...(request.references ?? []).map((image) => ({
+							type: "input_image",
+							image_url: `data:${image.mimeType};base64,${image.data}`,
+						})),
+					],
+				},
+			],
+			tools: [{ type: "image_generation", output_format: "png" }],
+			tool_choice: "auto",
+			parallel_tool_calls: false,
+			text: { verbosity: "low" },
+		}),
+	});
+	if (!response.ok) {
+		const detail = (await response.text()).slice(0, 300);
+		throw new Error(`Codex answered ${response.status}: ${detail}`);
+	}
+	return parseImageStream(response, signal, maxBytes);
+}
+
+/** `drawCodexImage` with its limits given, for the core's tests. */
+export async function requestCodexImage(
+	request: CodexImageRequest,
+	limits: CodexImageLimits,
+): Promise<CodexImage> {
+	const timeout = AbortSignal.timeout(limits.timeoutMs);
+	const signal = request.signal
+		? AbortSignal.any([request.signal, timeout])
+		: timeout;
+	signal.throwIfAborted();
+	try {
+		return await send(request, signal, limits.maxStreamBytes);
+	} catch (error) {
+		// The abort reaches the caller as its own reason, not as whatever the stream wrapped it in.
+		if (signal.aborted) throw signal.reason;
+		throw error;
+	}
+}
+
+/**
+ * Draws one image through the Codex backend. It aborts with `request.signal`, before the response
+ * and while its stream is read, stops after five minutes, and refuses a stream over 32 MiB.
+ */
+export function drawCodexImage(
+	request: CodexImageRequest,
+): Promise<CodexImage> {
+	return requestCodexImage(request, CODEX_IMAGE_LIMITS);
+}

package/src/core/images/codex-images-plugin.ts

@@ -0,0 +1,76 @@
+// The codex-images plugin: fills the images slot with drawCodexImage.
+
+import { definePlugin } from "../define.ts";
+import { PluginError } from "../errors.ts";
+import type { RoundtablePlugin } from "../plugin.ts";
+import {
+	CODEX_IMAGE_MODEL,
+	CODEX_IMAGES_PROVIDER,
+	type CodexFetch,
+	drawCodexImage,
+} from "./codex-image.ts";
+
+export interface CodexImagesOptions {
+	/** The request function; default the global `fetch`. */
+	fetch?: CodexFetch;
+	/** The model that routes the request; default `CODEX_IMAGE_MODEL`. */
+	model?: string;
+	/**
+	 * What setup does when the openai-codex login is missing or unusable: "throw" (the default)
+	 * stops the host; "warn" logs a warning, and a drawing then fails with the same PluginError.
+	 */
+	onMissingLogin?: "throw" | "warn";
+}
+
+const NO_LOGIN = `the host has no login for ${CODEX_IMAGES_PROVIDER}, the provider that pays for the images. Log in to the ${CODEX_IMAGES_PROVIDER} provider with Pi so the agent directory's auth.json holds it, or remove this plugin.`;
+
+/**
+ * The `codex-images` plugin. It fills `providers.images`, reads the login's token for each drawing
+ * through `context.apiKey`, and aborts a drawing with the turn that asked for it.
+ */
+export function createCodexImages(
+	options: CodexImagesOptions = {},
+): RoundtablePlugin {
+	const {
+		fetch: fetchImpl,
+		model = CODEX_IMAGE_MODEL,
+		onMissingLogin = "throw",
+	} = options;
+	let apiKey: ((provider: string) => Promise<string | undefined>) | undefined;
+	// The login refreshes its token, so each image reads it again instead of keeping the first.
+	const token = async (): Promise<string> => {
+		const value = await apiKey?.(CODEX_IMAGES_PROVIDER);
+		if (!value) throw new PluginError(`plugin codex-images: ${NO_LOGIN}`);
+		return value;
+	};
+	return definePlugin({
+		name: "codex-images",
+		providers: {
+			// The images slot draws an agent's avatar from a prompt and reference pictures.
+			images: async (prompt, references, drawing) =>
+				(
+					await drawCodexImage({
+						token: await token(),
+						prompt,
+						references,
+						model,
+						signal: drawing?.signal,
+						fetch: fetchImpl,
+					})
+				).data,
+		},
+		async setup(context) {
+			apiKey = context.apiKey;
+			try {
+				await token();
+			} catch (error) {
+				if (onMissingLogin !== "warn" || !(error instanceof PluginError))
+					throw error;
+				context.logger.warn(
+					`${NO_LOGIN} Drawing images fails until the login exists.`,
+				);
+			}
+			return {};
+		},
+	});
+}

package/src/core/modules/delegation/web-research-worker.ts

@@ -27,7 +27,7 @@ function webAccessDir(): string {
 		return packageDir("pi-web-access");
 	} catch (error) {
 		throw new PluginError(
-			"the delegation worker loads pi-web-access, which this project does not have installed. It is a peer dependency of pi-roundtable: run `bun add pi-web-access@0.35.0` (or your own build of it, which the worker then uses too).",
+			"the delegation worker loads pi-web-access, which this project does not have installed. It is a peer dependency of pi-roundtable: run `bun add pi-web-access@0.40.0` (or your own build of it, which the worker then uses too).",
 			{ cause: error },
 		);
 	}

package/src/core/ops/alert-throttle.ts

@@ -0,0 +1,81 @@
+/** What `admit` finds: the key is held, its group is full, or the alert may go. */
+export type Admission = "open" | "repeat" | "full";
+
+export interface AlertThrottleOptions {
+	/** How long a key, and a slot of its group, is held. */
+	windowMs: number;
+	/** The most slots one group holds inside the window. */
+	groupCap: number;
+	now: () => number;
+}
+
+/**
+ * The rolling window behind the error reports and the ops alerts: a key is held for a window, and
+ * a group of keys has a fixed number of slots inside it. Nothing here posts or schedules; the
+ * caller asks, then holds and takes a slot in the same synchronous step, so two alerts raised
+ * together for one key go out once.
+ */
+export class AlertThrottle {
+	readonly #windowMs: number;
+	readonly #groupCap: number;
+	readonly #now: () => number;
+	readonly #held = new Map<string, number>();
+	/** The times each group took a slot inside the window, oldest first. */
+	readonly #slots = new Map<string, number[]>();
+
+	constructor(options: AlertThrottleOptions) {
+		this.#windowMs = options.windowMs;
+		this.#groupCap = options.groupCap;
+		this.#now = options.now;
+	}
+
+	/** "repeat" when the key is held, else "full" when the group is (unless `uncapped`), else "open". */
+	admit(key: string, group: string, uncapped = false): Admission {
+		const now = this.#now();
+		this.#pruneKeys(now);
+		if (this.#held.has(key)) return "repeat";
+		if (!uncapped && this.#live(group, now).length >= this.#groupCap)
+			return "full";
+		return "open";
+	}
+
+	/** Holds the key for a window. */
+	hold(key: string): void {
+		this.#held.set(key, this.#now());
+	}
+
+	/** Takes one slot of the group for a window. */
+	slot(group: string): void {
+		const now = this.#now();
+		this.#live(group, now).push(now);
+	}
+
+	/** Gives back the key and the group's newest slot (a post that failed). */
+	release(key: string, group?: string): void {
+		this.#held.delete(key);
+		if (group !== undefined) this.#slots.get(group)?.pop();
+	}
+
+	/** When the group's oldest slot leaves the window; undefined while it has room. */
+	roomAt(group: string): number | undefined {
+		const slots = this.#live(group, this.#now());
+		const oldest = slots[0];
+		return slots.length >= this.#groupCap && oldest !== undefined
+			? oldest + this.#windowMs
+			: undefined;
+	}
+
+	#pruneKeys(now: number): void {
+		for (const [key, at] of this.#held)
+			if (now - at >= this.#windowMs) this.#held.delete(key);
+	}
+
+	/** The group's slots still inside the window; the array is kept. */
+	#live(group: string, now: number): number[] {
+		const live = (this.#slots.get(group) ?? []).filter(
+			(at) => now - at < this.#windowMs,
+		);
+		this.#slots.set(group, live);
+		return live;
+	}
+}

package/src/core/ops/error-reporter.ts

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import type { ScheduledOutcome } from "../contract/channels.ts";
 import type { LogEntry, Logger } from "../log.ts";
 import type { ChannelKey } from "../sessions.ts";
+import { AlertThrottle } from "./alert-throttle.ts";
 
 /** Errors that are expected and never reported, matched against the message and the error's. */
 export const IGNORED_ERRORS: readonly RegExp[] = [];
@@ -9,6 +10,8 @@ export const IGNORED_ERRORS: readonly RegExp[] = [];
 const HOUR_MS = 3_600_000;
 /** Reports, summaries included, per rolling hour. */
 const REPORTS_PER_HOUR = 5;
+/** The throttle group of every report. */
+const ALL = "*";
 /** Errors kept from before the agent server is ready; older ones are dropped and counted. */
 const EARLY_BUFFER = 20;
 const REPORT_LIMIT = 1500;
@@ -70,8 +73,8 @@ export class ErrorReporter {
 	#earlyDropped = 0;
 	/** Report turns started and not yet finished. */
 	#turns = 0;
-	#sent: number[] = [];
-	readonly #lastSent = new Map<string, number>();
+	/** One group for every report: the limit is on the process, not on a kind of error. */
+	readonly #throttle: AlertThrottle;
 	readonly #suppressed = new Map<string, number>();
 	#summaryDue = false;
 
@@ -80,6 +83,11 @@ export class ErrorReporter {
 		this.#app = options.app;
 		this.#ignored = options.ignored ?? IGNORED_ERRORS;
 		this.#now = options.now ?? Date.now;
+		this.#throttle = new AlertThrottle({
+			windowMs: HOUR_MS,
+			groupCap: REPORTS_PER_HOUR,
+			now: this.#now,
+		});
 		this.#setTimer =
 			options.setTimer ??
 			((run, ms) => {
@@ -134,43 +142,38 @@ export class ErrorReporter {
 	#consider(entry: LogEntry): void {
 		const now = this.#now();
 		const key = fingerprint(entry);
-		const last = this.#lastSent.get(key);
-		if (last !== undefined && now - last < HOUR_MS) return;
-		if (!this.#hasRoom(now)) {
+		const admission = this.#throttle.admit(key, ALL);
+		if (admission === "repeat") return;
+		if (admission === "full") {
 			this.#suppressed.set(key, (this.#suppressed.get(key) ?? 0) + 1);
 			this.#scheduleSummary(now);
 			return;
 		}
-		this.#lastSent.set(key, now);
-		this.#sent.push(now);
+		this.#throttle.hold(key);
+		this.#throttle.slot(ALL);
 		void this.#deliver(reportText(entry, this.#app));
 	}
 
-	#hasRoom(now: number): boolean {
-		this.#sent = this.#sent.filter((at) => now - at < HOUR_MS);
-		return this.#sent.length < REPORTS_PER_HOUR;
-	}
-
 	#scheduleSummary(now: number): void {
 		if (this.#summaryDue) return;
 		this.#summaryDue = true;
-		const oldest = this.#sent[0] ?? now;
-		this.#setTimer(() => this.#summarize(), oldest + HOUR_MS - now);
+		const roomAt = this.#throttle.roomAt(ALL) ?? now;
+		this.#setTimer(() => this.#summarize(), roomAt - now);
 	}
 
 	#summarize(): void {
 		this.#summaryDue = false;
 		const now = this.#now();
 		if (this.#suppressed.size === 0) return;
-		if (!this.#hasRoom(now)) {
+		if (this.#throttle.roomAt(ALL) !== undefined) {
 			this.#scheduleSummary(now);
 			return;
 		}
 		const counts = [...this.#suppressed];
 		this.#suppressed.clear();
 		const total = counts.reduce((sum, [, n]) => sum + n, 0);
-		for (const [key] of counts) this.#lastSent.set(key, now);
-		this.#sent.push(now);
+		for (const [key] of counts) this.#throttle.hold(key);
+		this.#throttle.slot(ALL);
 		const list = counts
 			.map(([key, n]) => (n > 1 ? `${key} (×${n})` : key))
 			.join("; ");

package/src/core/ops/ops-alerts.ts

@@ -0,0 +1,132 @@
+import type { Logger } from "../log.ts";
+import { AlertThrottle } from "./alert-throttle.ts";
+
+const DEFAULT_WINDOW_MS = 60 * 60_000;
+const DEFAULT_KIND_CAP = 8;
+
+export interface OpsAlertsOptions {
+	/**
+	 * Posts one alert's text where the people who run the host read it. Resolves true when it was
+	 * posted and false when the sink chose not to (it logs why itself); a throw is a failed post.
+	 * Either way the key and the slot are given back, so the next raise tries again. Absent: alerts are
+	 * only recorded and logged, the key still held so the log has one line per window.
+	 */
+	sink?: (text: string) => Promise<boolean>;
+	logger: Logger;
+	/** What `faults()` calls each kind; a kind not listed is called by itself. */
+	kinds?: Readonly<Record<string, string>>;
+	/** Default one hour. */
+	windowMs?: number;
+	/** The most alerts of one kind posted inside a window, whatever their keys; default 8. */
+	kindCap?: number;
+	now?: () => number;
+}
+
+export interface OpsRaiseOptions {
+	/** A short code (letters, digits, `_`, `:`) shown in `faults()`; never a name or anyone's words. */
+	code?: string;
+	/** News, not a fault: posted at most once per key, not counted against the kind's cap, not listed. */
+	info?: boolean;
+}
+
+/** The last fault of one kind since the start, and how often it came. */
+export interface OpsAlertKind {
+	kind: string;
+	name: string;
+	at: number;
+	code: string | undefined;
+	/** Raised since the start, posted or not. */
+	raised: number;
+	/** Of those, held back because the key or the kind had been raised inside the window. */
+	suppressed: number;
+}
+
+/** The kind of an alert is the word before the first colon of its key. */
+function kindOf(key: string): string {
+	const colon = key.indexOf(":");
+	return colon === -1 ? key : key.slice(0, colon);
+}
+
+/**
+ * Short alerts for the people who run a host. Every alert has a key; its kind is the key's word
+ * before the first colon. A key is posted at most once a window and a kind at most `kindCap` times,
+ * so a fault that touches everything cannot flood the sink; what is held back is counted, never
+ * summed up in a post. An alert is posted when it is raised, not queued. A failed post is logged by
+ * the error's name and never thrown.
+ */
+export class OpsAlerts {
+	readonly #options: OpsAlertsOptions;
+	readonly #throttle: AlertThrottle;
+	readonly #kinds = new Map<string, OpsAlertKind>();
+
+	constructor(options: OpsAlertsOptions) {
+		this.#options = options;
+		this.#throttle = new AlertThrottle({
+			windowMs: options.windowMs ?? DEFAULT_WINDOW_MS,
+			groupCap: options.kindCap ?? DEFAULT_KIND_CAP,
+			now: options.now ?? Date.now,
+		});
+	}
+
+	/** Whether alerts reach a sink. */
+	get posts(): boolean {
+		return this.#options.sink !== undefined;
+	}
+
+	/** The last fault of each kind, newest first; memory only. */
+	faults(): OpsAlertKind[] {
+		return [...this.#kinds.values()].sort((a, b) => b.at - a.at);
+	}
+
+	/** Posts the alert unless its key or its kind is held inside the window; whether it was posted. */
+	async raise(
+		key: string,
+		text: string,
+		options: OpsRaiseOptions = {},
+	): Promise<boolean> {
+		const { sink, logger } = this.#options;
+		const kind = kindOf(key);
+		const info = options.info === true;
+		const admission = this.#throttle.admit(key, kind, info);
+		if (!info) this.#record(kind, options.code, admission !== "open");
+		if (admission !== "open") return false;
+		// Taken before the post, so two alerts raised together for one key post once.
+		this.#throttle.hold(key);
+		if (sink === undefined) {
+			// Nowhere to post: the key stays held so that the log has one line per window, not one per event.
+			logger.warn(
+				{ kind, ...(options.code ? { code: options.code } : {}) },
+				"an ops alert was raised and there is no sink to post it to",
+			);
+			return false;
+		}
+		if (!info) this.#throttle.slot(kind);
+		const undo = () => this.#throttle.release(key, info ? undefined : kind);
+		try {
+			if (await sink(text)) return true;
+			undo();
+			return false;
+		} catch (error) {
+			// Asked again by the next event instead of staying silent for the whole window.
+			undo();
+			logger.warn(
+				{ error: error instanceof Error ? error.name : "unknown" },
+				"an ops alert could not be posted",
+			);
+			return false;
+		}
+	}
+
+	#record(kind: string, code: string | undefined, suppressed: boolean): void {
+		const before = this.#kinds.get(kind);
+		const { kinds, now } = this.#options;
+		this.#kinds.set(kind, {
+			kind,
+			name: kinds && Object.hasOwn(kinds, kind) ? (kinds[kind] ?? kind) : kind,
+			at: (now ?? Date.now)(),
+			code,
+			raised: (before?.raised ?? 0) + 1,
+			suppressed: (before?.suppressed ?? 0) + (suppressed ? 1 : 0),
+		});
+	}
+}