@code-yeongyu/senpi-codemode 2026.9.23 → 2026.9.24-3

package/CHANGELOG.md

@@ -12,6 +12,104 @@
 
 ### Removed
 
+## [2026.9.24-3] - 2026-09-24
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### 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
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.23-4] - 2026-09-23
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Eval cards no longer display truncation or full-output artifact footer warnings. Model-facing eval text and grouping are unchanged; content explicitly addressed only to the model is omitted from the text fallback. ([#2041](https://github.com/code-yeongyu/senpi/issues/2041))
+
+### Fixed
+
+### Removed
+
+## [2026.9.23-3] - 2026-09-23
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Dense one-line JavaScript eval cells are previewed in the TUI broken at statement, block, and long-array boundaries with indentation, keeping the original tokens and comments. Unparseable, non-JavaScript, and already readable cells are shown as sent, and the code that runs is unchanged. ([#2050](https://github.com/code-yeongyu/senpi/issues/2050))
+- The `eval` `summary` guide asks for a progress update saying what the agent is doing and why, in the language the user writes in, and summaries no longer have a length limit (the 80-character truncation is gone). A collapsed eval block shows the first three summary lines; expanding it shows the rest. ([#2050](https://github.com/code-yeongyu/senpi/issues/2050))
+- Codemode CI tests use at most two fork workers, matching the coding-agent suite's interpreter-heavy test scheduling. Test deadlines, assertions, and local worker defaults are unchanged. ([#2039](https://github.com/code-yeongyu/senpi/issues/2039))
+
+### Fixed
+
+### Removed
+
+## [2026.9.23-2] - 2026-09-23
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.9.23] - 2026-09-23
 
 ### Breaking Changes

package/README.md

@@ -29,7 +29,9 @@ task-tool names are known.
   session-adjacent spill files for large streams.
 - TUI and HTML-export rendering for syntax-highlighted cells, status rows,
   task progress, structured display values, truncation warnings, and image
-  fallbacks.
+  fallbacks. A JavaScript cell sent as dense one-line code is previewed broken
+  at statement, block, and long-array boundaries; the cell itself runs exactly
+  as sent.
 - Runtime identity badges in eval headers — `eval py (3.14.7, ~/.venv/bin/python3)`,
   `eval js (node 26.7.0, /opt/…/bin/node)` — with the same `runtime` info on
   `EvalToolDetails` and its `cells` for RPC consumers; interpreter detection
@@ -205,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
-
-Every `eval` run call MUST include a `summary` — one line in the user's
-conversational language stating what the cell does and for what purpose (e.g.
-a Korean conversation produces a Korean summary such as "src 전체에서
-legacyClient 사용처 집계"). 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. Values longer than 80 characters are force-truncated. A run request
-without a `summary` fails with a teaching error.
+## Required run fields
+
+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. 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.23",
+	"version": "2026.9.24-3",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.23",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.24-3",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.23"
+		"@code-yeongyu/senpi": "2026.9.24-3"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.23"
+		"@code-yeongyu/senpi": "2026.9.24-3"
 	},
 	"keywords": [
 		"senpi",

package/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/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/src/tool/display-code.ts

@@ -0,0 +1,48 @@
+import { bunJsPrinter, prettifyJs } from "./display-js.ts";
+import { pythonDisplay } from "./display-python.ts";
+import type { EvalLanguage } from "./types.ts";
+
+// 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 CACHE_LIMIT = 64;
+
+const jsCache = new Map<string, string>();
+
+function isDense(code: string): boolean {
+	return code.split("\n").some((line) => line.length > DENSE_LINE_LENGTH);
+}
+
+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;
+}
+
+/**
+ * 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;
+		}
+	}
+}

package/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/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/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;
+}