@oh-my-pi/pi-tui 18.7.0 → 18.8.0

package/src/autocomplete.ts

@@ -592,6 +592,22 @@ function buildMidPromptSkillCompletions(commands: CommandEntry[], lowerPrefix: s
 	);
 }
 
+const DIR_CACHE_MAX = 100;
+const DIR_CACHE_EVICT = 50;
+
+/**
+ * Drops the `count` oldest entries once `map` exceeds `max`. Callers delete a
+ * key before re-setting it, so Map insertion order is refresh order.
+ */
+function evictOldest(map: Map<string, unknown>, max: number, count: number): void {
+	if (map.size <= max) return;
+	let remaining = count;
+	for (const key of map.keys()) {
+		if (remaining-- === 0) break;
+		map.delete(key);
+	}
+}
+
 // Combined provider that handles both slash commands and file paths.
 export class CombinedAutocompleteProvider implements AutocompleteProvider {
 	#commands: CommandEntry[];
@@ -601,6 +617,9 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 	// per-directory readdir fast-path for prefix completions. Global fuzzy
 	// discovery continues to use native fuzzyFind + shared scan cache.
 	#dirCache: Map<string, { entries: fs.Dirent[]; timestamp: number }> = new Map();
+	// Whether a scoped fuzzy query's base (`src/` in `@src/foo`) is a directory;
+	// stat'ing it on every keystroke is redundant while the base is unchanged.
+	#scopedBaseCache: Map<string, { isDirectory: boolean; timestamp: number }> = new Map();
 	readonly #DIR_CACHE_TTL = 2000; // 2 seconds
 
 	constructor(
@@ -979,11 +998,21 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 			baseDir = path.join(this.#basePath, displayBase);
 		}
 
-		try {
-			if (!(await fs.promises.stat(baseDir)).isDirectory()) {
-				return null;
+		const now = Date.now();
+		let cachedBase = this.#scopedBaseCache.get(baseDir);
+		if (!cachedBase || now - cachedBase.timestamp >= this.#DIR_CACHE_TTL) {
+			let isDirectory = false;
+			try {
+				isDirectory = (await fs.promises.stat(baseDir)).isDirectory();
+			} catch {
+				// Missing or inaccessible base: not a scope.
 			}
-		} catch {
+			cachedBase = { isDirectory, timestamp: now };
+			this.#scopedBaseCache.delete(baseDir);
+			this.#scopedBaseCache.set(baseDir, cachedBase);
+			evictOldest(this.#scopedBaseCache, DIR_CACHE_MAX, DIR_CACHE_EVICT);
+		}
+		if (!cachedBase.isDirectory) {
 			return null;
 		}
 
@@ -1006,17 +1035,9 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		}
 
 		const entries = await fs.promises.readdir(searchDir, { withFileTypes: true });
+		this.#dirCache.delete(searchDir);
 		this.#dirCache.set(searchDir, { entries, timestamp: now });
-
-		if (this.#dirCache.size > 100) {
-			const sortedKeys = [...this.#dirCache.entries()]
-				.sort((a, b) => a[1].timestamp - b[1].timestamp)
-				.slice(0, 50)
-				.map(([key]) => key);
-			for (const key of sortedKeys) {
-				this.#dirCache.delete(key);
-			}
-		}
+		evictOldest(this.#dirCache, DIR_CACHE_MAX, DIR_CACHE_EVICT);
 
 		return entries;
 	}
@@ -1024,8 +1045,10 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 	invalidateDirCache(dir?: string): void {
 		if (dir) {
 			this.#dirCache.delete(dir);
+			this.#scopedBaseCache.delete(dir);
 		} else {
 			this.#dirCache.clear();
+			this.#scopedBaseCache.clear();
 		}
 	}
 
@@ -1090,26 +1113,29 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 			const entries = await this.#getCachedDirEntries(searchDir);
 			const suggestions: AutocompleteItem[] = [];
 
-			for (const entry of entries) {
-				if (!entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase())) {
-					continue;
-				}
-				// Skip .git directory
-				if (entry.name === ".git") {
-					continue;
-				}
+			const lowerSearchPrefix = searchPrefix.toLowerCase();
+			// Skip .git directory
+			const matched = entries.filter(
+				entry => entry.name !== ".git" && entry.name.toLowerCase().startsWith(lowerSearchPrefix),
+			);
+			// Directory flag per match; symlinks are stat'ed concurrently to learn whether
+			// they point at a directory. `null` drops a broken symlink, a file deleted
+			// between readdir and stat, or a permission error.
+			const directoryFlags = await Promise.all(
+				matched.map(entry =>
+					!entry.isDirectory() && entry.isSymbolicLink()
+						? fs.promises.stat(path.join(searchDir, entry.name)).then(
+								stats => stats.isDirectory(),
+								() => null,
+							)
+						: entry.isDirectory(),
+				),
+			);
 
-				// Check if entry is a directory (or a symlink pointing to a directory)
-				let isDirectory = entry.isDirectory();
-				if (!isDirectory && entry.isSymbolicLink()) {
-					try {
-						const fullPath = path.join(searchDir, entry.name);
-						isDirectory = (await fs.promises.stat(fullPath)).isDirectory();
-					} catch {
-						// Broken symlink, file deleted between readdir and stat, or permission error
-						continue;
-					}
-				}
+			for (let index = 0; index < matched.length; index++) {
+				const isDirectory = directoryFlags[index];
+				if (typeof isDirectory !== "boolean") continue;
+				const entry = matched[index]!;
 
 				let relativePath: string;
 				const name = entry.name;

package/src/chat/assistant-message.ts

@@ -247,16 +247,22 @@ export class AssistantMessageComponent extends Container {
 	#toolImagesByCallId = new Map<string, ImageContent[]>();
 	/**
 	 * Payload keys ({@link imagePayloadKey}) whose Kitty PNG conversion this
-	 * component already awaits, so a re-delivered image neither re-encodes nor
+	 * component is awaiting, so a re-delivered image neither re-encodes nor
 	 * schedules a second {@link updateContent} cascade. The conversions
-	 * themselves are shared process-wide by {@link convertImageToPngShared}.
+	 * themselves live in the bounded process-wide cache behind
+	 * {@link convertImageToPngShared}; an evicted one is redone on the next
+	 * render instead of being pinned here for the session.
 	 */
 	#kittyConversionsAwaited = new Set<string>();
 	/**
-	 * Conversions this component displays, held so a later re-render (theme
-	 * invalidation) still finds them after the bounded shared cache evicts them.
+	 * Conversions the current image children display, by payload key. Rebuilt
+	 * on every full render pass ({@link updateContent}), so a conversion is held
+	 * only while it is on screen — a re-render after the shared cache evicted
+	 * it still finds it — and released once hidden or replaced.
 	 */
-	#kittyConverted = new Map<string, ImageContent>();
+	#kittyDisplayed = new Map<string, ImageContent>();
+	/** The previous pass's {@link #kittyDisplayed}, readable only during a render pass. */
+	#kittyPreviouslyDisplayed: Map<string, ImageContent> | undefined;
 	#showImages = true;
 	#showToolResultImages = true;
 	/** Charts under numeric tables; off for subagent transcripts. */
@@ -1462,22 +1468,24 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	/** A displayable Kitty PNG for a non-PNG `image`: the shared cache, else this component's displayed copy. */
+	#kittyConversion(image: ImageContent): ImageContent | undefined {
+		const cached = cachedPngConversion(image);
+		if (cached) return cached;
+		const key = imagePayloadKey(image);
+		return this.#kittyDisplayed.get(key) ?? this.#kittyPreviouslyDisplayed?.get(key);
+	}
+
 	#convertImagesForKitty(entries: Array<{ image: ImageContent; key: string }>): void {
 		if (TERMINAL.imageProtocol !== ImageProtocol.Kitty) return;
 		for (const { image } of entries) {
-			if (image.mimeType === "image/png") continue;
+			if (image.mimeType === "image/png" || this.#kittyConversion(image)) continue;
 			const key = imagePayloadKey(image);
-			if (this.#kittyConverted.has(key)) continue;
-			const cached = cachedPngConversion(image);
-			if (cached) {
-				this.#kittyConverted.set(key, cached);
-				continue;
-			}
 			if (this.#kittyConversionsAwaited.has(key)) continue;
 			this.#kittyConversionsAwaited.add(key);
 			convertImageToPngShared(image)
-				.then(converted => {
-					this.#kittyConverted.set(key, converted);
+				.then(() => {
+					this.#kittyConversionsAwaited.delete(key);
 					if (this.#lastMessage) {
 						this.updateContent(this.#lastMessage, { transient: this.#lastUpdateTransient });
 					}
@@ -1495,10 +1503,11 @@ export class AssistantMessageComponent extends Container {
 
 		if (withLeadingSpacer) this.#contentContainer.addChild(new Spacer(1));
 		for (const { image, key } of entries) {
-			const displayImage =
-				TERMINAL.imageProtocol === ImageProtocol.Kitty && image.mimeType !== "image/png"
-					? this.#kittyConverted.get(imagePayloadKey(image))
-					: image;
+			let displayImage: ImageContent | undefined = image;
+			if (TERMINAL.imageProtocol === ImageProtocol.Kitty && image.mimeType !== "image/png") {
+				displayImage = this.#kittyConversion(image);
+				if (displayImage) this.#kittyDisplayed.set(imagePayloadKey(image), displayImage);
+			}
 			if (TERMINAL.imageProtocol && displayImage) {
 				this.#contentContainer.addChild(
 					new Image(
@@ -1713,6 +1722,8 @@ export class AssistantMessageComponent extends Container {
 
 		// Clear content container
 		this.#contentContainer.clear();
+		this.#kittyPreviouslyDisplayed = this.#kittyDisplayed;
+		this.#kittyDisplayed = new Map();
 		this.#thinkingExtensions.clear();
 		this.#emergencyText = undefined;
 		this.#thinkingDots = undefined;
@@ -1795,6 +1806,7 @@ export class AssistantMessageComponent extends Container {
 		}
 
 		this.#renderToolImages();
+		this.#kittyPreviouslyDisplayed = undefined;
 		const errorPresentation = resolveAssistantErrorPresentation(message);
 		const hasToolCalls = message.content.some(c => c.type === "toolCall");
 		if (errorPresentation.kind === "compact-recovered") {

package/src/chat/fence-figure.ts

@@ -0,0 +1,80 @@
+/**
+ * A tool call's {@link ToolFigure} drawn under its card, the way assistant
+ * Markdown draws that fence: ```svg as an inline image ({@link SvgFigure}),
+ * redrawn as the body streams; ```mermaid as ASCII art once the body is
+ * final. The card already shows the source, so unlike the assistant's fence
+ * it never falls back to code: {@link FenceFigure.draws} turns down fences
+ * this terminal shows as code, and an svg that does not rasterize stays blank.
+ */
+import type { ImageBudget } from "../components/image";
+import { fencedCode, Markdown } from "../components/markdown";
+import { TERMINAL } from "../terminal-capabilities";
+import { getMarkdownTheme } from "../theme";
+import type { ToolFigure } from "../tools/renderer";
+import type { Component } from "../tui";
+import { SvgFigure, svgFigureRendering } from "./svg-figure";
+
+/** Fence languages a {@link FenceFigure} draws. */
+export type FenceFigureLang = "svg" | "mermaid";
+
+export interface FenceFigureOptions {
+	/** Shared inline-image budget for an svg's rasters. */
+	budget?: ImageBudget;
+	/** The figure's rows changed outside a render: a raster landed. */
+	onChange: () => void;
+}
+
+export class FenceFigure implements Component {
+	/**
+	 * Whether this terminal draws `figure` now: an svg where inline images show
+	 * (`showImages` and a graphics protocol), a closed mermaid fence when
+	 * diagram rendering is on and the source renders.
+	 */
+	static draws(
+		figure: ToolFigure,
+		options: { showImages: boolean },
+	): figure is ToolFigure & { readonly lang: FenceFigureLang } {
+		if (figure.lang === "svg") return options.showImages && TERMINAL.imageProtocol !== null && svgFigureRendering();
+		if (figure.lang !== "mermaid" || !figure.closed) return false;
+		return getMarkdownTheme().resolveMermaidAscii?.(figure.source.trimEnd()) != null;
+	}
+
+	readonly lang: FenceFigureLang;
+	readonly #svg: SvgFigure | undefined;
+	#source = "";
+	/** The mermaid fence as assistant Markdown renders it; rebuilt after a theme change. */
+	#diagram: Markdown | undefined;
+
+	constructor(lang: FenceFigureLang, options: FenceFigureOptions) {
+		this.lang = lang;
+		if (lang === "svg") this.#svg = new SvgFigure({ budget: options.budget, onChange: options.onChange });
+	}
+
+	/** Feed the fence as it stands; its `lang` is this figure's. */
+	update(figure: ToolFigure): void {
+		if (figure.source !== this.#source) this.#diagram = undefined;
+		this.#source = figure.source;
+		this.#svg?.update(figure.source, figure.closed);
+	}
+
+	/** Whether a closed svg's raster is still on its way. */
+	get pending(): boolean {
+		return this.#svg?.pending === true;
+	}
+
+	/** The drawing; no rows while an svg draws, or when it does not. */
+	render(width: number): readonly string[] {
+		if (this.#svg) return this.#svg.render(width);
+		this.#diagram ??= new Markdown(fencedCode("mermaid", this.#source), 1, 0, getMarkdownTheme());
+		return this.#diagram.render(width);
+	}
+
+	invalidate(): void {
+		this.#svg?.invalidate();
+		this.#diagram = undefined;
+	}
+
+	dispose(): void {
+		this.#svg?.dispose();
+	}
+}

package/src/chat/svg-figure.ts

@@ -15,7 +15,7 @@
 import { rasterizeSvg } from "@oh-my-pi/pi-natives";
 import { logger } from "@oh-my-pi/pi-utils";
 import { Image, type ImageBudget, imageMaxColumns } from "../components/image";
-import type { Markdown } from "../components/markdown";
+import { fencedCode, type Markdown } from "../components/markdown";
 import { type CellDimensions, getCellDimensions, getImageDimensions } from "../terminal-capabilities";
 import { getThemeEpoch, type ThemeColor, theme } from "../theme";
 import type { Component } from "../tui";
@@ -355,9 +355,7 @@ export class SvgFigure implements Component {
 		const source = this.#source;
 		if (!this.#options.markdown) return [];
 		if (this.#fallback?.source !== source) {
-			const longest = Math.max(2, ...(source.match(/`+/g) ?? []).map(run => run.length));
-			const fence = "`".repeat(longest + 1);
-			this.#fallback = { source, md: this.#options.markdown(`${fence}svg\n${source.trimEnd()}\n${fence}`) };
+			this.#fallback = { source, md: this.#options.markdown(fencedCode("svg", source)) };
 		}
 		return this.#fallback.md.render(width);
 	}

package/src/chat/tool-execution.ts

@@ -48,6 +48,7 @@ import {
 import type { XdevMountedState } from "../tools/xdev";
 import { isFramedBlockComponent, markFramedBlockComponent, renderStatusLine, WidthAwareText } from "../render/index";
 import { cachedPngConversion, convertImageToPngShared, imagePayloadKey } from "./image-loading";
+import { FenceFigure } from "./fence-figure";
 import { sanitizeWithOptionalSixelPassthrough } from "../render/sixel";
 import { renderDiff } from "../chrome/diff";
 import { type AnimationFrame, trimBlankEdges } from "../chrome/transcript-container";
@@ -301,6 +302,8 @@ export class ToolExecutionComponent extends Container {
 	#multiFileBoxes: (Box | Spacer)[] = []; // Extra boxes for multi-file edit results
 	#imageComponents: Image[] = [];
 	#imageSpacers: Spacer[] = [];
+	/** The renderer's {@link ToolRenderer.figure} drawing; kept across rebuilds while its language is unchanged, so it redraws in place and its raster survives them. */
+	#figure: FenceFigure | undefined;
 	readonly #instanceId = ++toolExecutionInstanceSeq;
 	#toolName: string;
 	#toolLabel: string;
@@ -759,6 +762,11 @@ export class ToolExecutionComponent extends Container {
 		}
 	}
 
+	/** Whether the result's figure still waits for its raster; the transcript holds retirement meanwhile. */
+	isTranscriptBlockPending(): boolean {
+		return this.#toolActivityVisible && this.#figure?.pending === true;
+	}
+
 	/**
 	 * Whether this block is ready to retire as immutable history. Partial
 	 * results, including detached background tasks, remain active and mutable
@@ -941,11 +949,13 @@ export class ToolExecutionComponent extends Container {
 
 	/**
 	 * The native `collapsed` prop: the transcript's expand state, except that a
-	 * call streaming its body (edit, write) stays open until it settles, then
+	 * view that asks to be {@link NativeToolView.open} never starts folded, and
+	 * a call streaming its body (edit, write) stays open until it settles, then
 	 * folds like a finished thought. The user's own toggle still wins meanwhile:
 	 * the terminal keeps local collapse state until this prop changes.
 	 */
-	#nativeCollapsed(status: TspCardStatus): boolean {
+	#nativeCollapsed(status: TspCardStatus, view: NativeToolView): boolean {
+		if (view.open) return false;
 		const live = status === "pending" || status === "running";
 		return !this.#expanded && !(live && streamsBody(this.#toolName));
 	}
@@ -1008,7 +1018,7 @@ export class ToolExecutionComponent extends Container {
 				intent: typeof intent === "string" && intent ? plainText(intent) : undefined,
 				frame: inline ? "inline" : "card",
 				collapsible: hasBody,
-				collapsed: hasBody ? this.#nativeCollapsed(status) : undefined,
+				collapsed: hasBody ? this.#nativeCollapsed(status, view) : undefined,
 				preview: hasBody ? (preview === "auto" ? { lines: DEFAULT_TERMINAL_PREVIEW_LINES } : preview) : undefined,
 				tools: view.tools,
 				tone: view.tone,
@@ -1076,7 +1086,7 @@ export class ToolExecutionComponent extends Container {
 				tone: view.tone ?? NATIVE_STATUS_TONE[status],
 				status,
 				collapsible: hasBody,
-				collapsed: hasBody ? this.#nativeCollapsed(status) : undefined,
+				collapsed: hasBody ? this.#nativeCollapsed(status, view) : undefined,
 				preview: hasBody ? cardPreview(view.preview) : undefined,
 			},
 			children,
@@ -1132,6 +1142,7 @@ export class ToolExecutionComponent extends Container {
 				body: [...(callView.body ?? []), ...(resultView.body ?? [])],
 				tone: resultView.tone ?? callView.tone,
 				preview: resultView.preview ?? callView.preview,
+				open: resultView.open ?? callView.open,
 				inline: resultView.inline ?? callView.inline,
 				tools: resultView.tools ?? callView.tools,
 			};
@@ -1611,6 +1622,7 @@ export class ToolExecutionComponent extends Container {
 			this.removeChild(spacer);
 		}
 		this.#imageSpacers = [];
+		this.#syncFigure();
 
 		if (this.#result) {
 			const imageBlocks = this.#getAllImageBlocks();
@@ -1654,6 +1666,43 @@ export class ToolExecutionComponent extends Container {
 		this.#renderedImageCount = this.#imageComponents.length;
 	}
 
+	/**
+	 * Mount the built-in renderer's figure under the card and feed it the fence
+	 * as it stands: the mounted one stays while its language is unchanged, so it
+	 * redraws in place as the args stream.
+	 */
+	#syncFigure(): void {
+		const result = this.#result;
+		const renderer = this.#tool?.renderCall || this.#tool?.renderResult ? undefined : this.#renderer;
+		const fence =
+			this.#isBenignSkip() || isNativeRendering()
+				? undefined
+				: renderer?.figure?.(
+						this.#args,
+						result && { content: result.content, details: result.details, isError: result.isError },
+						this.#renderState,
+					);
+		const drawable = fence !== undefined && FenceFigure.draws(fence, { showImages: this.#showImages });
+		let figure = this.#figure;
+		if (figure && (!drawable || figure.lang !== fence.lang)) {
+			this.removeChild(figure);
+			figure.dispose();
+			figure = this.#figure = undefined;
+		}
+		if (!drawable) return;
+		if (!figure) {
+			figure = this.#figure = new FenceFigure(fence.lang, {
+				budget: this.#ui.imageBudget,
+				onChange: () => {
+					this.#blockVersion++;
+					this.#ui.requestRender();
+				},
+			});
+			this.addChild(figure);
+		}
+		figure.update(fence);
+	}
+
 	#getCallArgsForRender(): unknown {
 		const renderArgs = this.#args;
 		if (!isEditLikeToolName(this.#toolName)) {

package/src/components/editor.ts

@@ -14,7 +14,7 @@ import { BracketedPasteHandler, decodeReencodedPasteControls } from "../brackete
 import { canonicalKeyId, getKeybindings, type KeybindingsManager } from "../keybindings";
 import { extractPrintableText, matchesKey, parseKey } from "../keys";
 import { KillRing } from "../kill-ring";
-import type { TspEditorDecoration, TspEditorProps, TspTone } from "@oh-my-pi/pi-wire";
+import type { TspEditorDecoration, TspEditorProps, TspText, TspTone } from "@oh-my-pi/pi-wire";
 import { col, node } from "../native/describe";
 import { sameItems, sameProps } from "../native/memo";
 import { plainText } from "../native/spans";
@@ -625,8 +625,11 @@ export class Editor implements Component, Focusable {
 	 * dialog's text field; only the prompt composer claims `omp.editor`).
 	 */
 	describeLayout: ((input: NativeNode, cx: DescribeContext) => NativeEditorLayout) | undefined;
-	/** TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints. */
-	describePlaceholder: (() => string) | undefined;
+	/**
+	 * TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints.
+	 * Return a stable value (the same spans array) while it is unchanged: the editor node is reused by identity.
+	 */
+	describePlaceholder: (() => TspText) | undefined;
 	#promptGutter: string | undefined;
 	/** Bumped by {@link invalidate}: host-side decoration inputs (spelling results, settings) changed. */
 	#nativeGeneration = 0;
@@ -713,6 +716,7 @@ export class Editor implements Component, Focusable {
 
 	// Host-registered atomic chip tokens: exact buffer label → expansion emitted on submit.
 	#atoms: Map<string, string> = new Map();
+	#atomsRevision = 0;
 
 	/** Optional pattern matching atomic placeholder tokens (e.g. `[Image #1, 800x600]` or
 	 *  `[Paste #2, +30 lines]`) that the editor treats as indivisible: a backspace or forward-delete
@@ -1025,6 +1029,7 @@ export class Editor implements Component, Focusable {
 		this.#pastes.clear();
 		this.#pasteCounter = 0;
 		this.#atoms.clear();
+		this.#atomsRevision++;
 		this.#historyDraftActive = false;
 	}
 
@@ -1064,6 +1069,7 @@ export class Editor implements Component, Focusable {
 		if (entry?.draft || this.#historyDraftActive) {
 			this.#pastes = new Map(entry?.draft?.pastes);
 			this.#atoms = new Map(entry?.draft?.atoms);
+			this.#atomsRevision++;
 			this.#pasteCounter = entry?.draft?.pasteCounter ?? 0;
 			this.restoreHistoryState(entry?.draft?.restore);
 			this.#historyDraftActive = entry?.draft !== undefined;
@@ -2661,6 +2667,11 @@ export class Editor implements Component, Focusable {
 		return this.#textRevision;
 	}
 
+	/** Monotonic atom-table revision for render caches: advances whenever {@link atoms} is mutated or replaced. */
+	get atomsRevision(): number {
+		return this.#atomsRevision;
+	}
+
 	#notifyChange(text?: string): void {
 		this.#textRevision++;
 		this.onChange?.(text ?? this.getText());
@@ -2699,6 +2710,7 @@ export class Editor implements Component, Focusable {
 	 *  it — for hosts that re-collapse restored draft text via {@link setText}. */
 	registerAtom(label: string, expansion: string): void {
 		this.#atoms.set(label, expansion);
+		this.#atomsRevision++;
 	}
 
 	/** Insert `label` (plus a trailing space) at the cursor and register it as an atom expanding
@@ -2735,6 +2747,7 @@ export class Editor implements Component, Focusable {
 	/** Drop every registered atom expansion (draft cleared or replaced by the host). */
 	clearAtoms(): void {
 		this.#atoms.clear();
+		this.#atomsRevision++;
 	}
 
 	/**