zidane 5.14.4 → 6.0.0

package/dist/{turn-operations-Dw02ZoSQ.d.ts → turn-operations-CgMROLsr.d.ts}

@@ -1,5 +1,5 @@
-import { Ar as TurnUsage, L as SkillConfig, Sr as ToolResultContent, mr as SessionTurn } from "./agent-EFWt6uQ_.js";
-import { D as Owner, E as EditPayload, G as ProviderKey, L as CompletionProvider, M as StreamEvent, R as CompletionReference, W as ProviderAuth, Y as ModelInfo, l as ApprovalDecision, w as EditOutcome } from "./tool-formatters-C6iLgc9f.js";
+import { Ac as CompletionProvider, Vd as SessionTurn, Yd as ToolResultContent, _u as ProviderKey, au as EditOutcome, cu as Owner, gu as ProviderAuth, if as TurnUsage, jc as CompletionReference, pu as StreamEvent, su as EditPayload, xf as SkillConfig, xu as ModelInfo } from "./index-B8UtiZy7.js";
+import { m as ApprovalDecision } from "./tool-formatters-DY0TDb1r.js";
 
 //#region src/chat/color-gradient.d.ts
 /**
@@ -628,6 +628,31 @@ declare function finalizeStreamingMarkdownForOwner(events: StreamEvent[], owner:
  * collapses to plain `input` for them.
  */
 declare function turnContextSize(usage: TurnUsage | undefined): number;
+/**
+ * Display-layer transcript bounds. Each rendered event holds live React
+ * fibers + OpenTUI renderables + native text buffers even when scrolled
+ * off-screen — measured at roughly 0.13 MB RSS per markdown-heavy event —
+ * so an uncapped multi-thousand-event session (a normal working day with
+ * tool calls) climbs into the hundreds of MB and eventually OOM/thrash.
+ *
+ * The cap bounds ONLY what is materialized on screen: session turns on
+ * disk are complete, and switching sessions / re-activating replays the
+ * most recent window again. Trimming happens at TURN boundaries so a
+ * turn's rows are never orphaned, and re-caps fold into one cumulative
+ * marker rather than stacking markers.
+ */
+declare const MAX_TRANSCRIPT_EVENTS = 1500;
+/** Post-trim size — the hysteresis gap keeps re-trims O(rare), not per-append. */
+declare const TRANSCRIPT_TRIM_TO_EVENTS = 1200;
+/**
+ * Bound a transcript event array for display. Identity below the cap
+ * (no re-render churn on the hot append path); above it, drops the
+ * oldest events down to {@link TRANSCRIPT_TRIM_TO_EVENTS} — extended to
+ * the next turn boundary — and prepends a cumulative hidden-count
+ * marker. Callers: the stream buffer's drain commit and every
+ * `eventsFromTurns` replay site.
+ */
+declare function capTranscriptEvents(events: StreamEvent[], max?: number, trimTo?: number): StreamEvent[];
 //#endregion
 //#region src/chat/turn-operations.d.ts
 /**
@@ -685,5 +710,5 @@ declare function countNeighbors(turnIds: readonly string[], turnId: string): {
   after: number;
 } | null;
 //#endregion
-export { uniqueFilesFromReferences as $, buildUnifiedDiff as A, buildEditOutcomesAnnotation as B, EditSummary as C, PreviewResult as D, InlineSegment as E, previewEditPayload as F, rewriteMultiEditHeader as G, mergeApprovalAndBodyOutcomes as H, splitLines as I, SKILLS_TRIGGER as J, stripEditOutcomesAnnotation as K, summarizeEditPayload as L, computeLineDiff as M, extractEditPayload as N, applyEditPayload as O, filetypeFromPath as P, createFilesCompletionProvider as Q, tokenize as R, EditHunkSummary as S, InlineDiff as T, parseEditOutcomesFromResult as U, maskToOutcomeKinds as V, resolveApprovalForPayload as W, uniqueSkillNamesFromReferences as X, createSkillsCompletionProvider as Y, FILES_TRIGGER as Z, formatTaskSummary as _, finalizeStreamingMarkdown as a, ChatReferenceEntry as at, DiffLine as b, CatalogEntry as c, createChatsCompletionProvider as ct, indexOfEntry as d, buildLinearRamp as dt, FileEntry as et, ageString as f, formatTaskStatus as g, formatDuration as h, turnAsText as i, ChatReferenceData as it, computeInlineDiff as j, buildContextualDiff as k, buildModelCatalog as l, uniqueChatIdsFromReferences as lt, fmtTokens as m, deleteTurnSafely as n, listProjectFiles as nt, finalizeStreamingMarkdownForOwner as o, ChatReferenceScope as ot, compactPath as p, summarizeOutcomes as q, truncateTurnsAt as r, CHATS_TRIGGER as rt, turnContextSize as s, chatReferenceTokensFromText as st, countNeighbors as t, ListProjectFilesOptions as tt, filterModelCatalog as u, blendHsl as ut, previewLine as v, HunkResolution as w, DiffOp as x, shortId as y, ResolvedApproval as z };
-//# sourceMappingURL=turn-operations-Dw02ZoSQ.d.ts.map
+export { uniqueSkillNamesFromReferences as $, PreviewResult as A, summarizeEditPayload as B, DiffLine as C, HunkResolution as D, EditSummary as E, computeLineDiff as F, mergeApprovalAndBodyOutcomes as G, ResolvedApproval as H, extractEditPayload as I, rewriteMultiEditHeader as J, parseEditOutcomesFromResult as K, filetypeFromPath as L, buildContextualDiff as M, buildUnifiedDiff as N, InlineDiff as O, computeInlineDiff as P, createSkillsCompletionProvider as Q, previewEditPayload as R, shortId as S, EditHunkSummary as T, buildEditOutcomesAnnotation as U, tokenize as V, maskToOutcomeKinds as W, summarizeOutcomes as X, stripEditOutcomesAnnotation as Y, SKILLS_TRIGGER as Z, fmtTokens as _, MAX_TRANSCRIPT_EVENTS as a, listProjectFiles as at, formatTaskSummary as b, finalizeStreamingMarkdown as c, ChatReferenceEntry as ct, CatalogEntry as d, createChatsCompletionProvider as dt, FILES_TRIGGER as et, buildModelCatalog as f, uniqueChatIdsFromReferences as ft, compactPath as g, ageString as h, turnAsText as i, ListProjectFilesOptions as it, applyEditPayload as j, InlineSegment as k, finalizeStreamingMarkdownForOwner as l, ChatReferenceScope as lt, indexOfEntry as m, buildLinearRamp as mt, deleteTurnSafely as n, uniqueFilesFromReferences as nt, TRANSCRIPT_TRIM_TO_EVENTS as o, CHATS_TRIGGER as ot, filterModelCatalog as p, blendHsl as pt, resolveApprovalForPayload as q, truncateTurnsAt as r, FileEntry as rt, capTranscriptEvents as s, ChatReferenceData as st, countNeighbors as t, createFilesCompletionProvider as tt, turnContextSize as u, chatReferenceTokensFromText as ut, formatDuration as v, DiffOp as w, previewLine as x, formatTaskStatus as y, splitLines as z };
+//# sourceMappingURL=turn-operations-CgMROLsr.d.ts.map

package/dist/turn-operations-CgMROLsr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-operations-CgMROLsr.d.ts","names":[],"sources":["../src/chat/color-gradient.ts","../src/chat/completion-chats.ts","../src/chat/files-discovery.ts","../src/chat/completion-files.ts","../src/chat/completion-skills.ts","../src/chat/edit-approval.ts","../src/tools/edit-utils.ts","../src/chat/edit-diff.ts","../src/chat/format.ts","../src/chat/model-catalog.ts","../src/chat/streaming-pure.ts","../src/chat/turn-operations.ts"],"mappings":"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"}

package/dist/{turn-operations-tG0vuBNc.js → turn-operations-Dq9Kx7m2.js}

@@ -1135,85 +1135,6 @@ function buildLinearRamp(from, to, n) {
 	return ramp;
 }
 //#endregion
-//#region src/chat/completion-core.ts
-/**
-* Resolve the provider trigger active at `cursor`, or `null` when none fits.
-*
-* Rules:
-*   - The trigger character must sit at position 0 of the buffer OR be
-*     preceded by whitespace. This prevents `http://` from triggering the
-*     `/`-bound skills provider mid-URL.
-*   - The cursor must be at or past the trigger position.
-*   - Nothing between the trigger and the cursor may be whitespace (the
-*     query is one contiguous token).
-*   - The query length is bounded — `maxQueryLength` defaults to 64 — so
-*     a runaway buffer scan can't pin the renderer.
-*/
-function findActiveTrigger(text, cursor, providers, options = {}) {
-	if (providers.length === 0) return null;
-	const max = options.maxQueryLength ?? 64;
-	const safeCursor = Math.max(0, Math.min(cursor, text.length));
-	const isWhitespace = (ch) => ch === void 0 ? false : /\s/.test(ch);
-	for (let i = safeCursor - 1; i >= 0 && safeCursor - i <= max + 1; i--) {
-		const ch = text[i];
-		if (isWhitespace(ch)) return null;
-		const provider = providers.find((p) => p.trigger === ch);
-		if (!provider) continue;
-		const before = i > 0 ? text[i - 1] : "";
-		if (before !== "" && !isWhitespace(before)) continue;
-		return {
-			provider,
-			query: text.slice(i + 1, safeCursor),
-			span: {
-				start: i,
-				end: safeCursor
-			}
-		};
-	}
-	return null;
-}
-/**
-* Replace `[span.start, span.end)` in `text` with `insertText`. Returns the
-* mutated text and the new cursor position (end of insertion).
-*/
-function applyInsert(text, span, insertText) {
-	return {
-		text: text.slice(0, span.start) + insertText + text.slice(span.end),
-		cursor: span.start + insertText.length
-	};
-}
-/**
-* Merge reference lists from multiple providers into one ordered list with
-* earlier-start-wins disambiguation when spans overlap. Ties broken by
-* insertion order. Spans are sorted ascending so renderers can walk them
-* sequentially with a cursor through the source string.
-*/
-function mergeReferences(refs) {
-	const sorted = [...refs].sort((a, b) => a.start - b.start);
-	const merged = [];
-	let lastEnd = -1;
-	for (const ref of sorted) {
-		if (ref.start < lastEnd) continue;
-		merged.push(ref);
-		lastEnd = ref.end;
-	}
-	return merged;
-}
-/**
-* Collect every provider's references in one pass. Convenience wrapper —
-* the TUI textarea component calls this on every keystroke to highlight
-* in-prompt mentions.
-*/
-function collectReferences(text, providers, cursor = text.length) {
-	const ctx = {
-		text,
-		cursor
-	};
-	const refs = [];
-	for (const p of providers) for (const ref of p.parseReferences(text, ctx)) refs.push(ref);
-	return mergeReferences(refs);
-}
-//#endregion
 //#region src/chat/completion-files.ts
 /** Trigger character — `@` is the conventional file-mention prefix in chat UIs. */
 const FILES_TRIGGER = "@";
@@ -1518,6 +1439,260 @@ function uniqueSkillNamesFromReferences(references) {
 	return out;
 }
 //#endregion
+//#region src/chat/markdown-segments.ts
+/**
+* Split markdown text into alternating prose / fenced-code segments.
+*
+* Recognizes both ` ``` ` and `~~~` fences, with arbitrary length ≥ 3,
+* matching CommonMark's "fence indicator must be at least as long to
+* close" rule. Info-strings (the bit after the opening fence) are kept
+* as the `lang` hint; any trailing whitespace is trimmed. Closing
+* fences are detected on a line of their own (whitespace tolerated).
+*
+* Unclosed fences fall back to emitting the would-be-code body as a
+* trailing prose segment so no content is dropped — finalized markdown
+* isn't expected to ship one, but the fallback keeps the renderer
+* truthful when the model produces malformed output.
+*
+* Exported for unit tests.
+*/
+function splitMarkdownCodeBlocks(text) {
+	const lines = text.split("\n");
+	const segments = [];
+	let prose = [];
+	let code = [];
+	let inFence = false;
+	let fenceChar = "";
+	let fenceLen = 0;
+	let lang = "";
+	const flushProse = () => {
+		if (prose.length > 0 && prose[prose.length - 1] === "") prose.pop();
+		if (prose.length > 0) {
+			segments.push({
+				kind: "prose",
+				content: prose.join("\n")
+			});
+			prose = [];
+		}
+	};
+	let trimLeadingProseBlank = false;
+	for (const line of lines) if (!inFence) {
+		const open = line.match(/^(`{3,}|~{3,})([^\n`~]*)$/);
+		if (open) {
+			flushProse();
+			inFence = true;
+			fenceChar = open[1][0];
+			fenceLen = open[1].length;
+			lang = open[2].trim();
+			code = [];
+			continue;
+		}
+		if (trimLeadingProseBlank) {
+			trimLeadingProseBlank = false;
+			if (line === "" && prose.length === 0) continue;
+		}
+		prose.push(line);
+	} else {
+		const close = line.match(/^(`{3,}|~{3,})\s*$/);
+		if (close && close[1][0] === fenceChar && close[1].length >= fenceLen) {
+			segments.push({
+				kind: "code",
+				content: code.join("\n"),
+				lang
+			});
+			inFence = false;
+			code = [];
+			trimLeadingProseBlank = true;
+			continue;
+		}
+		code.push(line);
+	}
+	if (inFence) prose.push(`${fenceChar.repeat(fenceLen)}${lang}`, ...code);
+	flushProse();
+	return segments;
+}
+const LIST_ITEM_RE = /^( *)(?:[-+*]|\d+[.)]) +/;
+/**
+* Lift indented fenced code blocks to column 0 while preserving the code
+* body's relative indentation.
+*
+* OpenTUI's markdown renderNode hook only receives top-level code tokens.
+* A common assistant shape is:
+*
+*   - Run this:
+*     ```bash
+*     command
+*     ```
+*
+* Marked parses that as code inside a list token, so the TUI loses the
+* code-panel wrapper and copy affordance. Normalizing just the fence's list
+* indentation keeps the prose readable while routing the snippet through
+* the same top-level renderer as ordinary fences.
+*/
+function normalizeMarkdownCodeFences(text) {
+	const lines = text.split("\n");
+	const out = [];
+	const listIndents = [];
+	let inFence = false;
+	let fenceChar = "";
+	let fenceLen = 0;
+	let lift = 0;
+	for (const line of lines) {
+		if (inFence) {
+			const normalized = stripFenceIndent(line, lift);
+			out.push(normalized);
+			if (isFenceClose(normalized, fenceChar, fenceLen)) {
+				inFence = false;
+				fenceChar = "";
+				fenceLen = 0;
+				lift = 0;
+			}
+			continue;
+		}
+		updateListIndentStack(listIndents, line);
+		const open = parseFenceOpen(line);
+		if (!open) {
+			out.push(line);
+			continue;
+		}
+		lift = [...listIndents].reverse().find((i) => i <= open.indent) ?? (open.indent <= 3 ? open.indent : 0);
+		const normalized = stripFenceIndent(line, lift);
+		out.push(normalized);
+		inFence = true;
+		fenceChar = open.char;
+		fenceLen = open.length;
+	}
+	return out.join("\n");
+}
+/**
+* Default per-chunk target for {@link chunkMarkdownForRender}. Chosen from
+* measurement: marked's lexer (which OpenTUI's `<markdown>` runs
+* internally) is O(n²) over paragraph-heavy input — ~500ms at 64KiB,
+* ~2s at 128KiB, ~6s at 256KiB on an M-series laptop — while staying
+* comfortably in the linear zone below ~32KiB (≤ ~200ms). Chunking a
+* large document into ≤24KiB pieces keeps the total render linear in
+* document size with a small constant.
+*/
+const MARKDOWN_RENDER_CHUNK_TARGET_BYTES = 24576;
+/**
+* A blank-line split is only safe when the next block clearly STARTS a
+* new top-level construct. Lines that continue a multi-block construct —
+* list items (loose lists put blank lines between items; splitting would
+* restart ordered-list numbering), blockquote lines, table rows, and
+* indented continuations / indented code — are unsafe, so a chunk grows
+* past the target rather than splitting one of these. Worst case (one
+* giant list) degrades to a single chunk: the pre-chunking behavior.
+*/
+function isUnsafeChunkBoundary(line) {
+	return LIST_ITEM_RE.test(line) || /^ *>/.test(line) || /^ *\|/.test(line) || /^ {4,}/.test(line);
+}
+/**
+* Split a large markdown document into render-safe chunks at blank-line
+* boundaries outside code fences, each roughly `targetBytes` long.
+*
+* Rendering the chunks as SIBLING markdown renderables (with a one-row
+* gap standing in for the consumed blank line) is visually equivalent to
+* one renderable, but sidesteps the quadratic lexer cost documented on
+* {@link MARKDOWN_RENDER_CHUNK_TARGET_BYTES}. Chunk boundaries are
+* prefix-stable: appending text (streaming) can only ever change the
+* LAST chunk, so keyed-by-index consumers reconcile cheaply.
+*
+* Returns `[text]` untouched for anything at or under the target.
+*/
+function chunkMarkdownForRender(text, targetBytes = MARKDOWN_RENDER_CHUNK_TARGET_BYTES) {
+	if (text.length <= targetBytes) return [text];
+	const lines = text.split("\n");
+	const chunks = [];
+	let current = [];
+	let currentBytes = 0;
+	let inFence = false;
+	let fenceChar = "";
+	let fenceLen = 0;
+	const push = (line) => {
+		current.push(line);
+		currentBytes += line.length + 1;
+	};
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (inFence) {
+			push(line);
+			if (isFenceClose(line, fenceChar, fenceLen)) inFence = false;
+			continue;
+		}
+		const open = parseFenceOpen(line);
+		if (open) {
+			push(line);
+			inFence = true;
+			fenceChar = open.char;
+			fenceLen = open.length;
+			continue;
+		}
+		if (line.trim() === "" && currentBytes >= targetBytes && current.length > 0) {
+			let next = i + 1;
+			while (next < lines.length && lines[next].trim() === "") next++;
+			if (next < lines.length && !isUnsafeChunkBoundary(lines[next])) {
+				chunks.push(current.join("\n"));
+				current = [];
+				currentBytes = 0;
+				i = next - 1;
+				continue;
+			}
+		}
+		push(line);
+	}
+	if (current.length > 0) chunks.push(current.join("\n"));
+	return chunks.length > 0 ? chunks : [text];
+}
+function parseFenceOpen(line) {
+	const indent = leadingSpaces(line);
+	const char = line[indent];
+	if (char !== "`" && char !== "~") return null;
+	const length = countRun(line, indent, char);
+	if (length < 3) return null;
+	const info = line.slice(indent + length);
+	if (char === "`" && info.includes("`")) return null;
+	return {
+		indent,
+		char,
+		length
+	};
+}
+function isFenceClose(line, fenceChar, fenceLen) {
+	const indent = leadingSpaces(line);
+	if (line[indent] !== fenceChar) return false;
+	const length = countRun(line, indent, fenceChar);
+	if (length < fenceLen) return false;
+	return onlySpaces(line, indent + length);
+}
+function updateListIndentStack(listIndents, line) {
+	const contentIndent = leadingSpaces(line);
+	if (line.trim().length > 0) while (listIndents.length > 0 && contentIndent < listIndents[listIndents.length - 1]) listIndents.pop();
+	const item = line.match(LIST_ITEM_RE);
+	if (!item) return;
+	const indent = item[0].length;
+	if (indent > (listIndents[listIndents.length - 1] ?? 0)) listIndents.push(indent);
+}
+function leadingSpaces(line) {
+	let i = 0;
+	while (i < line.length && line[i] === " ") i++;
+	return i;
+}
+function countRun(line, start, char) {
+	let i = start;
+	while (i < line.length && line[i] === char) i++;
+	return i - start;
+}
+function onlySpaces(line, start) {
+	for (let i = start; i < line.length; i++) if (line[i] !== " ") return false;
+	return true;
+}
+function stripFenceIndent(line, columns) {
+	if (columns <= 0) return line;
+	let i = 0;
+	while (i < columns && line[i] === " ") i++;
+	return line.slice(i);
+}
+//#endregion
 //#region src/chat/model-catalog.ts
 /**
 * Build the unified catalog from a list of available providers.
@@ -1695,6 +1870,71 @@ function finalizeStreamingMarkdownForOwner(events, owner) {
 function turnContextSize(usage) {
 	return effectiveInputFromTurn(usage);
 }
+/**
+* Display-layer transcript bounds. Each rendered event holds live React
+* fibers + OpenTUI renderables + native text buffers even when scrolled
+* off-screen — measured at roughly 0.13 MB RSS per markdown-heavy event —
+* so an uncapped multi-thousand-event session (a normal working day with
+* tool calls) climbs into the hundreds of MB and eventually OOM/thrash.
+*
+* The cap bounds ONLY what is materialized on screen: session turns on
+* disk are complete, and switching sessions / re-activating replays the
+* most recent window again. Trimming happens at TURN boundaries so a
+* turn's rows are never orphaned, and re-caps fold into one cumulative
+* marker rather than stacking markers.
+*/
+const MAX_TRANSCRIPT_EVENTS = 1500;
+/** Post-trim size — the hysteresis gap keeps re-trims O(rare), not per-append. */
+const TRANSCRIPT_TRIM_TO_EVENTS = 1200;
+/**
+* The cumulative count rides IN the marker's display text and is parsed
+* back out on re-cap — deliberately text-as-protocol rather than a new
+* StreamEvent kind or field: 'info' renders everywhere for free (no
+* renderer changes, no persistence shape change — markers are display
+* state and never persisted), and producer + consumer live ten lines
+* apart in this file. Same precedent as task-notification re-synthesis.
+* If markers ever need richer data, THAT is the moment for a dedicated
+* event kind.
+*/
+const HIDDEN_MARKER_RE = /^… (\d+) earlier transcript items hidden/;
+function hiddenMarkerEvent(count) {
+	return {
+		kind: "info",
+		text: `… ${count} earlier transcript items hidden to bound memory — the full history stays in the session.`
+	};
+}
+/**
+* Bound a transcript event array for display. Identity below the cap
+* (no re-render churn on the hot append path); above it, drops the
+* oldest events down to {@link TRANSCRIPT_TRIM_TO_EVENTS} — extended to
+* the next turn boundary — and prepends a cumulative hidden-count
+* marker. Callers: the stream buffer's drain commit and every
+* `eventsFromTurns` replay site.
+*/
+function capTranscriptEvents(events, max = MAX_TRANSCRIPT_EVENTS, trimTo = TRANSCRIPT_TRIM_TO_EVENTS) {
+	if (events.length <= max) return events;
+	const keep = Math.max(1, Math.min(trimTo, Math.floor(max * .8)));
+	let previouslyHidden = 0;
+	let start = 0;
+	const first = events[0];
+	if (first && first.kind === "info") {
+		const match = HIDDEN_MARKER_RE.exec(first.text);
+		if (match) {
+			previouslyHidden = Number(match[1]) || 0;
+			start = 1;
+		}
+	}
+	let cut = events.length - keep;
+	if (cut <= start) return events;
+	const turnAtCut = (i) => events[i]?.turnId;
+	while (cut < events.length) {
+		const turn = turnAtCut(cut);
+		if (turn === void 0 || turn !== turnAtCut(cut - 1)) break;
+		cut++;
+	}
+	if (cut >= events.length) cut = events.length - 1;
+	return [hiddenMarkerEvent(previouslyHidden + (cut - start)), ...events.slice(cut)];
+}
 //#endregion
 //#region src/chat/tool-formatters.ts
 /**
@@ -2128,6 +2368,6 @@ function countNeighbors(turnIds, turnId) {
 	};
 }
 //#endregion
-export { CHATS_TRIGGER as $, isTurnHighlighted as A, filetypeFromPath as B, collectReferences as C, buildLinearRamp as D, blendHsl as E, buildContextualDiff as F, buildEditOutcomesAnnotation as G, splitLines as H, buildUnifiedDiff as I, parseEditOutcomesFromResult as J, maskToOutcomeKinds as K, computeInlineDiff as L, selectableTurnIds as M, turnSelectionOwnership as N, EDIT_TOOL_NAMES as O, applyEditPayload as P, summarizeOutcomes as Q, computeLineDiff as R, applyInsert as S, mergeReferences as T, summarizeEditPayload as U, previewEditPayload as V, tokenize as W, rewriteMultiEditHeader as X, resolveApprovalForPayload as Y, stripEditOutcomesAnnotation as Z, createSkillsCompletionProvider as _, TOOL_DISPLAY as a, createFilesCompletionProvider as b, finalizeStreamingMarkdown as c, turnContextSize as d, chatReferenceTokensFromText as et, splitPromptSegments as f, SKILLS_TRIGGER as g, indexOfEntry as h, turnAsText as i, isVisible as j, isEditErrorResult as k, finalizeStreamingMarkdownForOwner as l, filterModelCatalog as m, deleteTurnSafely as n, uniqueChatIdsFromReferences as nt, displayNameFor as o, buildModelCatalog as p, mergeApprovalAndBodyOutcomes as q, truncateTurnsAt as r, formatToolCall as s, countNeighbors as t, createChatsCompletionProvider as tt, ownerOf as u, uniqueSkillNamesFromReferences as v, findActiveTrigger as w, uniqueFilesFromReferences as x, FILES_TRIGGER as y, extractEditPayload as z };
+export { rewriteMultiEditHeader as $, buildLinearRamp as A, computeInlineDiff as B, SKILLS_TRIGGER as C, createFilesCompletionProvider as D, FILES_TRIGGER as E, selectableTurnIds as F, splitLines as G, extractEditPayload as H, turnSelectionOwnership as I, buildEditOutcomesAnnotation as J, summarizeEditPayload as K, applyEditPayload as L, isEditErrorResult as M, isTurnHighlighted as N, uniqueFilesFromReferences as O, isVisible as P, resolveApprovalForPayload as Q, buildContextualDiff as R, splitMarkdownCodeBlocks as S, uniqueSkillNamesFromReferences as T, filetypeFromPath as U, computeLineDiff as V, previewEditPayload as W, mergeApprovalAndBodyOutcomes as X, maskToOutcomeKinds as Y, parseEditOutcomesFromResult as Z, filterModelCatalog as _, TOOL_DISPLAY as a, uniqueChatIdsFromReferences as at, chunkMarkdownForRender as b, MAX_TRANSCRIPT_EVENTS as c, finalizeStreamingMarkdown as d, stripEditOutcomesAnnotation as et, finalizeStreamingMarkdownForOwner as f, buildModelCatalog as g, splitPromptSegments as h, turnAsText as i, createChatsCompletionProvider as it, EDIT_TOOL_NAMES as j, blendHsl as k, TRANSCRIPT_TRIM_TO_EVENTS as l, turnContextSize as m, deleteTurnSafely as n, CHATS_TRIGGER as nt, displayNameFor as o, ownerOf as p, tokenize as q, truncateTurnsAt as r, chatReferenceTokensFromText as rt, formatToolCall as s, countNeighbors as t, summarizeOutcomes as tt, capTranscriptEvents as u, indexOfEntry as v, createSkillsCompletionProvider as w, normalizeMarkdownCodeFences as x, MARKDOWN_RENDER_CHUNK_TARGET_BYTES as y, buildUnifiedDiff as z };
 
-//# sourceMappingURL=turn-operations-tG0vuBNc.js.map
+//# sourceMappingURL=turn-operations-Dq9Kx7m2.js.map