zidane 9.1.1 → 9.1.3

package/dist/script-progress-CrZ507Qq.js

@@ -0,0 +1,900 @@
+import { n as previewNestedOutput } from "./nested-call-record-OayszZBQ.js";
+//#region src/chat/command-notes.ts
+/** The persisted invocation header block: `` `❯ /commit args` ``. */
+function commandHeaderBlock(invocation) {
+	return `\`❯ ${invocation}\``;
+}
+/** `/name args` from a persisted header block, or null when the text is not one. */
+function parseCommandHeader(text) {
+	const match = /^`❯ (\/[\s\S]+)`$/.exec(text.trim());
+	return match ? match[1] : null;
+}
+const PREFIX_SEPARATOR = /^\s*(?:[:·—-]\s*)?/;
+/**
+* The receipt text for one note. Older displays repeat the command
+* (`/commit: 83dfea7`, `/review — 3 reviewers, fixes applied`); the prompt
+* bubble above already names it, so the prefix goes, and a leftover ` — `
+* becomes a comma. A note without a display shows its first line.
+*/
+function commandNoteText(display, text, invocation) {
+	let line = (display ?? text.split("\n").find((l) => l.trim()) ?? "").trim();
+	const prefix = [invocation, invocation?.split(/\s/, 1)[0]].filter((p) => Boolean(p)).find((p) => line.startsWith(p)) ?? /^\/[\w.:-]+/.exec(line)?.[0];
+	if (prefix) {
+		const rest = line.slice(prefix.length).replace(PREFIX_SEPARATOR, "");
+		if (rest) line = /^[0-9a-f]{7,40}$/.test(rest) ? `committed ${rest}` : rest;
+	}
+	line = line.replace(/\s+—\s+/g, ", ");
+	return line.length > 160 ? `${line.slice(0, 159)}…` : line;
+}
+/**
+* The `display` a context note persists with: the command's marker, its
+* first line when it gave none, or `''` for a model-only note
+* (`display: false`), which shows nothing.
+*/
+function noteDisplay(display, text) {
+	return display === false ? "" : display ?? commandNoteText(void 0, text);
+}
+/** A command step label: the display as given, a leftover ` — ` turned into a comma. */
+function commandStepLabel(display) {
+	return display.replace(/\s+—\s+/g, ", ");
+}
+const merged = /* @__PURE__ */ new WeakMap();
+function isTopPrompt(event) {
+	return event.kind === "user-prompt" && !event.childId && (event.depth ?? 0) === 0;
+}
+/**
+* One receipt line per exchange: every `command-note` in an exchange moves
+* to its end and joins into a single event (`committed 83dfea7, pushed to
+* origin/main`). Returns `events` itself when there is nothing to merge;
+* the merged event keeps its identity while its notes do not change, so
+* memoised rows stay put.
+*
+* @param events - Transcript events in display order.
+*/
+function gatherCommandNotes(events) {
+	if (!events.some((e) => e.kind === "command-note")) return events;
+	const out = [];
+	let notes = [];
+	const flush = () => {
+		if (notes.length === 0) return;
+		const first = notes[0];
+		const key = notes.map((n) => n.text).join("\0");
+		let event = first;
+		if (notes.length > 1) {
+			const cached = merged.get(first);
+			event = cached?.key === key ? cached.event : {
+				...first,
+				text: notes.map((n) => n.text).join(", ")
+			};
+			merged.set(first, {
+				key,
+				event
+			});
+		}
+		let at = out.length;
+		while (at > 0 && out[at - 1].kind === "separator") at--;
+		out.splice(at, 0, event);
+		notes = [];
+	};
+	for (const event of events) {
+		if (isTopPrompt(event)) flush();
+		if (event.kind === "command-note" && !event.childId) {
+			notes.push(event);
+			continue;
+		}
+		out.push(event);
+	}
+	flush();
+	return out.length === events.length && out.every((e, i) => e === events[i]) ? events : out;
+}
+//#endregion
+//#region src/chat/nested-call-events.ts
+/** `name(json args)`, as `store.ts`' `toolCallPreview` writes it (not imported: `store.ts` imports this module). */
+function callPreview(name, input) {
+	const args = JSON.stringify(input);
+	return args && args !== "{}" ? `${name}(${args})` : name;
+}
+function tagFields(tag) {
+	return {
+		...tag?.turnId ? { turnId: tag.turnId } : {},
+		...tag?.childId !== void 0 ? { childId: tag.childId } : {},
+		...tag?.depth !== void 0 ? { depth: tag.depth } : {}
+	};
+}
+/**
+* The `tool` row for a nested call as it starts.
+*
+* @param call - The nested call.
+* @param call.callId - Its call id.
+* @param call.name - Tool it called.
+* @param call.input - Arguments it passed.
+* @param call.parentToolCallId - Id of the calling tool, which the row groups under.
+* @param call.runsNestedAgent - The called tool runs a subagent.
+* @param call.startedAt - When the call started (epoch ms, the host's clock), live only.
+* @param tag - Turn, subagent and depth to stamp on the event.
+*/
+function nestedToolEvent(call, tag) {
+	return {
+		kind: "tool",
+		text: callPreview(call.name, call.input),
+		tool: call.name,
+		callId: call.callId,
+		input: call.input,
+		parentToolCallId: call.parentToolCallId,
+		...call.runsNestedAgent ? { runsNestedAgent: true } : {},
+		...call.startedAt !== void 0 ? { startedAt: call.startedAt } : {},
+		...tagFields(tag)
+	};
+}
+/**
+* The `tool-result` row for a nested call as it ends; the output is cut to a preview.
+*
+* @param result - The nested call's result.
+* @param result.callId - Its call id.
+* @param result.name - Tool it called.
+* @param result.output - Full output; the row keeps a preview.
+* @param result.isError - The call failed.
+* @param result.parentToolCallId - Id of the calling tool, which the row groups under.
+* @param result.runsNestedAgent - The called tool runs a subagent.
+* @param result.durationMs - How long the call ran. `0` reads as unknown: a durable run's records carry no wall time.
+* @param tag - Turn, subagent and depth to stamp on the event.
+*/
+function nestedResultEvent(result, tag) {
+	return {
+		kind: "tool-result",
+		text: previewNestedOutput(result.output).output,
+		tool: result.name,
+		callId: result.callId,
+		parentToolCallId: result.parentToolCallId,
+		...result.runsNestedAgent ? { runsNestedAgent: true } : {},
+		...result.isError ? { isError: true } : {},
+		...result.durationMs ? { durationMs: result.durationMs } : {},
+		...tagFields(tag)
+	};
+}
+/**
+* A persisted record as the events the live run emitted for it.
+*
+* @param records - Nested calls stored on the calling tool's result.
+* @param parentToolCallId - Id of the calling tool.
+* @param tag - Turn, subagent and depth to stamp on the events.
+*/
+function nestedRecordEvents(records, parentToolCallId, tag) {
+	return records.flatMap((record) => [nestedToolEvent({
+		callId: record.id,
+		name: record.name,
+		input: record.input ?? {},
+		parentToolCallId,
+		runsNestedAgent: record.runsNestedAgent
+	}, tag), nestedResultEvent({
+		callId: record.id,
+		name: record.name,
+		output: record.output ?? "",
+		isError: record.status !== "ok",
+		parentToolCallId,
+		runsNestedAgent: record.runsNestedAgent,
+		durationMs: record.durationMs
+	}, tag)]);
+}
+//#endregion
+//#region src/chat/ansi.ts
+const ESC = 27;
+/** Parser states: plain text, after ESC, in a CSI, in an OSC / DCS string, after ESC inside one. */
+const TEXT = 0;
+const AFTER_ESC = 1;
+const CSI = 2;
+const STRING = 3;
+const STRING_ESC = 4;
+/**
+* Whether `text` holds anything {@link parseAnsi} changes: an escape, a carriage return, a backspace.
+*
+* @param text - Terminal output.
+*/
+function hasAnsi(text) {
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code === ESC || code === 155 || code === 157 || code === 13 || code === 8) return true;
+	}
+	return false;
+}
+function sameStyle(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.fg === b.fg && a.bg === b.bg && a.bold === b.bold && a.dim === b.dim && a.italic === b.italic && a.underline === b.underline && a.inverse === b.inverse;
+}
+function hex(n) {
+	return Math.max(0, Math.min(255, n)).toString(16).padStart(2, "0");
+}
+/** An extended color (`38;5;n`, `38;2;r;g;b`) read from `params` at `i` (the `5` or `2`); returns it and the index after it. */
+function extendedColor(params, i) {
+	if (params[i] === 5) return [params[i + 1] !== void 0 ? Math.max(0, Math.min(255, params[i + 1])) : void 0, i + 2];
+	if (params[i] === 2) return [`#${hex(params[i + 1] ?? 0)}${hex(params[i + 2] ?? 0)}${hex(params[i + 3] ?? 0)}`, i + 4];
+	return [void 0, i + 1];
+}
+/** `style` after an SGR sequence. A style object is never changed, so spans can compare by reference. */
+function applySgr(style, raw) {
+	const params = raw === "" ? [0] : raw.split(/[;:]/).map((p) => p === "" ? 0 : Number(p));
+	let next = { ...style };
+	for (let i = 0; i < params.length; i++) {
+		const p = params[i];
+		if (p === 0) next = {};
+		else if (p === 1) next.bold = true;
+		else if (p === 2) next.dim = true;
+		else if (p === 3) next.italic = true;
+		else if (p === 4) next.underline = true;
+		else if (p === 7) next.inverse = true;
+		else if (p === 22) {
+			delete next.bold;
+			delete next.dim;
+		} else if (p === 23) delete next.italic;
+		else if (p === 24) delete next.underline;
+		else if (p === 27) delete next.inverse;
+		else if (p >= 30 && p <= 37) next.fg = p - 30;
+		else if (p >= 90 && p <= 97) next.fg = p - 90 + 8;
+		else if (p === 39) delete next.fg;
+		else if (p >= 40 && p <= 47) next.bg = p - 40;
+		else if (p >= 100 && p <= 107) next.bg = p - 100 + 8;
+		else if (p === 49) delete next.bg;
+		else if (p === 38 || p === 48) {
+			const [color, after] = extendedColor(params, i + 1);
+			if (color !== void 0) {
+				if (p === 38) next.fg = color;
+				else next.bg = color;
+			}
+			i = after - 1;
+		}
+	}
+	if (Object.keys(next).length === 0) return void 0;
+	return sameStyle(style, next) ? style : next;
+}
+/** Creates an incremental {@link AnsiLines} reader. The style carries across chunks and lines, as in a terminal. */
+function createAnsiLines() {
+	let state = TEXT;
+	let params = "";
+	let style;
+	let line = [];
+	/** A `\r` arrived: the next printable starts the line over, unless `\n` follows. */
+	let pendingCr = false;
+	const append = (text) => {
+		if (pendingCr) {
+			line = [];
+			pendingCr = false;
+		}
+		const last = line[line.length - 1];
+		if (last && sameStyle(last.style, style)) {
+			last.text += text;
+			return;
+		}
+		line.push(style ? {
+			text,
+			style
+		} : { text });
+	};
+	const backspace = () => {
+		const last = line[line.length - 1];
+		if (!last) return;
+		last.text = last.text.slice(0, -1);
+		if (last.text === "") line.pop();
+	};
+	return {
+		push(chunk) {
+			const done = [];
+			let i = 0;
+			while (i < chunk.length) {
+				const code = chunk.charCodeAt(i);
+				if (state === TEXT) {
+					if (code === ESC) state = AFTER_ESC;
+					else if (code === 10) {
+						done.push(line);
+						line = [];
+						pendingCr = false;
+					} else if (code === 13) pendingCr = true;
+					else if (code === 8) backspace();
+					else if (code === 155) {
+						state = CSI;
+						params = "";
+					} else if (code === 157) state = STRING;
+					else if (code === 9 || code >= 32 && !(code >= 127 && code < 160)) {
+						let end = i + 1;
+						while (end < chunk.length) {
+							const c = chunk.charCodeAt(end);
+							if (c === ESC || c === 10 || c === 13 || c === 8 || c < 32 && c !== 9 || c >= 127 && c < 160) break;
+							end++;
+						}
+						append(chunk.slice(i, end));
+						i = end;
+						continue;
+					}
+				} else if (state === AFTER_ESC) {
+					if (code === 91) {
+						state = CSI;
+						params = "";
+					} else if (code === 93 || code === 80 || code === 88 || code === 94 || code === 95) state = STRING;
+					else if (code < 32 || code > 47) state = TEXT;
+				} else if (state === CSI) {
+					if (code >= 64 && code <= 126) {
+						if (code === 109) style = applySgr(style, params);
+						state = TEXT;
+					} else if (params.length < 64) params += chunk[i];
+				} else if (state === STRING) {
+					if (code === 7 || code === 156) state = TEXT;
+					else if (code === ESC) state = STRING_ESC;
+				} else state = code === 92 ? TEXT : STRING;
+				i++;
+			}
+			return done;
+		},
+		partial: () => pendingCr ? [] : line
+	};
+}
+/**
+* `text` as lines of styled spans. A text without a closing newline still
+* yields its last line; an empty text yields one empty line.
+*
+* @param text - Terminal output.
+*/
+function parseAnsi(text) {
+	const reader = createAnsiLines();
+	const lines = reader.push(text);
+	lines.push(reader.partial());
+	return lines;
+}
+/**
+* The visible text of a line.
+*
+* @param spans - The line's spans.
+*/
+function ansiLineText(spans) {
+	return spans.map((span) => span.text).join("");
+}
+/**
+* `text` without its escapes, as a terminal would show it.
+*
+* @param text - Terminal output.
+*/
+function stripAnsi(text) {
+	if (!hasAnsi(text)) return text;
+	return parseAnsi(text).map(ansiLineText).join("\n");
+}
+/**
+* A line cut to `max` visible characters, the last one an ellipsis when it is cut.
+*
+* @param spans - The line's spans.
+* @param max - Visible characters kept.
+*/
+function clipAnsiLine(spans, max) {
+	if (ansiLineText(spans).length <= max) return [...spans];
+	const out = [];
+	let room = max - 1;
+	for (const span of spans) {
+		if (room <= 0) break;
+		const text = span.text.slice(0, room);
+		out.push(span.style ? {
+			text,
+			style: span.style
+		} : { text });
+		room -= text.length;
+	}
+	out.push({ text: "…" });
+	return out;
+}
+//#endregion
+//#region src/chat/output-tail.ts
+/**
+* Creates an empty {@link OutputTail}.
+*
+* @param maxLines - Lines kept.
+* @param lineChars - Characters kept per line.
+*/
+function createOutputTail(maxLines, lineChars) {
+	const tail = [];
+	const commands = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	const shape = (spans) => {
+		const clipped = clipAnsiLine(spans, lineChars);
+		const text = ansiLineText(clipped);
+		return clipped.some((span) => span.style) ? {
+			text,
+			spans: clipped
+		} : { text };
+	};
+	const push = (entry) => {
+		tail.push(entry);
+		if (tail.length > maxLines) tail.splice(0, tail.length - maxLines);
+	};
+	return {
+		item(stream, text, line) {
+			const at = line !== void 0 ? { line } : {};
+			for (const spans of createAnsiLines().push(`${text}\n`)) push({
+				id: nextId++,
+				stream,
+				...shape(spans),
+				...at
+			});
+		},
+		chunk(stream, text, line) {
+			const key = `${stream}\u0000${line ?? ""}`;
+			let command = commands.get(key);
+			if (!command) {
+				command = {
+					reader: createAnsiLines(),
+					stream,
+					...line !== void 0 ? { line } : {}
+				};
+				commands.set(key, command);
+			}
+			const at = line !== void 0 ? { line } : {};
+			for (const spans of command.reader.push(text)) {
+				push({
+					id: command.openId ?? nextId++,
+					stream,
+					...shape(spans),
+					...at
+				});
+				command.openId = void 0;
+			}
+			if (command.reader.partial().length > 0 && command.openId === void 0) command.openId = nextId++;
+		},
+		lines() {
+			const open = [...commands.values()].flatMap(({ reader, stream, line, openId }) => {
+				const spans = reader.partial();
+				return spans.length === 0 || openId === void 0 ? [] : [{
+					id: openId,
+					stream,
+					...shape(spans),
+					...line !== void 0 ? { line } : {}
+				}];
+			});
+			return [...tail, ...open].slice(-maxLines);
+		}
+	};
+}
+//#endregion
+//#region src/chat/script-progress.ts
+/** Output lines a progress state keeps. */
+const SCRIPT_OUTPUT_TAIL_LINES = 8;
+/** Characters kept per output line. */
+const SCRIPT_OUTPUT_LINE_CHARS = 240;
+/** Creates an empty {@link ScriptProgressTracker}. */
+function createScriptProgressTracker() {
+	const lines = /* @__PURE__ */ new Map();
+	const lineOf = /* @__PURE__ */ new Map();
+	const running = /* @__PURE__ */ new Set();
+	let done = 0;
+	let failed = 0;
+	let ended;
+	const output = createOutputTail(8, 240);
+	return {
+		start(callId, line) {
+			if (line === void 0 || lineOf.has(callId)) return;
+			lineOf.set(callId, line);
+			running.add(callId);
+			const entry = lines.get(line);
+			if (entry) {
+				entry.calls++;
+				entry.status = "running";
+				entry.latest = callId;
+			} else lines.set(line, {
+				line,
+				status: "running",
+				calls: 1,
+				latest: callId
+			});
+		},
+		finish(callId, ok) {
+			if (!running.delete(callId)) return;
+			done++;
+			if (!ok) failed++;
+			const entry = lines.get(lineOf.get(callId));
+			if (entry && entry.latest === callId) entry.status = ok ? "ok" : "error";
+		},
+		output(stream, text, line) {
+			if (stream === "output" || stream === "console") output.item(stream, text, line);
+			else output.chunk(stream, text, line);
+		},
+		end(ok) {
+			ended = ok ? "ok" : "error";
+		},
+		snapshot() {
+			return {
+				lines: [...lines.values()].sort((a, b) => a.line - b.line).map(({ line, status, calls }) => ({
+					line,
+					status,
+					calls
+				})),
+				done,
+				running: running.size,
+				failed,
+				output: output.lines(),
+				...ended ? { ended } : {}
+			};
+		}
+	};
+}
+/**
+* The final progress of a script from its saved call records, or `undefined`
+* when none carries a line (the script ran without live progress).
+*
+* @param records - The calls saved on the script's result.
+* @param ok - The script's own result was no error.
+*/
+function scriptProgressFromRecords(records, ok) {
+	if (!records.some((record) => record.line !== void 0)) return void 0;
+	const tracker = createScriptProgressTracker();
+	for (const record of records) {
+		tracker.start(record.id, record.line);
+		tracker.finish(record.id, record.status === "ok");
+	}
+	if (ok !== void 0) tracker.end(ok);
+	return tracker.snapshot();
+}
+/**
+* `events` with `event`, a `tool-progress` state, in place of the one it
+* replaces (same call, same subagent), or appended. Other events are appended.
+* A script keeps one progress event, however long it runs.
+*
+* @param events - The transcript so far.
+* @param event - The live event.
+*/
+function upsertToolProgress(events, event) {
+	if (event.kind === "tool-progress") {
+		const at = events.findLastIndex((e) => e.kind === "tool-progress" && e.callId === event.callId && e.childId === event.childId);
+		if (at !== -1) {
+			const next = events.slice();
+			next[at] = event;
+			return next;
+		}
+	}
+	return [...events, event];
+}
+/**
+* The latest `tool-progress` state of each script, by call id (`childId` + NUL + `callId`).
+*
+* @param events - The transcript's events.
+*/
+function scriptProgressByCall(events) {
+	const found = /* @__PURE__ */ new Map();
+	for (const event of events) if (event.kind === "tool-progress" && event.callId && event.scriptProgress) found.set(scriptProgressKey(event.callId, event.childId), event.scriptProgress);
+	return found;
+}
+/**
+* Key of a script in {@link scriptProgressByCall}.
+*
+* @param callId - The script's call id.
+* @param childId - The subagent that ran it, if any.
+*/
+function scriptProgressKey(callId, childId) {
+	return `${childId ?? ""}\u0000${callId}`;
+}
+const OPTIONS_LINE = /^\s*\/\/ @options:(.*)$/;
+function readOptions(json) {
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch {
+		return {
+			other: [],
+			raw: json
+		};
+	}
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {
+		other: [],
+		raw: json
+	};
+	const options = { other: [] };
+	for (const [key, field] of Object.entries(value)) if (key === "timeout_ms" && typeof field === "number") options.timeoutMs = field;
+	else if (key === "max_output_tokens" && typeof field === "number") options.maxOutputTokens = field;
+	else options.other.push({
+		key,
+		value: JSON.stringify(field)
+	});
+	return options;
+}
+/**
+* The view of a script: its lines with their states, the counts, and the
+* percent when it is exact (see {@link countOnceCallSites}).
+*
+* @param code - The script, as the model wrote it.
+* @param progress - Its progress, when it streamed any.
+* @param finished - The script ended (`ok` tells how).
+* @param ok - It ended without error.
+* @param result - Its result text: a failed script's names the line it threw at.
+*/
+function scriptProgressView(code, progress, finished, ok = true, result) {
+	const ended = finished || progress?.ended !== void 0;
+	const endedOk = progress?.ended !== void 0 ? progress.ended === "ok" : ok;
+	const error = ended && !endedOk && result ? scriptErrorOf(result) : void 0;
+	const source = code.split("\n").map((line) => line.replace(/\r$/, ""));
+	const optionsMatch = source[0] !== void 0 ? OPTIONS_LINE.exec(source[0]) : null;
+	const options = optionsMatch ? readOptions(optionsMatch[1].trim()) : void 0;
+	let first = optionsMatch ? 1 : 0;
+	while (first < source.length && source[first].trim() === "") first++;
+	let last = source.length - 1;
+	while (last >= first && source[last].trim() === "") last--;
+	const byLine = new Map(progress?.lines.map((entry) => [entry.line, entry]));
+	const furthest = progress?.lines.length ? progress.lines[progress.lines.length - 1].line : 0;
+	const reached = ended && endedOk ? Number.POSITIVE_INFINITY : furthest;
+	const lines = [];
+	for (let i = first; i <= last; i++) {
+		const number = i + 1;
+		const entry = byLine.get(number);
+		const state = error?.line === number ? "failed" : !progress ? "passed" : entry ? entry.status === "running" ? "running" : entry.status === "ok" ? "done" : "failed" : number <= reached ? "passed" : "idle";
+		lines.push({
+			number,
+			label: number - first,
+			text: source[i],
+			state,
+			calls: entry?.calls ?? 0
+		});
+	}
+	const lastLine = lines.at(-1);
+	if (progress && ended && endedOk && lastLine?.state === "passed") lastLine.state = "done";
+	const done = progress?.done ?? 0;
+	const total = progress ? countOnceCallSites(code) : void 0;
+	const exact = total !== void 0 && done + (progress?.running ?? 0) <= total;
+	const running = progress?.lines.find((entry) => entry.status === "running")?.line;
+	return {
+		lines,
+		...options !== void 0 ? { options } : {},
+		tracked: progress !== void 0,
+		done,
+		running: progress?.running ?? 0,
+		failed: progress?.failed ?? 0,
+		...exact ? {
+			total,
+			percent: ended && endedOk ? 100 : Math.min(100, Math.round(done / total * 100))
+		} : {},
+		...!ended && progress ? { active: running ?? (furthest || void 0) } : {},
+		output: progress?.output ?? [],
+		...error && lines.some((line) => line.number === error.line) ? { error } : {}
+	};
+}
+const SCRIPT_ERROR = /^Script error: (.+)$/m;
+const EXCERPT_LINE = /^(\d+) \| /m;
+/**
+* The error a failed script threw and the line it names, out of its result
+* (`Script error: …` then the `12 | source` excerpt the sandbox writes).
+*
+* @param result - The script's result text.
+*/
+function scriptErrorOf(result) {
+	const message = SCRIPT_ERROR.exec(result)?.[1]?.trim();
+	const line = EXCERPT_LINE.exec(result)?.[1];
+	return message && line ? {
+		line: Number(line),
+		message
+	} : void 0;
+}
+/**
+* `code` with the text of strings, comments and regular expressions replaced
+* by spaces (newlines kept), so a scan sees only code. Template literals keep
+* their `${…}` expressions.
+*
+* @param code - The script, as the model wrote it.
+*/
+function maskScriptSource(code) {
+	const out = code.split("");
+	const blank = (from, to) => {
+		for (let k = from; k < to; k++) if (out[k] !== "\n") out[k] = " ";
+	};
+	/** Brace depth of each open `${`, innermost last. */
+	const templates = [];
+	let braces = 0;
+	let prev = "";
+	let i = 0;
+	const n = code.length;
+	/** Skip a template's text from `i` (after the backtick or the `}` of an expression). */
+	const templateText = () => {
+		const start = i;
+		while (i < n) {
+			const c = code[i];
+			if (c === "\\") {
+				i += 2;
+				continue;
+			}
+			if (c === "`") {
+				blank(start, i);
+				i++;
+				prev = "`";
+				return;
+			}
+			if (c === "$" && code[i + 1] === "{") {
+				blank(start, i);
+				templates.push(braces);
+				i += 2;
+				prev = "{";
+				return;
+			}
+			i++;
+		}
+		blank(start, n);
+	};
+	while (i < n) {
+		const c = code[i];
+		if (c === "/" && code[i + 1] === "/") {
+			const end = code.indexOf("\n", i);
+			blank(i, end === -1 ? n : end);
+			i = end === -1 ? n : end;
+			continue;
+		}
+		if (c === "/" && code[i + 1] === "*") {
+			const end = code.indexOf("*/", i + 2);
+			blank(i, end === -1 ? n : end + 2);
+			i = end === -1 ? n : end + 2;
+			continue;
+		}
+		if (c === "\"" || c === "'") {
+			let j = i + 1;
+			while (j < n && code[j] !== c && code[j] !== "\n") j += code[j] === "\\" ? 2 : 1;
+			blank(i + 1, Math.min(j, n));
+			i = j + 1;
+			prev = c;
+			continue;
+		}
+		if (c === "`") {
+			i++;
+			templateText();
+			continue;
+		}
+		if (c === "/" && (prev === "" || "(,=:[!&|?{};+-*%<>~^".includes(prev))) {
+			let j = i + 1;
+			let inClass = false;
+			while (j < n && code[j] !== "\n") {
+				const d = code[j];
+				if (d === "\\") {
+					j += 2;
+					continue;
+				}
+				if (d === "[") inClass = true;
+				else if (d === "]") inClass = false;
+				else if (d === "/" && !inClass) break;
+				j++;
+			}
+			blank(i + 1, Math.min(j, n));
+			i = j + 1;
+			prev = ")";
+			continue;
+		}
+		if (c === "{") braces++;
+		else if (c === "}") {
+			if (templates.length > 0 && templates[templates.length - 1] === braces) {
+				templates.pop();
+				i++;
+				templateText();
+				continue;
+			}
+			braces--;
+		}
+		if (!/\s/.test(c)) prev = /[\w$]/.test(c) ? "w" : c;
+		i++;
+	}
+	return out.join("");
+}
+const TOOL_CALL = /\btools\s*(?:\.\s*[A-Z_$][\w$]*|\[\s*(["'`])\s*\1\s*\])\s*\(/gi;
+const TOOL_REF = /\btools\b/g;
+const SH_CALL = /(?<![\w$.])sh\s*\(/g;
+const SH_REF = /(?<![\w$.])sh\b/g;
+const WORD = /[\w$]/;
+/**
+* How many calls a script makes, when every call can run once at most: each
+* `tools.<name>(…)` or `sh(…)` sits outside loops and functions (callbacks,
+* helpers, methods). `undefined` when one may run more than once, when the
+* script reaches `tools` or `sh` another way (a reference, a computed name),
+* or when it makes no call. A call in a branch that does not run makes the
+* count high, never low, so a percent from it never runs ahead.
+*
+* @param code - The script, as the model wrote it.
+*/
+function countOnceCallSites(code) {
+	const masked = maskScriptSource(code);
+	const sites = /* @__PURE__ */ new Set();
+	for (const match of masked.matchAll(TOOL_CALL)) sites.add(match.index);
+	if ((masked.match(TOOL_REF)?.length ?? 0) !== sites.size) return void 0;
+	const shCalls = [...masked.matchAll(SH_CALL)];
+	if ((masked.match(SH_REF)?.length ?? 0) !== shCalls.length) return void 0;
+	for (const match of shCalls) sites.add(match.index);
+	if (sites.size === 0) return void 0;
+	const stack = [];
+	let pending = null;
+	let nextParen = null;
+	const repeating = () => stack.some((scope) => scope.repeats);
+	/** A body without braces opens where its first token starts. */
+	const openBody = () => {
+		if (pending === "loopBody") stack.push({
+			close: "stmt",
+			repeats: true
+		});
+		else if (pending === "arrowBody") stack.push({
+			close: "expr",
+			repeats: true
+		});
+		pending = null;
+	};
+	const closeTo = (close) => {
+		while (stack.length > 0) {
+			const scope = stack.pop();
+			if (scope.close === close) return scope;
+		}
+	};
+	const popWhile = (closes) => {
+		while (stack.length > 0 && closes.includes(stack[stack.length - 1].close)) stack.pop();
+	};
+	let i = 0;
+	const n = masked.length;
+	while (i < n) {
+		const c = masked[i];
+		if (/\s/.test(c)) {
+			i++;
+			continue;
+		}
+		if (WORD.test(c)) {
+			let j = i;
+			while (j < n && WORD.test(masked[j])) j++;
+			const word = masked.slice(i, j);
+			openBody();
+			if (sites.has(i) && repeating()) return void 0;
+			if (word === "for" || word === "while") nextParen = "loop";
+			else if (word === "if" || word === "switch" || word === "catch" || word === "with") nextParen = "cond";
+			else if (word === "function") nextParen = "fn";
+			else if (word === "do") pending = "loopBody";
+			i = j;
+			continue;
+		}
+		if (c === "=" && masked[i + 1] === ">") {
+			pending = "arrowBody";
+			i += 2;
+			continue;
+		}
+		if (c === "{") {
+			const repeats = pending === "loopBody" || pending === "fnBody" || pending === "braceIsFn" || pending === "arrowBody";
+			stack.push({
+				close: "}",
+				repeats
+			});
+			pending = null;
+			i++;
+			continue;
+		}
+		if (c === ";") {
+			popWhile(["stmt", "expr"]);
+			pending = null;
+			i++;
+			continue;
+		}
+		if (c === ",") {
+			popWhile(["expr"]);
+			pending = null;
+			i++;
+			continue;
+		}
+		if (c === ")" || c === "]" || c === "}") {
+			const scope = closeTo(c);
+			pending = null;
+			if (c === ")" && scope) {
+				if (scope.kind === "loop") pending = "loopBody";
+				else if (scope.kind === "fn") pending = "fnBody";
+				else if (scope.kind === "other") pending = "braceIsFn";
+			}
+			i++;
+			continue;
+		}
+		openBody();
+		if (c === "(") {
+			stack.push({
+				close: ")",
+				repeats: false,
+				kind: nextParen ?? "other"
+			});
+			nextParen = null;
+		} else if (c === "[") stack.push({
+			close: "]",
+			repeats: false
+		});
+		i++;
+	}
+	return sites.size;
+}
+//#endregion
+export { commandNoteText as C, parseCommandHeader as D, noteDisplay as E, commandHeaderBlock as S, gatherCommandNotes as T, parseAnsi as _, maskScriptSource as a, nestedResultEvent as b, scriptProgressFromRecords as c, upsertToolProgress as d, createOutputTail as f, hasAnsi as g, createAnsiLines as h, createScriptProgressTracker as i, scriptProgressKey as l, clipAnsiLine as m, SCRIPT_OUTPUT_TAIL_LINES as n, scriptErrorOf as o, ansiLineText as p, countOnceCallSites as r, scriptProgressByCall as s, SCRIPT_OUTPUT_LINE_CHARS as t, scriptProgressView as u, stripAnsi as v, commandStepLabel as w, nestedToolEvent as x, nestedRecordEvents as y };
+
+//# sourceMappingURL=script-progress-CrZ507Qq.js.map