pi-paster 0.1.5 → 0.2.1

package/dist/index.mjs

@@ -3,22 +3,233 @@ import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { Image, getCellDimensions, getImageDimensions, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { platform } from "node:process";
+import { Box, Container, Image, Spacer, Text, getCellDimensions, getImageDimensions, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 //#region src/types.ts
 const EXTENSION_NAME = "paster";
-const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_IMAGE_BYTES = 64 * 1024 * 1024;
+const ANTHROPIC_MAX_DIMENSION = 8e3;
+const ANTHROPIC_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+//#endregion
+//#region src/optimize-image.ts
+let _sharp;
+async function getSharp() {
+	if (_sharp !== void 0) return _sharp;
+	try {
+		const mod = await import("sharp");
+		const fn = typeof mod === "function" ? mod : mod?.default;
+		_sharp = typeof fn === "function" ? fn : null;
+	} catch {
+		_sharp = null;
+	}
+	return _sharp;
+}
+const SHRINK_LADDER = [
+	6e3,
+	4e3,
+	3e3,
+	2e3
+];
+const JPEG_QUALITY_LADDER = [
+	95,
+	90,
+	85,
+	80,
+	70,
+	60
+];
+async function optimizeImageBytes(input, mime) {
+	const originalBytes = input.length;
+	const noop = () => ({
+		data: input.toString("base64"),
+		mimeType: mime,
+		originalBytes,
+		finalBytes: originalBytes,
+		actions: [],
+		changed: false
+	});
+	if (originalBytes <= 5242880) {
+		if (originalBytes <= 256 * 1024) return noop();
+	}
+	const sharp = await getSharp();
+	if (!sharp) return noop();
+	const meta = await sharp(input).metadata();
+	const origW = meta.width ?? 0;
+	const origH = meta.height ?? 0;
+	if (!origW || !origH) return noop();
+	const actions = [];
+	const originalDim = {
+		width: origW,
+		height: origH
+	};
+	let workBuf = input;
+	let workW = origW;
+	let workH = origH;
+	if (workW > 8e3 || workH > 8e3) {
+		workBuf = await sharp(workBuf).resize({
+			width: workW >= workH ? ANTHROPIC_MAX_DIMENSION : void 0,
+			height: workH > workW ? ANTHROPIC_MAX_DIMENSION : void 0,
+			fit: "inside",
+			withoutEnlargement: true
+		}).toBuffer();
+		const m = await sharp(workBuf).metadata();
+		workW = m.width ?? workW;
+		workH = m.height ?? workH;
+		actions.push(`resize to ${workW}x${workH} (8000px cap)`);
+	}
+	if (workBuf.length <= 5242880 && actions.length === 0) return noop();
+	if (workBuf.length <= 5242880) return {
+		data: workBuf.toString("base64"),
+		mimeType: mime,
+		originalBytes,
+		finalBytes: workBuf.length,
+		originalDim,
+		finalDim: {
+			width: workW,
+			height: workH
+		},
+		actions,
+		changed: true
+	};
+	let outMime = "image/jpeg";
+	let attempt = workBuf;
+	for (const q of JPEG_QUALITY_LADDER) {
+		attempt = await sharp(workBuf).jpeg({
+			quality: q,
+			mozjpeg: true
+		}).toBuffer();
+		if (attempt.length <= 5242880) {
+			actions.push(`jpeg q=${q} → ${formatBytes(attempt.length)}`);
+			return {
+				data: attempt.toString("base64"),
+				mimeType: outMime,
+				originalBytes,
+				finalBytes: attempt.length,
+				originalDim,
+				finalDim: {
+					width: workW,
+					height: workH
+				},
+				actions,
+				changed: true
+			};
+		}
+	}
+	actions.push(`jpeg q=60 still ${formatBytes(attempt.length)} — shrinking`);
+	for (const longEdge of SHRINK_LADDER) {
+		if (Math.max(workW, workH) <= longEdge) continue;
+		const resized = await sharp(workBuf).resize({
+			width: workW >= workH ? longEdge : void 0,
+			height: workH > workW ? longEdge : void 0,
+			fit: "inside",
+			withoutEnlargement: true
+		}).toBuffer();
+		const m = await sharp(resized).metadata();
+		const newW = m.width ?? workW;
+		const newH = m.height ?? workH;
+		for (const q of JPEG_QUALITY_LADDER) {
+			attempt = await sharp(resized).jpeg({
+				quality: q,
+				mozjpeg: true
+			}).toBuffer();
+			if (attempt.length <= 5242880) {
+				actions.push(`resize ${newW}x${newH} + jpeg q=${q} → ${formatBytes(attempt.length)}`);
+				return {
+					data: attempt.toString("base64"),
+					mimeType: outMime,
+					originalBytes,
+					finalBytes: attempt.length,
+					originalDim,
+					finalDim: {
+						width: newW,
+						height: newH
+					},
+					actions,
+					changed: true
+				};
+			}
+		}
+		workBuf = resized;
+		workW = newW;
+		workH = newH;
+	}
+	actions.push(`final ${formatBytes(attempt.length)} — over limit`);
+	return {
+		data: attempt.toString("base64"),
+		mimeType: outMime,
+		originalBytes,
+		finalBytes: attempt.length,
+		originalDim,
+		finalDim: {
+			width: workW,
+			height: workH
+		},
+		actions,
+		changed: true
+	};
+}
+function formatBytes(bytes) {
+	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+	if (bytes >= 1024) return `${(bytes / 1024).toFixed(0)}KB`;
+	return `${bytes}B`;
+}
 //#endregion
 //#region src/image-utils.ts
+const MAX_BARE_PATH_EXTENSIONS = 8;
 function detectImageMimeType(bytes) {
 	if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) return "image/png";
 	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
 	if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) return "image/gif";
 	if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
 }
+const WINDOWS_DRIVE_PATH = /^([a-zA-Z]):[\\/](.*)$/;
+function isWindowsDrivePath(value) {
+	return WINDOWS_DRIVE_PATH.test(value);
+}
+function isWindowsUncPath(value) {
+	return value.startsWith("\\\\") && value.length > 2;
+}
+function isWindowsLikePath(value) {
+	return isWindowsDrivePath(value) || isWindowsUncPath(value);
+}
+let cachedIsWsl;
+function isWsl() {
+	if (cachedIsWsl !== void 0) return cachedIsWsl;
+	if (platform !== "linux") {
+		cachedIsWsl = false;
+		return cachedIsWsl;
+	}
+	if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
+		cachedIsWsl = true;
+		return cachedIsWsl;
+	}
+	try {
+		const release = readFileSync("/proc/version", "utf8");
+		cachedIsWsl = /microsoft|wsl/i.test(release);
+	} catch {
+		cachedIsWsl = false;
+	}
+	return cachedIsWsl;
+}
+function windowsToWslPath(windowsPath) {
+	const driveMatch = WINDOWS_DRIVE_PATH.exec(windowsPath);
+	if (driveMatch) {
+		const drive = driveMatch[1].toLowerCase();
+		const rest = driveMatch[2].replace(/\\/g, "/");
+		return rest.length > 0 ? `/mnt/${drive}/${rest}` : `/mnt/${drive}`;
+	}
+	if (isWindowsUncPath(windowsPath)) return windowsPath.replace(/\\/g, "/");
+	return windowsPath;
+}
 function resolveImagePath(input, cwd) {
 	if (input === "~") return homedir();
 	if (input.startsWith("~/")) return resolve(homedir(), input.slice(2));
+	if (isWindowsLikePath(input)) {
+		if (platform === "win32") return input;
+		if (isWsl()) return windowsToWslPath(input);
+		return input;
+	}
 	if (isAbsolute(input)) return input;
 	return resolve(cwd, input);
 }
@@ -32,7 +243,12 @@ function shellUnescape(input) {
 	return result;
 }
 function isPathLike(value) {
-	return value.startsWith("/") || value.startsWith("~/") || value === "~" || value.startsWith("./") || value.startsWith("../");
+	return value.startsWith("/") || value.startsWith("~/") || value === "~" || value.startsWith("./") || value.startsWith("../") || isWindowsLikePath(value);
+}
+function startsWithWindowsPath(text, index) {
+	if (index + 2 < text.length && /[a-zA-Z]/.test(text[index]) && text[index + 1] === ":" && (text[index + 2] === "\\" || text[index + 2] === "/")) return true;
+	if (index + 1 < text.length && text[index] === "\\" && text[index + 1] === "\\") return true;
+	return false;
 }
 function tokenizePathLikeText(text) {
 	const tokens = [];
@@ -47,11 +263,12 @@ function tokenizePathLikeText(text) {
 		if (char === "'" || char === "\"") {
 			const quote = char;
 			index++;
+			const windowsMode = startsWithWindowsPath(text, index);
 			let value = "";
 			let closed = false;
 			while (index < text.length) {
 				const current = text[index];
-				if (current === "\\" && quote === "\"" && index + 1 < text.length) {
+				if (!windowsMode && current === "\\" && quote === "\"" && index + 1 < text.length) {
 					value += text[index + 1];
 					index += 2;
 					continue;
@@ -68,15 +285,17 @@ function tokenizePathLikeText(text) {
 				raw: text.slice(start, index),
 				value,
 				start,
-				end: index
+				end: index,
+				bare: false
 			});
 			continue;
 		}
+		const windowsMode = startsWithWindowsPath(text, index);
 		let rawValue = "";
 		while (index < text.length) {
 			const current = text[index];
 			if (/\s/.test(current)) break;
-			if (current === "\\" && index + 1 < text.length) {
+			if (!windowsMode && current === "\\" && index + 1 < text.length) {
 				rawValue += current + text[index + 1];
 				index += 2;
 				continue;
@@ -84,16 +303,59 @@ function tokenizePathLikeText(text) {
 			rawValue += current;
 			index++;
 		}
-		const value = shellUnescape(rawValue);
+		const value = windowsMode ? rawValue : shellUnescape(rawValue);
 		if (isPathLike(value)) tokens.push({
 			raw: rawValue,
 			value,
 			start,
-			end: index
+			end: index,
+			bare: true
 		});
 	}
 	return tokens;
 }
+function tryExtendBareToken(text, token, attempt) {
+	let value = token.value;
+	let end = token.end;
+	let lastResult = attempt(value);
+	if (lastResult.ok || lastResult.reason === "too-large" || !token.bare) return {
+		value,
+		end,
+		result: lastResult
+	};
+	let scan = end;
+	for (let i = 0; i < MAX_BARE_PATH_EXTENSIONS; i++) {
+		let wsEnd = scan;
+		while (wsEnd < text.length) {
+			const ch = text[wsEnd];
+			if (ch === "\n" || ch === "\r") break;
+			if (!/\s/.test(ch)) break;
+			wsEnd++;
+		}
+		if (wsEnd === scan) break;
+		let wordEnd = wsEnd;
+		while (wordEnd < text.length && !/\s/.test(text[wordEnd])) wordEnd++;
+		if (wordEnd === wsEnd) break;
+		const nextWord = shellUnescape(text.slice(wsEnd, wordEnd));
+		if (isPathLike(nextWord)) break;
+		const extendedValue = value + text.slice(scan, wsEnd) + nextWord;
+		const candidate = attempt(extendedValue);
+		scan = wordEnd;
+		if (candidate.ok || candidate.reason === "too-large") return {
+			value: extendedValue,
+			end: wordEnd,
+			result: candidate
+		};
+		value = extendedValue;
+		end = wordEnd;
+		lastResult = candidate;
+	}
+	return {
+		value,
+		end,
+		result: lastResult
+	};
+}
 function dimensionsForImage(data, mimeType) {
 	return getImageDimensions(data, mimeType) ?? void 0;
 }
@@ -154,15 +416,16 @@ function replaceImagePathsInText(text, options) {
 	const accepted = [];
 	const loadImage = options.loadImage ?? loadImageFromPath;
 	for (const token of tokens) {
-		const result = loadImage(token.value, options.cwd);
-		if (!result.ok) {
-			options.onReject?.(result);
+		if (token.start < cursor) continue;
+		const extended = tryExtendBareToken(text, token, (path) => loadImage(path, options.cwd));
+		if (!extended.result.ok) {
+			if (extended.result.reason === "too-large") options.onReject?.(extended.result);
 			continue;
 		}
-		const attachment = options.store.add(result.image);
+		const attachment = options.store.add(extended.result.image);
 		accepted.push(attachment);
 		output += text.slice(cursor, token.start) + attachment.placeholder;
-		cursor = token.end;
+		cursor = extended.end;
 		replaced++;
 	}
 	if (replaced === 0) return {
@@ -184,14 +447,145 @@ function imagesForText(store, text, existing = []) {
 		data: attachment.data
 	}))];
 }
+function appendImagePathContext(text, attachments) {
+	if (attachments.length === 0) return text;
+	return `${text}\n\nAttached image paths:\n${attachments.map((attachment) => `- ${attachment.placeholder}: ${attachment.originalPath}`).join("\n")}`;
+}
+/**
+* Async variant of imagesForText that runs each attachment through the
+* Anthropic-aware image optimizer (resize to 8000px cap, JPEG ladder to stay
+* under the 5 MB / 32 MB request caps). Optimization is cached on the
+* attachment so the cost is paid once per image, not per submit.
+*
+* Used by paster's `input` handler; safe to await on the hot path because
+* sharp is only invoked when the image is actually over the limits.
+*/
+async function imagesForTextOptimized(store, text, existing = []) {
+	const attachments = store.matchingPlaceholders(text);
+	const optimized = [];
+	for (const attachment of attachments) {
+		if (!attachment.optimized) try {
+			const result = await optimizeImageBytes(Buffer.from(attachment.data, "base64"), attachment.mimeType);
+			if (result.changed) {
+				attachment.data = result.data;
+				attachment.mimeType = result.mimeType;
+				if (result.finalDim) attachment.dimensions = {
+					widthPx: result.finalDim.width,
+					heightPx: result.finalDim.height
+				};
+			}
+			attachment.optimized = true;
+			attachment.originalBytes = result.originalBytes;
+			attachment.finalBytes = result.finalBytes;
+			attachment.optimizeActions = result.actions;
+		} catch {
+			attachment.optimized = true;
+		}
+		optimized.push({
+			type: "image",
+			mimeType: attachment.mimeType,
+			data: attachment.data
+		});
+	}
+	return [...existing, ...optimized];
+}
+function describeReject(result, notify) {
+	if (!notify) return;
+	if (result.reason === "too-large") notify(`paster: image is too large and was not attached: ${result.path}`);
+}
 //#endregion
 //#region src/clipboard.ts
 function readClipboardImage(maxBytes = MAX_IMAGE_BYTES) {
-	if (process.platform !== "darwin") return {
+	if (process.platform === "darwin") return readMacOSClipboardImage(maxBytes);
+	if (process.platform === "win32") return readWindowsClipboardImage(maxBytes);
+	if (process.platform === "linux" && isWSL()) return readWindowsClipboardImage(maxBytes);
+	return {
 		ok: false,
 		reason: "unsupported-platform"
 	};
-	return readMacOSClipboardImage(maxBytes);
+}
+function isWSL() {
+	try {
+		return /microsoft|wsl/i.test(readFileSync("/proc/version", "utf8"));
+	} catch {
+		return false;
+	}
+}
+function resolvePowerShell() {
+	if (process.platform === "win32") return "powershell.exe";
+	for (const c of ["/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe", "/mnt/c/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe"]) if (existsSync(c)) return c;
+	return "powershell.exe";
+}
+function readWindowsClipboardImage(maxBytes) {
+	const exe = resolvePowerShell();
+	if (!exe) return {
+		ok: false,
+		reason: "unsupported-platform"
+	};
+	const script = [
+		"$ErrorActionPreference = 'Stop'",
+		"Add-Type -AssemblyName System.Windows.Forms | Out-Null",
+		"Add-Type -AssemblyName System.Drawing | Out-Null",
+		"$img = [System.Windows.Forms.Clipboard]::GetImage()",
+		"if ($img -eq $null) { exit 2 }",
+		"$ms = New-Object System.IO.MemoryStream",
+		"$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)",
+		"[Console]::Out.Write([Convert]::ToBase64String($ms.ToArray()))"
+	].join("; ");
+	try {
+		const result = spawnSync(exe, [
+			"-NoProfile",
+			"-NonInteractive",
+			"-STA",
+			"-Command",
+			script
+		], {
+			timeout: 5e3,
+			encoding: "utf8",
+			maxBuffer: 64 * 1024 * 1024
+		});
+		if (result.status === 2) return {
+			ok: false,
+			reason: "empty"
+		};
+		if (result.status !== 0) return {
+			ok: false,
+			reason: "read-error"
+		};
+		const data = (result.stdout || "").trim();
+		if (!data) return {
+			ok: false,
+			reason: "empty"
+		};
+		const bytes = Buffer.from(data, "base64");
+		if (bytes.length === 0) return {
+			ok: false,
+			reason: "empty"
+		};
+		if (bytes.length > maxBytes) return {
+			ok: false,
+			reason: "too-large"
+		};
+		const mimeType = detectImageMimeType(bytes);
+		if (!mimeType) return {
+			ok: false,
+			reason: "unsupported"
+		};
+		return {
+			ok: true,
+			image: {
+				originalPath: "clipboard.png",
+				mimeType,
+				data,
+				dimensions: dimensionsForImage(data, mimeType)
+			}
+		};
+	} catch {
+		return {
+			ok: false,
+			reason: "read-error"
+		};
+	}
 }
 function readMacOSClipboardImage(maxBytes) {
 	for (const attempt of [{
@@ -254,23 +648,72 @@ function readMacOSClipboardImage(maxBytes) {
 }
 //#endregion
 //#region src/config.ts
-const DEFAULT_PASTER_CONFIG = { customEditor: {
-	enabled: true,
-	showImagePreview: true,
-	deletePlaceholderAsBlock: true
-} };
+const DEFAULT_PASTER_CONFIG = {
+	submittedPreviewStyle: "raw",
+	includeImagePathsInPrompt: true,
+	customEditor: {
+		enabled: true,
+		showImagePreview: true,
+		deletePlaceholderAsBlock: true
+	}
+};
 function resolvePasterConfig(config = {}) {
-	return { customEditor: {
-		enabled: config.customEditor?.enabled ?? DEFAULT_PASTER_CONFIG.customEditor.enabled,
-		showImagePreview: config.customEditor?.showImagePreview ?? DEFAULT_PASTER_CONFIG.customEditor.showImagePreview,
-		deletePlaceholderAsBlock: config.customEditor?.deletePlaceholderAsBlock ?? DEFAULT_PASTER_CONFIG.customEditor.deletePlaceholderAsBlock
-	} };
+	return {
+		submittedPreviewStyle: config.submittedPreviewStyle ?? DEFAULT_PASTER_CONFIG.submittedPreviewStyle,
+		includeImagePathsInPrompt: config.includeImagePathsInPrompt ?? DEFAULT_PASTER_CONFIG.includeImagePathsInPrompt,
+		customEditor: {
+			enabled: config.customEditor?.enabled ?? DEFAULT_PASTER_CONFIG.customEditor.enabled,
+			showImagePreview: config.customEditor?.showImagePreview ?? DEFAULT_PASTER_CONFIG.customEditor.showImagePreview,
+			deletePlaceholderAsBlock: config.customEditor?.deletePlaceholderAsBlock ?? DEFAULT_PASTER_CONFIG.customEditor.deletePlaceholderAsBlock
+		}
+	};
 }
 //#endregion
 //#region src/editor.ts
 const PASTE_START = "\x1B[200~";
 const PASTE_END = "\x1B[201~";
 const PLACEHOLDER_REGEX = /\[#image \d+\]/g;
+const PASTE_MARKER_REGEX = /\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]/g;
+const baseSegmenter = new Intl.Segmenter();
+function atomicSpansForText(text, validPasteIds) {
+	const spans = [];
+	for (const match of text.matchAll(PASTE_MARKER_REGEX)) {
+		const id = Number.parseInt(match[1], 10);
+		if (!validPasteIds.has(id)) continue;
+		spans.push({
+			start: match.index,
+			end: match.index + match[0].length
+		});
+	}
+	for (const match of text.matchAll(PLACEHOLDER_REGEX)) {
+		const placeholder = match[0];
+		spans.push({
+			start: match.index,
+			end: match.index + placeholder.length
+		});
+	}
+	return spans.sort((a, b) => a.start - b.start || a.end - b.end);
+}
+function segmentTextWithAtomicImages(text, store, validPasteIds = /* @__PURE__ */ new Set()) {
+	const spans = atomicSpansForText(text, validPasteIds);
+	if (spans.length === 0) return [...baseSegmenter.segment(text)];
+	const result = [];
+	let spanIndex = 0;
+	for (const segment of baseSegmenter.segment(text)) {
+		while (spanIndex < spans.length && spans[spanIndex].end <= segment.index) spanIndex++;
+		const span = spans[spanIndex];
+		if (span && segment.index >= span.start && segment.index < span.end) {
+			if (segment.index === span.start) result.push({
+				segment: text.slice(span.start, span.end),
+				index: span.start,
+				input: text
+			});
+			continue;
+		}
+		result.push(segment);
+	}
+	return result;
+}
 function findPlaceholderAtCursor(store, lines, cursor, mode) {
 	const line = lines[cursor.line] ?? "";
 	for (const match of line.matchAll(PLACEHOLDER_REGEX)) {
@@ -278,21 +721,24 @@ function findPlaceholderAtCursor(store, lines, cursor, mode) {
 		const start = match.index;
 		const end = start + placeholder.length;
 		const attachment = store.get(placeholder);
-		if (!attachment) continue;
+		if (!attachment && mode !== "hover") continue;
 		if (mode === "hover" && cursor.col >= start && cursor.col < end) return {
 			attachment,
+			placeholder,
 			line: cursor.line,
 			start,
 			end
 		};
 		if (mode === "backspace" && cursor.col > start && cursor.col <= end) return {
 			attachment,
+			placeholder,
 			line: cursor.line,
 			start,
 			end
 		};
 		if (mode === "delete" && cursor.col >= start && cursor.col < end) return {
 			attachment,
+			placeholder,
 			line: cursor.line,
 			start,
 			end
@@ -306,6 +752,7 @@ var PasterEditor = class extends CustomEditor {
 		super(tui, theme, pasterKeybindings);
 		this.pasterKeybindings = pasterKeybindings;
 		this.pasterOptions = pasterOptions;
+		this.installAtomicImageSegmentation();
 		this.onPasteImage = () => {
 			this.handlePasteClipboardImage();
 		};
@@ -317,6 +764,7 @@ var PasterEditor = class extends CustomEditor {
 	}
 	handleInput(data) {
 		if (this.handleBracketedPaste(data)) return;
+		if (this.handleAtomicPlaceholderNavigation(data)) return;
 		if (this.pasterOptions.deletePlaceholderAsBlock && this.handleAtomicPlaceholderDelete(data)) return;
 		super.handleInput(data);
 		this.updateCursorPreview();
@@ -325,6 +773,10 @@ var PasterEditor = class extends CustomEditor {
 		this.activePreviewPlaceholder = void 0;
 		this.pasterOptions.setCursorPreview(void 0);
 	}
+	installAtomicImageSegmentation() {
+		const editor = this;
+		editor.segment = (text) => segmentTextWithAtomicImages(text, this.pasterOptions.store, new Set(editor.pastes?.keys() ?? []));
+	}
 	async handlePasteClipboardImage() {
 		const attachment = await this.pasterOptions.pasteClipboardImage?.();
 		if (!attachment) return;
@@ -365,6 +817,20 @@ var PasterEditor = class extends CustomEditor {
 		this.updateCursorPreview();
 		return true;
 	}
+	handleAtomicPlaceholderNavigation(data) {
+		const isLeft = this.pasterKeybindings.matches(data, "tui.editor.cursorLeft");
+		const isRight = this.pasterKeybindings.matches(data, "tui.editor.cursorRight");
+		if (!isLeft && !isRight) return false;
+		const line = this.getLines()[this.getCursor().line] ?? "";
+		const cursor = this.getCursor();
+		const matches = [...line.matchAll(PLACEHOLDER_REGEX)];
+		const target = isRight ? matches.find((match) => cursor.col >= match.index && cursor.col < match.index + match[0].length) : matches.find((match) => cursor.col > match.index && cursor.col <= match.index + match[0].length);
+		if (!target) return false;
+		this.setCursor(target.index + (isRight ? target[0].length : 0));
+		this.updateCursorPreview();
+		this.tui.requestRender();
+		return true;
+	}
 	handleAtomicPlaceholderDelete(data) {
 		const isBackspace = this.pasterKeybindings.matches(data, "tui.editor.deleteCharBackward");
 		const isDelete = this.pasterKeybindings.matches(data, "tui.editor.deleteCharForward");
@@ -376,14 +842,18 @@ var PasterEditor = class extends CustomEditor {
 		this.updateCursorPreview();
 		return true;
 	}
+	setCursor(col) {
+		const editor = this;
+		if (editor.setCursorCol) editor.setCursorCol(col);
+		else editor.state.cursorCol = col;
+	}
 	deleteLineRange(lineIndex, start, end) {
 		const editor = this;
 		editor.pushUndoSnapshot?.();
 		const line = editor.state.lines[lineIndex] ?? "";
 		editor.state.lines[lineIndex] = line.slice(0, start) + line.slice(end);
 		editor.state.cursorLine = lineIndex;
-		if (editor.setCursorCol) editor.setCursorCol(start);
-		else editor.state.cursorCol = start;
+		this.setCursor(start);
 		editor.lastAction = null;
 		editor.historyIndex = -1;
 		this.onChange?.(this.getText());
@@ -393,14 +863,12 @@ var PasterEditor = class extends CustomEditor {
 		return replaceImagePathsInText(text, {
 			cwd: this.pasterOptions.cwd,
 			store: this.pasterOptions.store,
-			onReject: (result) => {
-				if (result.reason === "too-large") this.pasterOptions.notify(`paster: image is over 10 MB and was not attached: ${result.path}`);
-			}
+			onReject: (result) => describeReject(result, this.pasterOptions.notify)
 		});
 	}
 	updateCursorPreview() {
 		const target = findPlaceholderAtCursor(this.pasterOptions.store, this.getLines(), this.getCursor(), "hover");
-		const nextPlaceholder = target?.attachment.placeholder;
+		const nextPlaceholder = target?.attachment?.placeholder;
 		if (nextPlaceholder === this.activePreviewPlaceholder) return;
 		this.activePreviewPlaceholder = nextPlaceholder;
 		this.pasterOptions.setCursorPreview(target?.attachment);
@@ -415,26 +883,48 @@ function formatAttachmentLine(attachment, width, style) {
 }
 var ImagePreviewMessage = class {
 	images;
-	constructor(attachments, theme) {
+	constructor(attachments, theme, options = {}) {
 		this.attachments = attachments;
 		this.theme = theme;
+		this.options = options;
 		this.images = attachments.map((attachment) => new Image(attachment.data, attachment.mimeType, theme, {
 			maxWidthCells: 60,
 			maxHeightCells: 16,
 			filename: attachment.placeholder
 		}));
 	}
+	invalidate() {
+		for (const image of this.images) image.invalidate();
+	}
 	render(width) {
+		return this.options.style === "collapsible" ? this.renderCollapsible(width) : this.renderRaw(width);
+	}
+	renderRaw(width) {
 		const lines = [];
+		const safeWidth = Math.max(1, width);
 		for (let index = 0; index < this.attachments.length; index++) {
 			const attachment = this.attachments[index];
-			lines.push(formatAttachmentLine(attachment, width, this.theme.fallbackColor));
-			lines.push(...this.images[index].render(width));
+			lines.push(formatAttachmentLine(attachment, safeWidth, this.theme.fallbackColor));
+			lines.push(...this.images[index].render(safeWidth));
 		}
 		return lines;
 	}
-	invalidate() {
-		for (const image of this.images) image.invalidate();
+	renderCollapsible(width) {
+		const container = new Container();
+		container.addChild(new Spacer(1));
+		const box = new Box(1, 1, this.theme.background);
+		container.addChild(box);
+		const title = this.theme.title ?? this.theme.fallbackColor;
+		const muted = this.theme.muted ?? this.theme.fallbackColor;
+		const summary = this.attachments.length === 1 ? `Attached ${this.attachments[0].placeholder}` : `Attached ${this.attachments.length} images`;
+		const suffix = this.options.expanded ? " (ctrl+o to collapse)" : " (ctrl+o to expand)";
+		box.addChild(new Text(`${title(summary)}${muted(suffix)}`, 0, 0));
+		for (const attachment of this.attachments) box.addChild(new Text(formatAttachmentLine(attachment, width, muted), 0, 0));
+		const lines = container.render(width);
+		if (!this.options.expanded) return lines;
+		const safeWidth = Math.max(1, width);
+		for (let index = 0; index < this.attachments.length; index++) lines.push(...this.images[index].render(safeWidth));
+		return lines;
 	}
 };
 var CursorImagePreviewWidget = class {
@@ -512,9 +1002,7 @@ function createImagePasteTerminalInputHandler(options) {
 		cwd: options.cwd,
 		store: options.store,
 		loadImage: options.loadImage,
-		onReject: (result) => {
-			if (result.reason === "too-large") options.notify?.(`paster: image is over 10 MB and was not attached: ${result.path}`);
-		}
+		onReject: (result) => describeReject(result, options.notify)
 	});
 	return (data) => {
 		let prefix = "";
@@ -550,11 +1038,19 @@ function paster(pi, config = {}) {
 	let pendingPreview = [];
 	let activeEditor;
 	let unsubscribeTerminalInput;
-	pi.registerMessageRenderer("paster-preview", (message, _options, theme) => {
+	pi.registerMessageRenderer("paster-preview", (message, options, theme) => {
 		const placeholders = message.details?.placeholders ?? [];
 		const attachments = store.list().filter((attachment) => placeholders.includes(attachment.placeholder));
 		if (attachments.length === 0) return void 0;
-		return new ImagePreviewMessage(attachments, { fallbackColor: (text) => theme.fg("muted", text) });
+		return new ImagePreviewMessage(attachments, {
+			fallbackColor: (text) => theme.fg("muted", text),
+			background: (text) => theme.bg("toolSuccessBg", text),
+			title: (text) => theme.fg("toolTitle", theme.bold(text)),
+			muted: (text) => theme.fg("muted", text)
+		}, {
+			expanded: options.expanded,
+			style: resolvedConfig.submittedPreviewStyle
+		});
 	});
 	pi.on("session_start", (_event, ctx) => {
 		store.clear();
@@ -612,24 +1108,26 @@ function paster(pi, config = {}) {
 		store.clear();
 	});
 	function previewMessage(attachments) {
+		const placeholders = attachments.map((attachment) => attachment.placeholder);
 		return {
 			customType: "paster-preview",
-			content: "",
+			content: `(attachment preview: ${placeholders.join(", ")})`,
 			display: true,
-			details: { placeholders: attachments.map((attachment) => attachment.placeholder) }
+			details: { placeholders }
 		};
 	}
-	pi.on("input", (event, ctx) => {
+	pi.on("input", async (event, ctx) => {
 		if (event.source === "extension") return { action: "continue" };
 		if (ctx.hasUI) activeEditor?.clearCursorPreview();
 		const attachments = store.matchingPlaceholders(event.text);
 		if (attachments.length === 0) return { action: "continue" };
 		if (ctx.isIdle()) pendingPreview = attachments;
 		else pi.sendMessage(previewMessage(attachments), { deliverAs: "followUp" });
+		const images = await imagesForTextOptimized(store, event.text, event.images);
 		return {
 			action: "transform",
-			text: event.text,
-			images: imagesForText(store, event.text, event.images)
+			text: resolvedConfig.includeImagePathsInPrompt ? appendImagePathContext(event.text, attachments) : event.text,
+			images
 		};
 	});
 	pi.on("before_agent_start", () => {
@@ -640,4 +1138,4 @@ function paster(pi, config = {}) {
 	});
 }
 //#endregion
-export { AttachmentStore, CursorImagePreviewWidget, DEFAULT_PASTER_CONFIG, EXTENSION_NAME, ImagePreviewMessage, MAX_IMAGE_BYTES, PASTE_END, PASTE_START, PasterEditor, createImagePasteTerminalInputHandler, createPaster, paster as default, detectImageMimeType, dimensionsForImage, imagesForText, loadImageFromPath, readClipboardImage, replaceImagePathsInText, resolveImagePath, resolvePasterConfig, shellUnescape, tokenizePathLikeText };
+export { ANTHROPIC_MAX_DIMENSION, ANTHROPIC_MAX_IMAGE_BYTES, AttachmentStore, CursorImagePreviewWidget, DEFAULT_PASTER_CONFIG, EXTENSION_NAME, ImagePreviewMessage, MAX_IMAGE_BYTES, PASTE_END, PASTE_START, PasterEditor, appendImagePathContext, createImagePasteTerminalInputHandler, createPaster, paster as default, describeReject, detectImageMimeType, dimensionsForImage, imagesForText, imagesForTextOptimized, isWindowsDrivePath, isWindowsLikePath, isWindowsUncPath, isWsl, loadImageFromPath, optimizeImageBytes, readClipboardImage, replaceImagePathsInText, resolveImagePath, resolvePasterConfig, segmentTextWithAtomicImages, shellUnescape, tokenizePathLikeText, windowsToWslPath };