pi-paster 0.1.5 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-paster",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "description": "Pi extension that turns pasted image paths into first-class image attachments.",
   "keywords": [
     "image-attachments",
@@ -50,11 +50,14 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },
+  "optionalDependencies": {
+    "sharp": "^0.34.0"
+  },
   "packageManager": "pnpm@11.1.2",
   "pi": {
     "extensions": [
       "./src/index.ts"
     ],
-    "image": "https://unpkg.com/pi-paster@0.1.5/docs/preview.png"
+    "image": "https://unpkg.com/pi-paster@0.2.1/docs/preview.png"
   }
 }

package/src/clipboard.ts

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { detectImageMimeType, dimensionsForImage } from "./image-utils.ts";
@@ -14,8 +14,78 @@ export type ClipboardImageResult =
     };
 
 export function readClipboardImage(maxBytes = MAX_IMAGE_BYTES): ClipboardImageResult {
-  if (process.platform !== "darwin") return { ok: false, reason: "unsupported-platform" };
-  return readMacOSClipboardImage(maxBytes);
+  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" };
+}
+
+function isWSL(): boolean {
+  try {
+    return /microsoft|wsl/i.test(readFileSync("/proc/version", "utf8"));
+  } catch {
+    return false;
+  }
+}
+
+function resolvePowerShell(): string | null {
+  if (process.platform === "win32") return "powershell.exe";
+  const candidates = [
+    "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe",
+    "/mnt/c/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe",
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return "powershell.exe";
+}
+
+function readWindowsClipboardImage(maxBytes: number): ClipboardImageResult {
+  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: 5000,
+      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: number): ClipboardImageResult {

package/src/config.ts

@@ -1,4 +1,10 @@
+export type SubmittedPreviewStyle = "raw" | "collapsible";
+
 export interface PasterConfig {
+  /** How submitted attachment previews render in chat history. */
+  submittedPreviewStyle?: SubmittedPreviewStyle;
+  /** Append local image paths to the submitted prompt so the agent can manipulate the source files. */
+  includeImagePathsInPrompt?: boolean;
   customEditor?: {
     /** Replace pi's input editor to enable inline image UX features. */
     enabled?: boolean;
@@ -10,6 +16,8 @@ export interface PasterConfig {
 }
 
 export interface ResolvedPasterConfig {
+  submittedPreviewStyle: SubmittedPreviewStyle;
+  includeImagePathsInPrompt: boolean;
   customEditor: {
     enabled: boolean;
     showImagePreview: boolean;
@@ -18,6 +26,8 @@ export interface ResolvedPasterConfig {
 }
 
 export const DEFAULT_PASTER_CONFIG: ResolvedPasterConfig = {
+  submittedPreviewStyle: "raw",
+  includeImagePathsInPrompt: true,
   customEditor: {
     enabled: true,
     showImagePreview: true,
@@ -27,6 +37,10 @@ export const DEFAULT_PASTER_CONFIG: ResolvedPasterConfig = {
 
 export function resolvePasterConfig(config: PasterConfig = {}): ResolvedPasterConfig {
   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:

package/src/editor.ts

@@ -1,12 +1,65 @@
 import { CustomEditor, type KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
-import { replaceImagePathsInText } from "./image-utils.ts";
+import { describeReject, replaceImagePathsInText } from "./image-utils.ts";
 import type { AttachmentStore } from "./store.ts";
 import type { ImageAttachment } from "./types.ts";
 
 export const PASTE_START = "\x1b[200~";
 export 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();
+
+interface AtomicSpan {
+  start: number;
+  end: number;
+}
+
+interface EditorSegmentationAccess {
+  segment?: (text: string) => Iterable<Intl.SegmentData>;
+  pastes?: Map<number, string>;
+}
+
+function atomicSpansForText(text: string, validPasteIds: Set<number>): AtomicSpan[] {
+  const spans: AtomicSpan[] = [];
+
+  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);
+}
+
+export function segmentTextWithAtomicImages(
+  text: string,
+  store: AttachmentStore,
+  validPasteIds: Set<number> = new Set(),
+): Intl.SegmentData[] {
+  const spans = atomicSpansForText(text, validPasteIds);
+  if (spans.length === 0) return [...baseSegmenter.segment(text)];
+
+  const result: Intl.SegmentData[] = [];
+  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;
+}
 
 interface EditorCursor {
   line: number;
@@ -14,7 +67,8 @@ interface EditorCursor {
 }
 
 interface PlaceholderAtCursor {
-  attachment: ImageAttachment;
+  attachment?: ImageAttachment;
+  placeholder: string;
   line: number;
   start: number;
   end: number;
@@ -32,16 +86,16 @@ function findPlaceholderAtCursor(
     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, line: cursor.line, start, end };
+      return { attachment, placeholder, line: cursor.line, start, end };
     }
     if (mode === "backspace" && cursor.col > start && cursor.col <= end) {
-      return { attachment, line: cursor.line, start, end };
+      return { attachment, placeholder, line: cursor.line, start, end };
     }
     if (mode === "delete" && cursor.col >= start && cursor.col < end) {
-      return { attachment, line: cursor.line, start, end };
+      return { attachment, placeholder, line: cursor.line, start, end };
     }
   }
   return undefined;
@@ -76,6 +130,7 @@ export class PasterEditor extends CustomEditor {
     },
   ) {
     super(tui, theme, pasterKeybindings);
+    this.installAtomicImageSegmentation();
     this.onPasteImage = () => {
       void this.handlePasteClipboardImage();
     };
@@ -89,6 +144,7 @@ export class PasterEditor extends CustomEditor {
 
   override handleInput(data: string): void {
     if (this.handleBracketedPaste(data)) return;
+    if (this.handleAtomicPlaceholderNavigation(data)) return;
     if (this.pasterOptions.deletePlaceholderAsBlock && this.handleAtomicPlaceholderDelete(data))
       return;
 
@@ -101,6 +157,16 @@ export class PasterEditor extends CustomEditor {
     this.pasterOptions.setCursorPreview(undefined);
   }
 
+  private installAtomicImageSegmentation(): void {
+    const editor = this as unknown as EditorSegmentationAccess;
+    editor.segment = (text: string) =>
+      segmentTextWithAtomicImages(
+        text,
+        this.pasterOptions.store,
+        new Set(editor.pastes?.keys() ?? []),
+      );
+  }
+
   private async handlePasteClipboardImage(): Promise<void> {
     const attachment = await this.pasterOptions.pasteClipboardImage?.();
     if (!attachment) return;
@@ -149,6 +215,29 @@ export class PasterEditor extends CustomEditor {
     return true;
   }
 
+  private handleAtomicPlaceholderNavigation(data: string): boolean {
+    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;
+  }
+
   private handleAtomicPlaceholderDelete(data: string): boolean {
     const isBackspace = this.pasterKeybindings.matches(data, "tui.editor.deleteCharBackward");
     const isDelete = this.pasterKeybindings.matches(data, "tui.editor.deleteCharForward");
@@ -168,17 +257,22 @@ export class PasterEditor extends CustomEditor {
     return true;
   }
 
+  private setCursor(col: number): void {
+    const editor = this as unknown as EditorStateAccess;
+    if (editor.setCursorCol) {
+      editor.setCursorCol(col);
+    } else {
+      editor.state.cursorCol = col;
+    }
+  }
+
   private deleteLineRange(lineIndex: number, start: number, end: number): void {
     const editor = this as unknown as EditorStateAccess;
     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());
@@ -189,13 +283,7 @@ export class PasterEditor 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),
     });
   }
 
@@ -206,7 +294,7 @@ export class PasterEditor extends CustomEditor {
       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);

package/src/image-utils.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
+import { platform } from "node:process";
 import { getImageDimensions } from "@earendil-works/pi-tui";
 import type { AttachmentStore } from "./store.ts";
 import {
@@ -10,14 +11,18 @@ import {
   type PasterImageContent,
   type SupportedImageMimeType,
 } from "./types.ts";
+import { optimizeImageBytes } from "./optimize-image.ts";
 
 interface PathToken {
   raw: string;
   value: string;
   start: number;
   end: number;
+  bare: boolean;
 }
 
+const MAX_BARE_PATH_EXTENSIONS = 8;
+
 export function detectImageMimeType(bytes: Uint8Array): SupportedImageMimeType | undefined {
   if (
     bytes.length >= 8 &&
@@ -62,9 +67,62 @@ export function detectImageMimeType(bytes: Uint8Array): SupportedImageMimeType |
   return undefined;
 }
 
+const WINDOWS_DRIVE_PATH = /^([a-zA-Z]):[\\/](.*)$/;
+
+export function isWindowsDrivePath(value: string): boolean {
+  return WINDOWS_DRIVE_PATH.test(value);
+}
+
+export function isWindowsUncPath(value: string): boolean {
+  return value.startsWith("\\\\") && value.length > 2;
+}
+
+export function isWindowsLikePath(value: string): boolean {
+  return isWindowsDrivePath(value) || isWindowsUncPath(value);
+}
+
+let cachedIsWsl: boolean | undefined;
+export function isWsl(): boolean {
+  if (cachedIsWsl !== undefined) 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;
+}
+
+export function windowsToWslPath(windowsPath: string): string {
+  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)) {
+    // \\server\share\path -> //wsl.localhost-style not generally translatable; pass through.
+    return windowsPath.replace(/\\/g, "/");
+  }
+  return windowsPath;
+}
+
 export function resolveImagePath(input: string, cwd: string): string {
   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);
 }
@@ -88,10 +146,26 @@ function isPathLike(value: string): boolean {
     value.startsWith("~/") ||
     value === "~" ||
     value.startsWith("./") ||
-    value.startsWith("../")
+    value.startsWith("../") ||
+    isWindowsLikePath(value)
   );
 }
 
+function startsWithWindowsPath(text: string, index: number): boolean {
+  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;
+}
+
 export function tokenizePathLikeText(text: string): PathToken[] {
   const tokens: PathToken[] = [];
   let index = 0;
@@ -107,11 +181,12 @@ export function tokenizePathLikeText(text: string): PathToken[] {
     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;
@@ -125,15 +200,16 @@ export function tokenizePathLikeText(text: string): PathToken[] {
         index++;
       }
       if (closed && isPathLike(value))
-        tokens.push({ raw: text.slice(start, index), value, start, end: index });
+        tokens.push({ raw: text.slice(start, index), value, start, 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;
@@ -141,13 +217,57 @@ export function tokenizePathLikeText(text: string): PathToken[] {
       rawValue += current;
       index++;
     }
-    const value = shellUnescape(rawValue);
-    if (isPathLike(value)) tokens.push({ raw: rawValue, value, start, end: index });
+    const value = windowsMode ? rawValue : shellUnescape(rawValue);
+    if (isPathLike(value)) tokens.push({ raw: rawValue, value, start, end: index, bare: true });
   }
 
   return tokens;
 }
 
+function tryExtendBareToken(
+  text: string,
+  token: PathToken,
+  attempt: (path: string) => LoadImageResult,
+): { value: string; end: number; result: LoadImageResult } {
+  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 };
+}
+
 export function dimensionsForImage(data: string, mimeType: SupportedImageMimeType) {
   return getImageDimensions(data, mimeType) ?? undefined;
 }
@@ -202,16 +322,18 @@ export function replaceImagePathsInText(
   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++;
   }
 
@@ -234,3 +356,70 @@ export function imagesForText(
     })),
   ];
 }
+
+export function appendImagePathContext(text: string, attachments: ImageAttachment[]): string {
+  if (attachments.length === 0) return text;
+  const lines = attachments.map(
+    (attachment) => `- ${attachment.placeholder}: ${attachment.originalPath}`,
+  );
+  return `${text}\n\nAttached image paths:\n${lines.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.
+ */
+export async function imagesForTextOptimized(
+  store: AttachmentStore,
+  text: string,
+  existing: PasterImageContent[] = [],
+): Promise<PasterImageContent[]> {
+  const attachments = store.matchingPlaceholders(text);
+  const optimized: PasterImageContent[] = [];
+  for (const attachment of attachments) {
+    if (!attachment.optimized) {
+      try {
+        const input = Buffer.from(attachment.data, "base64");
+        const result = await optimizeImageBytes(input, 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 {
+        // optimization is best-effort; fall through with the original bytes
+        attachment.optimized = true;
+      }
+    }
+    optimized.push({
+      type: "image",
+      mimeType: attachment.mimeType,
+      data: attachment.data,
+    });
+  }
+  return [...existing, ...optimized];
+}
+
+export function describeReject(
+  result: Exclude<LoadImageResult, { ok: true }>,
+  notify?: (message: string) => void,
+): void {
+  if (!notify) return;
+  if (result.reason === "too-large") {
+    notify(`paster: image is too large and was not attached: ${result.path}`);
+  }
+}