@code-yeongyu/senpi 2026.9.23-5 → 2026.9.24-2

package/node_modules/@code-yeongyu/senpi-codemode/CHANGELOG.md

@@ -12,6 +12,38 @@
 
 ### Removed
 
+## [2026.9.24-2] - 2026-09-24
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Dense JavaScript eval cells are previewed with Bun's built-in printer when the TUI runs on Bun: one statement per line with normal spacing, while every string, number, template, name, and comment keeps its exact text. On Node, JavaScript cells are shown as sent. Dense Python cells are formatted by your own Python (ruff or black when installed, otherwise the standard library for comment-free cells), appearing formatted a moment after the cell is shown. Anything that cannot be shown faithfully is shown as sent, and the code that runs is unchanged. ([#2076](https://github.com/code-yeongyu/senpi/issues/2076))
+
+### Fixed
+
+- The `eval` tool's run contract is no longer a trap: the schema descriptions now mark `language` and `code` as required for run, and a run call missing either fails with an error that names the enabled languages or the missing cell body instead of a bare "eval run requires language".
+- An omitted `eval` `language` now names only the kernels enabled in this session (`js` and `py` by default), instead of advertising gated Ruby and Julia.
+
+### Removed
+
+## [2026.9.24] - 2026-09-24
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Eval code previews no longer show code that means something different from the cell: breaking a long JavaScript array keeps the parentheses around each element, and a Python formatter result that changes string or docstring text (or is not valid Python) is discarded so the cell is shown as sent. ([#2076](https://github.com/code-yeongyu/senpi/issues/2076))
+- Python eval previews give your ruff most of the 5-second formatting budget instead of a fixed 4 seconds, so a slow first ruff start still formats the cell. ([#2076](https://github.com/code-yeongyu/senpi/issues/2076))
+
+### Removed
+
 ## [2026.9.23-5] - 2026-09-23
 
 ### Breaking Changes

package/node_modules/@code-yeongyu/senpi-codemode/README.md

@@ -207,15 +207,19 @@ that implements it. Reset only removes kernel variables: save `pool_id` and use
 arguments in other languages). An open pool's adapter can be recreated with the
 same name/spec/mode; no worker state is reconstructed in the prelude.
 
-## Required summary
+## Required run fields
 
-Every `eval` run call MUST include a `summary` — one line in the language the
+Every `eval` run call MUST include a `language` (the kernel that runs the
+cell, one of the enabled languages), the `code` cell body, and a `summary` —
+one line in the language the
 user writes in: a progress update saying what the agent is doing and why, not
 a label for the code. The
 summary is shown in the TUI while the cell runs and in the finished result, so
 you can always tell what is running and why. It has no length limit; a
-collapsed block shows its first three lines. A run request without a
-`summary` fails with a teaching error.
+collapsed block shows its first three lines. The schema marks all three
+optional only because the control actions (`peek`, `stop`, `list`) share it; a
+run request missing any of them fails with a teaching error that names what to
+add.
 
 ## Detached cells
 

package/node_modules/@code-yeongyu/senpi-codemode/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.23-5",
+	"version": "2026.9.24-2",
 	"private": true,
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
@@ -31,14 +31,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.23-5",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.24-2",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.23-5"
+		"@code-yeongyu/senpi": "2026.9.24-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.23-5"
+		"@code-yeongyu/senpi": "2026.9.24-2"
 	},
 	"keywords": [
 		"senpi",

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/AGENTS.md

@@ -14,6 +14,7 @@ anchor most suites).
 | Cell execution, settlement | `cell-handler.ts`, `cell-execution.ts`, `cell-runtime.ts` |
 | Detached cells | `detached-cell-manager.ts` + `detached-cell-{state,snapshot,notification}.ts`, `detached-notification-queue.ts`, `detached-eval-result.ts` |
 | Call/result rendering | `render.ts`, `runtime-label.ts`, `json-tree.ts`, `image.ts`, `tool-widgets.ts` |
+| Code preview layout | `code-preview.ts` -> `display-code.ts` (JS: `display-js*.ts` Bun-only masked `Bun.Transpiler`; Python: `display-python*.ts` user interpreter, background + repaint) |
 | Status events, execution events | `status-events.ts`, `eval-execution-event.ts` |
 | Interrupt, capture | `interrupt-note.ts`, `call-capture.ts` |
 

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/code-preview.ts

@@ -0,0 +1,31 @@
+import { highlightCode, type Theme } from "@code-yeongyu/senpi";
+import { displayCode } from "./display-code.ts";
+import type { EvalLanguage } from "./types.ts";
+
+function languageForHighlighter(language: EvalLanguage): "python" | "javascript" | "ruby" | "julia" {
+	switch (language) {
+		case "py":
+			return "python";
+		case "js":
+			return "javascript";
+		case "rb":
+			return "ruby";
+		case "jl":
+			return "julia";
+		default: {
+			const unreachable: never = language;
+			throw new TypeError(`Unhandled eval language: ${String(unreachable)}`);
+		}
+	}
+}
+
+export function highlightedCode(
+	code: string,
+	language: EvalLanguage,
+	theme: Theme | undefined,
+	onFormatted?: () => void,
+): string {
+	const normalizedCode = code.trim().length > 0 ? code : "...";
+	const lines = highlightCode(displayCode(normalizedCode, language, onFormatted), languageForHighlighter(language));
+	return (theme === undefined ? lines.map((line) => line.replace(/\u001b\[[0-9;]*m/gu, "")) : lines).join("\n");
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/display-code.ts

@@ -1,145 +1,48 @@
-import { parse } from "@babel/parser";
+import { bunJsPrinter, prettifyJs } from "./display-js.ts";
+import { pythonDisplay } from "./display-python.ts";
 import type { EvalLanguage } from "./types.ts";
 
-// Display-only: models often send a JS cell as one long line of joined statements. The preview
-// breaks it at statement, block, and long-array boundaries and keeps every source token and
-// comment verbatim. The tool arguments are never touched (senpi#1472).
+// Display-only (senpi#2050, senpi#2076): models often send a cell as one long line of joined
+// statements. The tool arguments are never touched (senpi#1472).
 const DENSE_LINE_LENGTH = 100;
-const ARRAY_BREAK_LENGTH = 60;
-const INDENT = "  ";
 const CACHE_LIMIT = 64;
 
-type SourceNode = { readonly type: string; readonly start: number; readonly end: number };
-
-// A whitespace/comma/comment region between two tokens that becomes a line break.
-type Gap = {
-	readonly start: number;
-	readonly end: number;
-	readonly contentDepth: number;
-	readonly nextDepth: number;
-};
-
-const cache = new Map<string, string>();
-
-function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function sourceNode(value: unknown): SourceNode | undefined {
-	if (!isRecord(value)) return undefined;
-	const { type, start, end } = value;
-	if (typeof type !== "string" || typeof start !== "number" || typeof end !== "number") return undefined;
-	return { type, start, end };
-}
-
-function sourceNodes(value: unknown): SourceNode[] {
-	if (!Array.isArray(value)) return [];
-	return value.flatMap((item) => sourceNode(item) ?? []);
-}
+const jsCache = new Map<string, string>();
 
 function isDense(code: string): boolean {
 	return code.split("\n").some((line) => line.length > DENSE_LINE_LENGTH);
 }
 
-function parseProgram(code: string): unknown {
-	try {
-		return parse(code, {
-			sourceType: "module",
-			allowAwaitOutsideFunction: true,
-			allowReturnOutsideFunction: true,
-			allowImportExportEverywhere: true,
-		}).program;
-	} catch (error) {
-		if (error instanceof SyntaxError) return undefined;
-		throw error;
-	}
-}
-
-function siblingGaps(children: readonly SourceNode[], depth: number): Gap[] {
-	return children.slice(1).map((child, index) => ({
-		start: children[index]?.end ?? child.start,
-		end: child.start,
-		contentDepth: depth,
-		nextDepth: depth,
-	}));
-}
-
-// Gaps for a bracketed container whose children move onto their own indented lines.
-function containerGaps(container: SourceNode, children: readonly SourceNode[], depth: number): Gap[] {
-	const first = children[0];
-	const last = children.at(-1);
-	if (first === undefined || last === undefined) return [];
-	const inner = depth + 1;
-	return [
-		{ start: container.start + 1, end: first.start, contentDepth: inner, nextDepth: inner },
-		...siblingGaps(children, inner),
-		{ start: last.end, end: container.end - 1, contentDepth: inner, nextDepth: depth },
-	];
-}
-
-function breakableChildren(node: SourceNode, record: Readonly<Record<string, unknown>>, code: string) {
-	if (node.type === "BlockStatement" || node.type === "StaticBlock") return sourceNodes(record.body);
-	if (node.type !== "ArrayExpression") return undefined;
-	const elements = sourceNodes(record.elements);
-	const text = code.slice(node.start, node.end);
-	if (elements.length < 2 || text.length <= ARRAY_BREAK_LENGTH || text.includes("\n")) return undefined;
-	return elements;
-}
-
-function collectGaps(value: unknown, depth: number, code: string, gaps: Gap[]): void {
-	if (Array.isArray(value)) {
-		for (const item of value) collectGaps(item, depth, code, gaps);
-		return;
-	}
-	if (!isRecord(value)) return;
-	const node = sourceNode(value);
-	const children = node === undefined ? undefined : breakableChildren(node, value, code);
-	const breaks = node !== undefined && children !== undefined && children.length > 0;
-	if (breaks) gaps.push(...containerGaps(node, children, depth));
-	for (const [key, child] of Object.entries(value)) {
-		if (key === "loc" || key === "extra" || key.endsWith("Comments")) continue;
-		if (child !== null && typeof child === "object") collectGaps(child, breaks ? depth + 1 : depth, code, gaps);
-	}
-}
-
-function renderGap(text: string, gap: Gap): string {
-	let rest = text.trim();
-	let attached = "";
-	if (rest.startsWith(",") || rest.startsWith(";")) {
-		attached = rest.slice(0, 1);
-		rest = rest.slice(1).trim();
-	}
-	const contentIndent = INDENT.repeat(gap.contentDepth);
-	const content = rest
-		.split("\n")
-		.map((line) => line.trim())
-		.filter((line) => line.length > 0)
-		.map((line) => `\n${contentIndent}${line}`)
-		.join("");
-	return `${attached}${content}\n${INDENT.repeat(gap.nextDepth)}`;
+function displayJs(code: string): string {
+	const print = bunJsPrinter();
+	if (print === null) return code;
+	const cached = jsCache.get(code);
+	if (cached !== undefined) return cached;
+	const formatted = prettifyJs(code, print) ?? code;
+	if (jsCache.size >= CACHE_LIMIT) jsCache.delete(jsCache.keys().next().value ?? "");
+	jsCache.set(code, formatted);
+	return formatted;
 }
 
-function reformat(code: string): string {
-	const program = parseProgram(code);
-	if (!isRecord(program)) return code;
-	const gaps = siblingGaps(sourceNodes(program.body), 0);
-	collectGaps(program.body, 0, code, gaps);
-	gaps.sort((left, right) => left.start - right.start);
-	let output = "";
-	let cursor = 0;
-	for (const gap of gaps) {
-		output += code.slice(cursor, gap.start) + renderGap(code.slice(gap.start, gap.end), gap);
-		cursor = gap.end;
+/**
+ * The preview text for a cell. Dense JavaScript is laid out by the built-in Bun printer only when
+ * the renderer runs on Bun; dense Python is formatted by the user's own interpreter in the
+ * background, so the first render shows the cell as sent and `onFormatted` asks for a repaint.
+ * Pass `onFormatted` only for complete code; without it no formatter process starts.
+ */
+export function displayCode(code: string, language: EvalLanguage, onFormatted?: () => void): string {
+	if (!isDense(code)) return code;
+	switch (language) {
+		case "js":
+			return displayJs(code);
+		case "py":
+			return pythonDisplay.display(code, onFormatted);
+		case "rb":
+		case "jl":
+			return code;
+		default: {
+			const unreachable: never = language;
+			return unreachable;
+		}
 	}
-	return (output + code.slice(cursor)).trim();
-}
-
-export function displayCode(code: string, language: EvalLanguage): string {
-	if (language !== "js" || !isDense(code)) return code;
-	const cached = cache.get(code);
-	if (cached !== undefined) return cached;
-	const formatted = reformat(code);
-	if (cache.size >= CACHE_LIMIT) cache.delete(cache.keys().next().value ?? "");
-	cache.set(code, formatted);
-	return formatted;
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/display-js-ast.ts

@@ -0,0 +1,65 @@
+import { parse } from "@babel/parser";
+
+export type SourceNode = {
+	readonly type: string;
+	readonly start: number;
+	readonly end: number;
+	readonly record: Readonly<Record<string, unknown>>;
+};
+
+export type Edit = { readonly start: number; readonly end: number; readonly text: string };
+
+export function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function sourceNode(value: unknown): SourceNode | undefined {
+	if (!isRecord(value)) return undefined;
+	const { type, start, end } = value;
+	if (typeof type !== "string" || typeof start !== "number" || typeof end !== "number") return undefined;
+	return { type, start, end, record: value };
+}
+
+export function sourceNodes(value: unknown): SourceNode[] {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => sourceNode(item) ?? []);
+}
+
+export function childNodes(node: SourceNode): SourceNode[] {
+	return Object.entries(node.record).flatMap(([key, value]) => {
+		if (key === "loc" || key === "extra" || key.endsWith("Comments")) return [];
+		return Array.isArray(value) ? sourceNodes(value) : (sourceNode(value) ?? []);
+	});
+}
+
+/** Parses a cell the way the js kernel accepts it: module syntax, top-level `await` and `return`. */
+export function parseFile(code: string): SourceNode | undefined {
+	try {
+		return sourceNode(
+			parse(code, {
+				sourceType: "module",
+				allowAwaitOutsideFunction: true,
+				allowReturnOutsideFunction: true,
+				allowImportExportEverywhere: true,
+			}),
+		);
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+export function programOf(file: SourceNode | undefined): SourceNode | undefined {
+	return file === undefined ? undefined : sourceNode(file.record.program);
+}
+
+export function applyEdits(code: string, edits: readonly Edit[]): string {
+	const sorted = [...edits].sort((left, right) => left.start - right.start);
+	let output = "";
+	let cursor = 0;
+	for (const edit of sorted) {
+		output += code.slice(cursor, edit.start) + edit.text;
+		cursor = edit.end;
+	}
+	return output + code.slice(cursor);
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/display-js-layout.ts

@@ -0,0 +1,90 @@
+import {
+	applyEdits,
+	childNodes,
+	type Edit,
+	parseFile,
+	programOf,
+	type SourceNode,
+	sourceNode,
+	sourceNodes,
+} from "./display-js-ast.ts";
+
+const ARRAY_BREAK_LENGTH = 60;
+const INDENT = "  ";
+
+function forHeaderEdits(code: string, node: SourceNode, edits: Edit[]): void {
+	if (node.type === "ForStatement") {
+		const body = sourceNode(node.record.body);
+		const open = code.indexOf("(", node.start);
+		const close = body === undefined ? -1 : code.lastIndexOf(")", body.start);
+		if (open >= 0 && close > open) {
+			const parts = ["init", "test", "update"].map((key) => {
+				const part = sourceNode(node.record[key]);
+				return part === undefined ? "" : code.slice(part.start, part.end);
+			});
+			const header = parts.every((part) => part.length === 0) ? ";;" : parts.join("; ");
+			if (code.slice(open + 1, close) !== header) edits.push({ start: open + 1, end: close, text: header });
+		}
+	}
+	for (const child of childNodes(node)) forHeaderEdits(code, child, edits);
+}
+
+function lineIndent(code: string, position: number): string {
+	const line = code.slice(code.lastIndexOf("\n", position - 1) + 1);
+	return line.slice(0, line.length - line.trimStart().length);
+}
+
+// Only whitespace in a gap is rewritten: a gap between babel element nodes can also hold the
+// parentheses of a parenthesized element, and those must stay (senpi#2076).
+function gapTokens(code: string, start: number, end: number): string {
+	return code.slice(start, end).replace(/\s+/gu, "");
+}
+
+// A one-line array longer than ARRAY_BREAK_LENGTH puts each element on its own line (senpi#2050).
+// `forcedIndent` is the indentation of an element line an enclosing break just created.
+function arrayEdits(code: string, node: SourceNode, forcedIndent: string | undefined, edits: Edit[]): void {
+	const rawElements = node.record.elements;
+	const elements = sourceNodes(rawElements);
+	const first = elements[0];
+	const last = elements.at(-1);
+	const text = code.slice(node.start, node.end);
+	const breaks =
+		node.type === "ArrayExpression" &&
+		Array.isArray(rawElements) &&
+		elements.length === rawElements.length &&
+		elements.length >= 2 &&
+		text.length > ARRAY_BREAK_LENGTH &&
+		!text.includes("\n");
+	if (!breaks || first === undefined || last === undefined) {
+		for (const child of childNodes(node)) arrayEdits(code, child, forcedIndent, edits);
+		return;
+	}
+	const base = forcedIndent ?? lineIndent(code, node.start);
+	const inner = `${base}${INDENT}`;
+	edits.push({
+		start: node.start + 1,
+		end: first.start,
+		text: `\n${inner}${gapTokens(code, node.start + 1, first.start)}`,
+	});
+	elements.slice(1).forEach((element, index) => {
+		const start = elements[index]?.end ?? element.start;
+		const [before = "", after = ""] = gapTokens(code, start, element.start).split(",");
+		edits.push({ start, end: element.start, text: `${before},\n${inner}${after}` });
+	});
+	edits.push({ start: last.end, end: node.end - 1, text: `${gapTokens(code, last.end, node.end - 1)}\n${base}` });
+	for (const element of elements) arrayEdits(code, element, inner, edits);
+}
+
+/** Printer fix-ups on the restored cell: `for (a; b; c)` headers, then long-array breaks. */
+export function finishLayout(code: string): string | undefined {
+	const program = programOf(parseFile(code));
+	if (program === undefined) return undefined;
+	const headerEdits: Edit[] = [];
+	forHeaderEdits(code, program, headerEdits);
+	const withHeaders = applyEdits(code, headerEdits);
+	const reparsed = programOf(parseFile(withHeaders));
+	if (reparsed === undefined) return undefined;
+	const breaks: Edit[] = [];
+	arrayEdits(withHeaders, reparsed, undefined, breaks);
+	return applyEdits(withHeaders, breaks);
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/display-js-mask.ts

@@ -0,0 +1,178 @@
+import { applyEdits, childNodes, type Edit, type SourceNode, sourceNode } from "./display-js-ast.ts";
+
+const LITERAL_TYPES = new Set([
+	"StringLiteral",
+	"NumericLiteral",
+	"BigIntLiteral",
+	"RegExpLiteral",
+	"BooleanLiteral",
+	"NullLiteral",
+	"TemplateLiteral",
+	"TaggedTemplateExpression",
+	"DirectiveLiteral",
+]);
+// One placeholder per spelling, so `break outer` still resolves against `outer:` for Bun's parser.
+const NAME_TYPES = new Set(["Identifier", "PrivateName"]);
+// The grammar requires a string literal under these parents (module specifiers, attributes, and
+// string export names), so the placeholder stays a string there.
+const STRING_SLOT_PARENTS = new Set([
+	"ImportDeclaration",
+	"ExportAllDeclaration",
+	"ExportNamedDeclaration",
+	"ImportAttribute",
+	"ImportSpecifier",
+	"ExportSpecifier",
+	"ExportNamespaceSpecifier",
+	"ExportDefaultSpecifier",
+]);
+const STATEMENT_LISTS = new Set(["Program", "BlockStatement", "StaticBlock", "ClassBody", "SwitchCase"]);
+
+type SourceComment = { readonly start: number; readonly end: number; readonly line: boolean };
+type MaskedRange = SourceNode & { readonly stringSlot: boolean };
+export type Placeholder = { readonly id: string; readonly raw: string; readonly expected: number };
+export type CommentPlaceholder = Placeholder & { readonly trailing: boolean };
+export type Mask = {
+	readonly prefix: string;
+	readonly masked: string;
+	readonly values: ReadonlyMap<string, Placeholder>;
+	readonly comments: readonly CommentPlaceholder[];
+};
+
+function fileComments(file: SourceNode): SourceComment[] | undefined {
+	const comments = file.record.comments;
+	if (!Array.isArray(comments)) return undefined;
+	const parsed: SourceComment[] = [];
+	for (const comment of comments) {
+		const node = sourceNode(comment);
+		if (node === undefined) return undefined;
+		parsed.push({ start: node.start, end: node.end, line: node.type === "CommentLine" });
+	}
+	return parsed;
+}
+
+function innermostContainer(node: SourceNode, start: number, end: number): SourceNode {
+	for (const child of childNodes(node)) {
+		if (child.start <= start && end <= child.end) return innermostContainer(child, start, end);
+	}
+	return node;
+}
+
+function sitsInStatementList(code: string, program: SourceNode, comment: SourceComment): boolean {
+	const container = innermostContainer(program, comment.start, comment.end);
+	if (!STATEMENT_LISTS.has(container.type)) return false;
+	if (container.type !== "SwitchCase") return true;
+	const test = sourceNode(container.record.test);
+	const colon = code.indexOf(":", test?.end ?? container.start);
+	return colon >= 0 && colon < comment.start;
+}
+
+function followsCodeOnItsLine(code: string, comment: SourceComment, comments: readonly SourceComment[]): boolean {
+	let index = comment.start - 1;
+	while (index >= 0 && code[index] !== "\n") {
+		const position = index;
+		const covering = comments.find((other) => other.start <= position && position < other.end);
+		if (covering !== undefined) {
+			index = covering.start - 1;
+			continue;
+		}
+		if (code[index] !== " " && code[index] !== "\t") return true;
+		index -= 1;
+	}
+	return false;
+}
+
+function placeholderPrefix(code: string): string {
+	let prefix = "$display";
+	while (code.includes(prefix)) prefix = `${prefix}_`;
+	return prefix;
+}
+
+function collectRanges(node: SourceNode, parent: SourceNode | undefined, ranges: Map<string, MaskedRange>): void {
+	if (LITERAL_TYPES.has(node.type) || NAME_TYPES.has(node.type)) {
+		const stringSlot = node.type === "StringLiteral" && parent !== undefined && STRING_SLOT_PARENTS.has(parent.type);
+		const key = `${node.start}:${node.end}`;
+		if (!ranges.has(key)) ranges.set(key, { ...node, stringSlot });
+		return;
+	}
+	for (const child of childNodes(node)) collectRanges(child, node, ranges);
+}
+
+/**
+ * Swaps every literal, name, and statement-level comment for an opaque placeholder so a printer
+ * can only move them. Undefined when a comment sits where a placeholder statement cannot stand.
+ */
+export function maskSource(code: string, file: SourceNode): Mask | undefined {
+	const program = sourceNode(file.record.program);
+	const comments = fileComments(file);
+	if (program === undefined || comments === undefined) return undefined;
+	const ranges = new Map<string, MaskedRange>();
+	collectRanges(program, undefined, ranges);
+	const prefix = placeholderPrefix(code);
+	const edits: Edit[] = [];
+	const values = new Map<string, Placeholder>();
+	const nameIds = new Map<string, string>();
+	let counter = 0;
+	for (const range of ranges.values()) {
+		const raw = code.slice(range.start, range.end);
+		const reused = NAME_TYPES.has(range.type) ? nameIds.get(raw) : undefined;
+		const id = reused ?? `${prefix}${counter++}`;
+		if (NAME_TYPES.has(range.type)) nameIds.set(raw, id);
+		values.set(id, { id, raw, expected: (values.get(id)?.expected ?? 0) + 1 });
+		edits.push({ start: range.start, end: range.end, text: range.stringSlot ? `"${id}"` : id });
+	}
+	const masked: CommentPlaceholder[] = [];
+	for (const comment of comments) {
+		if (!sitsInStatementList(code, program, comment)) return undefined;
+		const id = `${prefix}${counter++}`;
+		const trailing = comment.line && followsCodeOnItsLine(code, comment, comments);
+		masked.push({ id, raw: code.slice(comment.start, comment.end), expected: 1, trailing });
+		edits.push({ start: comment.start, end: comment.end, text: `\n${id};\n` });
+	}
+	return { prefix, masked: applyEdits(code, edits), values, comments: masked };
+}
+
+export function restoreComments(printed: string, comments: readonly CommentPlaceholder[]): string | undefined {
+	const lines = printed.split("\n");
+	for (const comment of comments) {
+		const matches = lines.flatMap((line, index) => (line.trim() === `${comment.id};` ? [index] : []));
+		const index = matches[0];
+		if (matches.length !== 1 || index === undefined) return undefined;
+		const line = lines[index] ?? "";
+		let previous = index - 1;
+		while (previous >= 0 && (lines[previous] ?? "").trim().length === 0) previous -= 1;
+		const target = lines[previous];
+		if (comment.trailing && target !== undefined && !target.includes("//")) {
+			lines[previous] = `${target} ${comment.raw}`;
+			lines.splice(index, 1);
+			continue;
+		}
+		lines[index] = `${line.slice(0, line.length - line.trimStart().length)}${comment.raw}`;
+	}
+	return lines.join("\n");
+}
+
+function escapeRegExp(text: string): string {
+	return text.replace(/[\\^$.*+?()[\]{}|]/gu, "\\$&");
+}
+
+export function restoreValues(printed: string, mask: Mask): string | undefined {
+	const id = `${escapeRegExp(mask.prefix)}\\d+`;
+	const pattern = new RegExp(`"(${id})"|'(${id})'|(?<![\\w$])(${id})(?![\\w$])`, "gu");
+	const counts = new Map<string, number>();
+	let unknown = false;
+	const restored = printed.replace(pattern, (match, double: unknown, single: unknown, bare: unknown) => {
+		const key = [double, single, bare].find((group): group is string => typeof group === "string") ?? "";
+		const value = mask.values.get(key);
+		if (value === undefined) {
+			unknown = true;
+			return match;
+		}
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+		return value.raw;
+	});
+	if (unknown) return undefined;
+	for (const value of mask.values.values()) {
+		if (counts.get(value.id) !== value.expected) return undefined;
+	}
+	return restored;
+}