@askdkc/dsh-cli 0.11.3

package/lib/types/components/messages/TranscriptImages.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Image, Text, useTerminalImages, useTerminalSize } from '../../ui.js';
+import { TERMINAL_IMAGE_PREVIEW_MAX_EDGE, TERMINAL_IMAGE_PREVIEW_MAX_BYTES } from '../../ink/terminal-image.js';
+import { makeDecodeTier } from './transcriptImageDecode.js';
+import { cleanRenderText } from '../../dsh-adapter/sanitize.js';
+import { getLang, subscribeLang, t } from '../../i18n.js';
+const thumbnailTier = makeDecodeTier(384, 24);
+// One modal at a time: current + previous suffices for instant reopen.
+const fullTier = makeDecodeTier(TERMINAL_IMAGE_PREVIEW_MAX_EDGE, 2, TERMINAL_IMAGE_PREVIEW_MAX_BYTES / 4);
+/** Full-resolution (bounded) decode for the modal preview overlay. */
+export const loadTranscriptImageFull = fullTier.load;
+/** Display label for one transcript image: sanitized name, or the generic
+ *  localized fallback. Shared by thumbnails and the preview overlay. */
+export function transcriptImageLabel(image) {
+    const name = cleanRenderText(image.name ?? '', 80);
+    return name || t('transcript-image');
+}
+/** Bounded image gallery shared by user, assistant, and tool-result rows. */
+export function TranscriptImages({ images, indent = 2, onPreview, suppressGraphics = false, }) {
+    const { columns } = useTerminalSize();
+    const graphicsAvailable = useTerminalImages(images.length > 0 && !suppressGraphics);
+    React.useSyncExternalStore(subscribeLang, getLang);
+    if (images.length === 0)
+        return null;
+    const available = Math.max(1, columns - indent - 3);
+    return (_jsx(Box, { flexDirection: "row", flexWrap: "wrap", gap: 1, paddingLeft: indent, width: "100%", children: images.map((image, index) => {
+            const [width, height] = previewSize(image, images.length, available);
+            return (_jsx(TranscriptImagePreview, { image: image, width: width, height: height, graphicsAvailable: graphicsAvailable, onPreview: onPreview }, `${image.id}:${index}`));
+        }) }));
+}
+function TranscriptImagePreview({ image, width, height, graphicsAvailable, onPreview, }) {
+    const [state, setState] = React.useState({ kind: 'loading' });
+    React.useEffect(() => {
+        if (!graphicsAvailable)
+            return;
+        let live = true;
+        const controller = new AbortController();
+        setState({ kind: 'loading' });
+        void thumbnailTier.load(image, controller.signal).then(source => { if (live)
+            setState({ kind: 'ready', source }); }, () => { if (live)
+            setState({ kind: 'failed' }); });
+        return () => { live = false; controller.abort(); };
+    }, [image, graphicsAvailable]);
+    const label = transcriptImageLabel(image);
+    const fallback = !graphicsAvailable
+        ? t('transcript-image-ready', { name: label })
+        : state.kind === 'failed'
+            ? t('transcript-image-unavailable', { name: label })
+            : state.kind === 'loading'
+                ? t('transcript-image-loading', { name: label })
+                : t('transcript-image-ready', { name: label });
+    const preview = (_jsx(Image, { presentation: "transcript", source: graphicsAvailable && state.kind === 'ready' ? state.source : undefined, width: width, height: height, alt: label, children: _jsx(Box, { width: width, height: height, alignItems: "center", justifyContent: "center", children: _jsxs(Text, { dimColor: true, wrap: "truncate", children: ["[", fallback, "]"] }) }) }));
+    if (onPreview === undefined)
+        return preview;
+    return (_jsx(Box, { onClick: event => {
+            // A thumbnail click opens the preview; it must not also toggle the
+            // row expansion or start a transcript selection underneath.
+            event.stopImmediatePropagation();
+            onPreview(image);
+        }, children: preview }));
+}
+function previewSize(image, count, available) {
+    if (count > 1) {
+        const width = Math.max(1, Math.min(10, available));
+        return [width, Math.max(1, Math.round(width / 2))];
+    }
+    const ratio = Math.max(0.25, Math.min(4, image.width / image.height));
+    const maxWidth = Math.max(1, Math.min(24, available));
+    const maxHeight = 12;
+    let width = maxWidth;
+    let height = Math.max(1, Math.round(width / (2 * ratio)));
+    if (height > maxHeight) {
+        height = maxHeight;
+        width = Math.max(1, Math.min(maxWidth, Math.round(2 * height * ratio)));
+    }
+    return [width, height];
+}
+/** @internal Focused regression scripts clear the process-local LRUs. */
+export function clearTranscriptImageCacheForTests() {
+    thumbnailTier.clear();
+    fullTier.clear();
+}

package/lib/types/components/messages/UserPromptMessage.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { ClickEvent } from '../../ink/events/click-event.js';
+type Props = {
+    text: string;
+    /** Adds the top margin between turns. */
+    marginTopOnTurn: boolean;
+    /** Message-selection mode highlight. */
+    isSelected?: boolean;
+    onClick?(event: ClickEvent): void;
+};
+/**
+ * User prompt bubble: `❯ text` in bold userPromptLabel gold with no background
+ * fill (Kimi Code style: the user turn gets a distinct bold tint so it reads
+ * apart from assistant text; only selection mode paints a highlight).
+ */
+export declare function UserPromptMessage({ text, marginTopOnTurn, isSelected, onClick, }: Props): React.ReactNode;
+export {};
+//# sourceMappingURL=UserPromptMessage.d.ts.map

package/lib/types/components/messages/UserPromptMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserPromptMessage.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/UserPromptMessage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAKzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,yCAAyC;IACzC,eAAe,EAAE,OAAO,CAAA;IACxB,wCAAwC;IACxC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;CAClC,CAAA;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,eAAe,EACf,UAAkB,EAClB,OAAO,GACR,EAAE,KAAK,GAAG,KAAK,CAAC,SAAS,CAiCzB"}

package/lib/types/components/messages/UserPromptMessage.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useTerminalSize } from '../../ui.js';
+import { POINTER } from '../../terminal-utils/figures.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { wrapWidth } from '../../sessions/format.js';
+/**
+ * User prompt bubble: `❯ text` in bold userPromptLabel gold with no background
+ * fill (Kimi Code style: the user turn gets a distinct bold tint so it reads
+ * apart from assistant text; only selection mode paints a highlight).
+ */
+export function UserPromptMessage({ text, marginTopOnTurn, isSelected = false, onClick, }) {
+    const { columns } = useTerminalSize();
+    const promptPrefix = `${POINTER} `;
+    const prefixWidth = stringWidth(promptPrefix);
+    // Wrap here instead of letting Ink wrap the whole Text node. Ink starts an
+    // automatic continuation at column zero, while a prompt needs a hanging
+    // indent for both explicit newlines and width-based visual lines.
+    // Leave a small safety margin for the ScrollBox edge/scrollbar. The Text
+    // nodes below are explicitly wrapped, so they must never be wrapped again by
+    // Ink; a second wrap would move the continuation back to column zero.
+    const lines = wrapWidth(text, Math.max(1, columns - prefixWidth - 3));
+    const continuationIndent = ' '.repeat(prefixWidth);
+    // No hover tooltip here, deliberately: the message is pre-wrapped so every
+    // visual line is already on screen — a float would only repeat visible
+    // text, and worse, the card REPLACES the cells it covers, so a drag-copy
+    // crossing it yields the tooltip fragment instead of the message.
+    return (_jsx(Box, { flexDirection: "column", marginTop: marginTopOnTurn ? 1 : 0, backgroundColor: isSelected ? 'messageActionsBackground' : undefined, paddingRight: 1, onClick: onClick, children: lines.map((line, index) => (_jsxs(Text, { color: "userPromptLabel", bold: true, wrap: "truncate-end", children: [index === 0 ? `${POINTER} ` : continuationIndent, line] }, index))) }));
+}

package/lib/types/components/messages/imageInspection.d.ts

@@ -0,0 +1,33 @@
+import type { TranscriptImage } from '../../dsh-adapter/transcript-images.js';
+import type { TerminalCellSize, TerminalImageSource } from '../../ink/terminal-image.js';
+export interface ImageDimensions {
+    readonly width: number;
+    readonly height: number;
+}
+export interface ImageCenter {
+    readonly x: number;
+    readonly y: number;
+}
+export declare const IMAGE_ORIGINAL_MAX_BYTES: number;
+export declare const IMAGE_ZOOM_LEVELS: readonly [1, 2, 4, 8];
+/** Shrink the cell viewport, never the original pixels, when budgets apply. */
+export declare function inspectionCells(columns: number, rows: number, cell: TerminalCellSize): readonly [number, number];
+export declare function inspectionRegion(image: ImageDimensions, viewport: ImageDimensions, zoom: number, center: ImageCenter): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+/** One preview owns one encoded original; no full-resolution JS pixel cache. */
+export declare class ImageInspectionSession {
+    private readonly image;
+    private original;
+    private dimensions;
+    private readonly lifetime;
+    constructor(image: TranscriptImage);
+    private read;
+    metadata(): Promise<ImageDimensions>;
+    render(viewport: ImageDimensions, zoom: number, center: ImageCenter, signal: AbortSignal): Promise<TerminalImageSource>;
+    dispose(): void;
+}
+//# sourceMappingURL=imageInspection.d.ts.map

package/lib/types/components/messages/imageInspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageInspection.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/imageInspection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAG7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AAGxF,MAAM,WAAW,eAAe;IAAG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AACpF,MAAM,WAAW,WAAW;IAAG,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE;AACvE,eAAO,MAAM,wBAAwB,QAAmB,CAAA;AAExD,eAAO,MAAM,iBAAiB,uBAAwB,CAAA;AAEtD,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAQhH;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW;;;;;EAepH;AAED,gFAAgF;AAChF,qBAAa,sBAAsB;IAKrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJlC,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,UAAU,CAAsC;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwB;gBAEpB,KAAK,EAAE,eAAe;IAEnD,OAAO,CAAC,IAAI;IASZ,QAAQ,IAAI,OAAO,CAAC,eAAe,CAAC;IAc9B,MAAM,CAAC,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAoC7H,OAAO,IAAI,IAAI;CAKhB"}

package/lib/types/components/messages/imageInspection.js

@@ -0,0 +1,107 @@
+import { loadSharp } from '../../dsh-adapter/sharp.js';
+import { TERMINAL_IMAGE_PREVIEW_MAX_BYTES, TERMINAL_IMAGE_PREVIEW_MAX_EDGE, TERMINAL_IMAGE_MAX_CELLS } from '../../ink/terminal-image.js';
+import { scheduleImageDecode } from './transcriptImageDecode.js';
+export const IMAGE_ORIGINAL_MAX_BYTES = 64 * 1024 * 1024;
+const INPUT_MAX_PIXELS = 64_000_000;
+export const IMAGE_ZOOM_LEVELS = [1, 2, 4, 8];
+/** Shrink the cell viewport, never the original pixels, when budgets apply. */
+export function inspectionCells(columns, rows, cell) {
+    let width = Math.max(1, Math.min(Math.floor(columns), Math.floor(TERMINAL_IMAGE_PREVIEW_MAX_EDGE / cell.width)));
+    let height = Math.max(1, Math.min(Math.floor(rows), Math.floor(TERMINAL_IMAGE_PREVIEW_MAX_EDGE / cell.height)));
+    const scale = Math.min(1, Math.sqrt(TERMINAL_IMAGE_PREVIEW_MAX_BYTES / (4 * width * height * cell.width * cell.height)), Math.sqrt(TERMINAL_IMAGE_MAX_CELLS / (width * height)));
+    width = Math.max(1, Math.floor(width * scale));
+    height = Math.max(1, Math.floor(height * scale));
+    return [width, height];
+}
+export function inspectionRegion(image, viewport, zoom, center) {
+    if (!IMAGE_ZOOM_LEVELS.some(value => value === zoom) ||
+        ![image.width, image.height, viewport.width, viewport.height].every(value => Number.isSafeInteger(value) && value > 0) ||
+        !Number.isFinite(center.x) || !Number.isFinite(center.y) ||
+        viewport.width > TERMINAL_IMAGE_PREVIEW_MAX_EDGE || viewport.height > TERMINAL_IMAGE_PREVIEW_MAX_EDGE ||
+        viewport.width * viewport.height * 4 > TERMINAL_IMAGE_PREVIEW_MAX_BYTES) {
+        throw new Error('Invalid original-pixel viewport');
+    }
+    const width = Math.min(image.width, Math.ceil(viewport.width / zoom));
+    const height = Math.min(image.height, Math.ceil(viewport.height / zoom));
+    return {
+        left: Math.max(0, Math.min(image.width - width, Math.round(center.x - width / 2))),
+        top: Math.max(0, Math.min(image.height - height, Math.round(center.y - height / 2))),
+        width, height,
+    };
+}
+/** One preview owns one encoded original; no full-resolution JS pixel cache. */
+export class ImageInspectionSession {
+    image;
+    original;
+    dimensions;
+    lifetime = new AbortController();
+    constructor(image) {
+        this.image = image;
+    }
+    read() {
+        this.lifetime.signal.throwIfAborted();
+        return this.original ??= this.image.read(this.lifetime.signal).then(data => {
+            this.lifetime.signal.throwIfAborted();
+            if (data.byteLength > IMAGE_ORIGINAL_MAX_BYTES)
+                throw new Error('Original image byte budget exceeded');
+            return data;
+        });
+    }
+    metadata() {
+        return this.dimensions ??= scheduleImageDecode(this.lifetime.signal, async () => {
+            const data = await this.read();
+            const sharp = await loadSharp();
+            this.lifetime.signal.throwIfAborted();
+            if (!sharp)
+                throw new Error('Image decoder unavailable');
+            const metadata = await sharp(data, { failOn: 'error', limitInputPixels: INPUT_MAX_PIXELS }).metadata();
+            this.lifetime.signal.throwIfAborted();
+            const { width, height } = metadata.autoOrient;
+            if (!width || !height || width * height > INPUT_MAX_PIXELS)
+                throw new Error('Invalid original image dimensions');
+            return { width, height };
+        }, true);
+    }
+    async render(viewport, zoom, center, signal) {
+        signal.throwIfAborted();
+        const dimensions = await this.metadata();
+        signal.throwIfAborted();
+        return scheduleImageDecode(signal, async () => {
+            signal.throwIfAborted();
+            const data = await this.read();
+            const sharp = await loadSharp();
+            signal.throwIfAborted();
+            this.lifetime.signal.throwIfAborted();
+            if (!sharp)
+                throw new Error('Image decoder unavailable');
+            const crop = inspectionRegion(dimensions, viewport, zoom, center);
+            // Crop the original BEFORE resizing. Nearest keeps each source pixel an
+            // exact zoom-by-zoom block, including on non-cell-aligned pan positions.
+            const pipeline = sharp(data, { failOn: 'error', limitInputPixels: INPUT_MAX_PIXELS })
+                .autoOrient().extract(crop);
+            if (zoom !== 1)
+                pipeline.resize(crop.width * zoom, crop.height * zoom, { kernel: 'nearest', fit: 'fill' });
+            const decoded = await pipeline.toColourspace('srgb').ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+            signal.throwIfAborted();
+            this.lifetime.signal.throwIfAborted();
+            if (decoded.info.channels !== 4 || decoded.info.width !== crop.width * zoom || decoded.info.height !== crop.height * zoom) {
+                throw new Error('Unexpected original-pixel crop geometry');
+            }
+            const output = new Uint8Array(viewport.width * viewport.height * 4);
+            const width = Math.min(viewport.width, decoded.info.width);
+            const height = Math.min(viewport.height, decoded.info.height);
+            const left = Math.max(0, Math.floor((viewport.width - decoded.info.width) / 2));
+            const top = Math.max(0, Math.floor((viewport.height - decoded.info.height) / 2));
+            for (let row = 0; row < height; row++) {
+                const offset = row * decoded.info.width * 4;
+                output.set(decoded.data.subarray(offset, offset + width * 4), ((row + top) * viewport.width + left) * 4);
+            }
+            return { data: output, ...viewport };
+        }, true);
+    }
+    dispose() {
+        this.lifetime.abort();
+        this.original = undefined;
+        this.dimensions = undefined;
+    }
+}

package/lib/types/components/messages/originalImage.d.ts

@@ -0,0 +1,5 @@
+import type { TranscriptImage } from '../../dsh-adapter/transcript-images.js';
+/** Only called by an explicit open action. Keep exact bytes in OS temp storage
+ * after closing the TUI, since an external viewer may read the file later. */
+export declare function exportOriginalImage(image: TranscriptImage, signal?: AbortSignal): Promise<string>;
+//# sourceMappingURL=originalImage.d.ts.map

package/lib/types/components/messages/originalImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"originalImage.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/originalImage.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAgB7E;8EAC8E;AAC9E,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CA6BvG"}

package/lib/types/components/messages/originalImage.js

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+import { chmod, mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { IMAGE_ORIGINAL_MAX_BYTES } from './imageInspection.js';
+const exportsByImage = new WeakMap();
+let directory;
+/** Signature-derived extension: never let an attachment name select a program. */
+function originalExtension(data) {
+    const head = Buffer.from(data.buffer, data.byteOffset, Math.min(data.byteLength, 12));
+    if (head.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+        return 'png';
+    if (head[0] === 255 && head[1] === 216 && head[2] === 255)
+        return 'jpg';
+    if (head.subarray(0, 6).toString('ascii') === 'GIF87a' || head.subarray(0, 6).toString('ascii') === 'GIF89a')
+        return 'gif';
+    if (head.subarray(0, 4).toString('ascii') === 'RIFF' && head.subarray(8, 12).toString('ascii') === 'WEBP')
+        return 'webp';
+    throw new Error('Unsupported original image format');
+}
+/** Only called by an explicit open action. Keep exact bytes in OS temp storage
+ * after closing the TUI, since an external viewer may read the file later. */
+export async function exportOriginalImage(image, signal) {
+    signal?.throwIfAborted();
+    let pending = exportsByImage.get(image);
+    if (!pending) {
+        pending = (async () => {
+            const data = await image.read(signal);
+            signal?.throwIfAborted();
+            if (data.byteLength > IMAGE_ORIGINAL_MAX_BYTES)
+                throw new Error('Original image byte budget exceeded');
+            const extension = originalExtension(data);
+            const digest = createHash('sha256').update(data).digest('hex');
+            directory ??= mkdtemp(join(tmpdir(), 'dsh-tui-original-')).then(async (path) => {
+                await chmod(path, 0o700);
+                return path;
+            }).catch(error => { directory = undefined; throw error; });
+            const path = join(await directory, `${digest}.${extension}`);
+            signal?.throwIfAborted();
+            try {
+                await writeFile(path, data, { flag: 'wx', mode: 0o600 });
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+            return path;
+        })();
+        exportsByImage.set(image, pending);
+        void pending.catch(() => { if (exportsByImage.get(image) === pending)
+            exportsByImage.delete(image); });
+    }
+    const path = await pending;
+    signal?.throwIfAborted();
+    return path;
+}

package/lib/types/components/messages/transcriptImageDecode.d.ts

@@ -0,0 +1,9 @@
+import type { TerminalImageSource } from '../../ink/terminal-image.js';
+import type { TranscriptImage } from '../../dsh-adapter/transcript-images.js';
+export declare function scheduleImageDecode<T>(signal: AbortSignal, work: () => Promise<T>, priority: boolean): Promise<T>;
+/** Bounded LRU keyed by durable facade identity, with shared cancellation. */
+export declare function makeDecodeTier(maxPixels: number, limit: number, maxDecodedPixels?: number): {
+    load: (image: TranscriptImage, signal?: AbortSignal) => Promise<TerminalImageSource>;
+    clear: () => void;
+};
+//# sourceMappingURL=transcriptImageDecode.d.ts.map

package/lib/types/components/messages/transcriptImageDecode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcriptImageDecode.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/transcriptImageDecode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAS7E,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CA0BjH;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,SAAwB;kBAuDlF,eAAe,WAAW,WAAW,KAAG,OAAO,CAAC,mBAAmB,CAAC;iBA0B/D,IAAI;EAI/B"}

package/lib/types/components/messages/transcriptImageDecode.js

@@ -0,0 +1,144 @@
+import { loadSharp } from '../../dsh-adapter/sharp.js';
+// Share the attachment I/O and native decode budget across resolution tiers.
+let activeDecodes = 0;
+const decodeQueue = [];
+function pumpDecodes() {
+    while (activeDecodes < 2 && decodeQueue.length)
+        decodeQueue.shift().start();
+}
+export function scheduleImageDecode(signal, work, priority) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        if (decodeQueue.length >= (priority ? 65 : 64)) {
+            reject(new Error('Image decode queue budget exceeded'));
+            return;
+        }
+        const job = {
+            start: () => {
+                signal.removeEventListener('abort', job.cancel);
+                if (signal.aborted) {
+                    reject(signal.reason);
+                    return;
+                }
+                activeDecodes++;
+                void Promise.resolve().then(work).then(resolve, reject).finally(() => {
+                    activeDecodes--;
+                    pumpDecodes();
+                });
+            },
+            cancel: () => {
+                const index = decodeQueue.indexOf(job);
+                if (index >= 0)
+                    decodeQueue.splice(index, 1);
+                signal.removeEventListener('abort', job.cancel);
+                reject(signal.reason);
+            },
+        };
+        signal.addEventListener('abort', job.cancel, { once: true });
+        if (priority)
+            decodeQueue.unshift(job);
+        else
+            decodeQueue.push(job);
+        pumpDecodes();
+    });
+}
+/** Bounded LRU keyed by durable facade identity, with shared cancellation. */
+export function makeDecodeTier(maxPixels, limit, maxDecodedPixels = maxPixels * maxPixels) {
+    const cache = new Map();
+    const trim = () => {
+        for (const [image, entry] of cache) {
+            if (cache.size <= limit)
+                break;
+            if (entry.settled && entry.refs === 0)
+                cache.delete(image);
+        }
+    };
+    const create = (image) => {
+        const controller = new AbortController();
+        const signal = controller.signal;
+        const pending = scheduleImageDecode(signal, async () => {
+            signal.throwIfAborted();
+            const data = await image.read(signal);
+            signal.throwIfAborted();
+            const sharp = await loadSharp();
+            signal.throwIfAborted();
+            if (sharp === undefined)
+                throw new Error('sharp is unavailable');
+            const decoder = sharp(data, { failOn: 'error' });
+            let width = maxPixels;
+            let height = maxPixels;
+            if (maxDecodedPixels < maxPixels * maxPixels) {
+                const metadata = await decoder.metadata();
+                signal.throwIfAborted();
+                const inputWidth = metadata.width ?? image.width;
+                const inputHeight = metadata.height ?? image.height;
+                if (!Number.isSafeInteger(inputWidth) || !Number.isSafeInteger(inputHeight) || inputWidth < 1 || inputHeight < 1) {
+                    throw new Error('invalid image dimensions');
+                }
+                const scale = Math.min(1, maxPixels / inputWidth, maxPixels / inputHeight, Math.sqrt(maxDecodedPixels / (inputWidth * inputHeight)));
+                width = Math.max(1, Math.floor(inputWidth * scale));
+                height = Math.max(1, Math.floor(inputHeight * scale));
+            }
+            const decoded = await decoder
+                .resize({ width, height, fit: 'inside', withoutEnlargement: true })
+                .toColourspace('srgb')
+                .ensureAlpha()
+                .raw()
+                .toBuffer({ resolveWithObject: true });
+            signal.throwIfAborted();
+            if (decoded.info.channels !== 4 || decoded.data.byteLength !== decoded.info.width * decoded.info.height * 4) {
+                throw new Error('decoded image is not RGBA');
+            }
+            if (decoded.data.byteLength > maxDecodedPixels * 4)
+                throw new Error('Image decode pixel budget exceeded');
+            return { data: decoded.data, width: decoded.info.width, height: decoded.info.height };
+        }, maxPixels > 384);
+        const entry = { promise: pending, controller, refs: 0, settled: false };
+        void pending.then(() => { entry.settled = true; trim(); }, () => {
+            entry.settled = true;
+            if (cache.get(image) === entry)
+                cache.delete(image);
+        });
+        return entry;
+    };
+    const load = (image, signal) => {
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        const entry = cache.get(image) ?? create(image);
+        cache.delete(image);
+        cache.set(image, entry);
+        entry.refs++;
+        trim();
+        return new Promise((resolve, reject) => {
+            let released = false;
+            const release = () => {
+                if (released)
+                    return false;
+                released = true;
+                signal?.removeEventListener('abort', abort);
+                entry.refs--;
+                if (!entry.settled && entry.refs === 0) {
+                    if (cache.get(image) === entry)
+                        cache.delete(image);
+                    entry.controller.abort();
+                }
+                trim();
+                return true;
+            };
+            const abort = () => { if (release())
+                reject(signal?.reason); };
+            signal?.addEventListener('abort', abort, { once: true });
+            void entry.promise.then(value => { if (release())
+                resolve(value); }, error => { if (release())
+                reject(error); });
+        });
+    };
+    return { load, clear: () => {
+            for (const entry of cache.values())
+                entry.controller.abort();
+            cache.clear();
+        } };
+}

package/lib/types/components/messages/useImageInspection.d.ts

@@ -0,0 +1,10 @@
+import type { TranscriptImage } from '../../dsh-adapter/transcript-images.js';
+import type { TerminalCellSize, TerminalImageSource } from '../../ink/terminal-image.js';
+import type { DragEvent } from '../../ink/events/drag-event.js';
+export declare function useImageInspection(image: TranscriptImage, available: boolean, columns: number, rows: number, cell: TerminalCellSize | undefined, zoom: number): {
+    source: TerminalImageSource | undefined;
+    failed: boolean;
+    pan: (x: number, y: number) => void;
+    drag: (event: DragEvent) => void;
+};
+//# sourceMappingURL=useImageInspection.d.ts.map

package/lib/types/components/messages/useImageInspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImageInspection.d.ts","sourceRoot":"","sources":["../../../../src/components/messages/useImageInspection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACxF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAA;AAQ/D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAC1G,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM;;;aA4ErC,MAAM,KAAK,MAAM,KAAG,IAAI;kBAfI,SAAS;EAmBjD"}

package/lib/types/components/messages/useImageInspection.js

@@ -0,0 +1,91 @@
+import React from 'react';
+import { ImageInspectionSession, inspectionRegion } from './imageInspection.js';
+import { loadTranscriptImageFull } from './TranscriptImages.js';
+// The attachment is identified by `image.id` (a content hash), never by the
+// facade object: callers may hand a fresh facade for the same attachment on
+// every render, and keying effects or memos on the object would then restart
+// the session and re-request pixels each commit — a render loop (#885).
+export function useImageInspection(image, available, columns, rows, cell, zoom) {
+    const imageId = image.id;
+    // Committed facade for the loaders below. Written in a layout effect, not
+    // during render: an interrupted render must not leak its facade into a
+    // timer that an earlier commit already scheduled.
+    const latestImage = React.useRef(image);
+    React.useLayoutEffect(() => { latestImage.current = image; }, [image]);
+    const session = React.useRef(null);
+    const [position, setPosition] = React.useState(null);
+    const center = position?.imageId === imageId ? position.center : undefined;
+    const dimensions = React.useRef(null);
+    React.useEffect(() => {
+        const current = new ImageInspectionSession(latestImage.current);
+        session.current = current;
+        dimensions.current = null;
+        setPosition(null);
+        return () => { current.dispose(); session.current = null; };
+    }, [imageId]);
+    const request = React.useMemo(() => ({ imageId, available, columns, rows, cell, zoom, center }), [imageId, available, columns, rows, cell, zoom, center]);
+    const [result, setResult] = React.useState(null);
+    React.useEffect(() => {
+        if (!available || (zoom > 0 && !cell))
+            return;
+        const controller = new AbortController();
+        const current = session.current;
+        // Coalesce drag/wheel bursts before starting native work. The shared
+        // scheduler also bounds jobs already running when a request is cancelled.
+        const timer = setTimeout(() => {
+            void (async () => {
+                if (zoom === 0)
+                    return loadTranscriptImageFull(latestImage.current, controller.signal);
+                const size = await current.metadata();
+                controller.signal.throwIfAborted();
+                dimensions.current = size;
+                return current.render({ width: columns * cell.width, height: rows * cell.height }, zoom, center ?? { x: size.width / 2, y: size.height / 2 }, controller.signal);
+            })().then(source => {
+                if (!controller.signal.aborted)
+                    setResult({ request, source });
+            }, () => {
+                if (!controller.signal.aborted)
+                    setResult({ request, failed: true });
+            });
+        }, zoom === 0 ? 0 : 100);
+        return () => { clearTimeout(timer); controller.abort(); };
+    }, [request]);
+    const clampedCenter = React.useCallback((value) => {
+        const size = dimensions.current;
+        if (!size || !cell || zoom === 0)
+            return undefined;
+        const crop = inspectionRegion(size, { width: columns * cell.width, height: rows * cell.height }, zoom, value ?? center ?? { x: size.width / 2, y: size.height / 2 });
+        return { x: crop.left + crop.width / 2, y: crop.top + crop.height / 2 };
+    }, [center, cell, columns, rows, zoom]);
+    const move = React.useCallback((x, y, origin) => {
+        const previous = origin ?? clampedCenter();
+        if (!previous)
+            return;
+        const next = clampedCenter({ x: previous.x + x, y: previous.y + y });
+        if (next)
+            setPosition(old => old?.imageId === imageId && old.center.x === next.x && old.center.y === next.y
+                ? old : { imageId, center: next });
+    }, [clampedCenter, imageId]);
+    const dragOrigin = React.useRef(undefined);
+    const drag = React.useCallback((event) => {
+        event.stopImmediatePropagation();
+        if (!cell || zoom === 0)
+            return;
+        if (event.type === 'dragstart')
+            dragOrigin.current = clampedCenter();
+        if (dragOrigin.current)
+            move((event.startCol - event.col) * cell.width / zoom, (event.startRow - event.row) * cell.height / zoom, dragOrigin.current);
+        if (event.type === 'dragend')
+            dragOrigin.current = undefined;
+    }, [cell, zoom, clampedCenter, move]);
+    // Preserve the previous pixels while panning, but never stretch stale pixels
+    // across a new geometry, zoom, terminal cell size, or attachment.
+    const reusable = result?.request.imageId === imageId && result.request.zoom === zoom &&
+        result.request.columns === columns && result.request.rows === rows && result.request.cell === cell;
+    return {
+        source: available && reusable ? result?.source : undefined,
+        failed: result?.request === request && result.failed === true,
+        pan: (x, y) => move(x * columns * (cell?.width ?? 1) / Math.max(1, zoom) / 4, y * rows * (cell?.height ?? 1) / Math.max(1, zoom) / 4),
+        drag,
+    };
+}