@timurproko/a1 0.1.8-dev.287 → 0.1.8-dev.289

package/dist/contracts/owned-ui/image-attachments.d.ts

@@ -7,6 +7,15 @@ declare const MESSAGES: {
     readonly "image-count": "A prompt supports at most 8 images. Remove an attachment before adding another.";
     readonly "image-data": "Image data is invalid. Paste a valid image again.";
     readonly "image-mime": "Image MIME type is invalid. Paste a supported image again.";
+    readonly "image-source-size": "Source image exceeds 20 MiB. Reduce the source size and paste it again.";
+    readonly "image-pixels": "Source image exceeds 40 million pixels or a 32768-pixel dimension. Reduce its dimensions and paste again.";
+    readonly "image-conversion": "This image cannot be safely resized. Paste a PNG or JPEG screenshot instead.";
+    readonly "image-codec": "Image preparation is unavailable. Check the installation and paste again.";
+    readonly "image-output": "Image cannot fit the output limits without excessive quality loss. Crop it and paste again.";
+    readonly "image-timeout": "Image preparation timed out. Remove the failed image and paste again.";
+    readonly "image-busy": "Image preparation is full (8 pending images). Wait or remove an image before pasting again.";
+    readonly "image-canceled": "Image preparation was canceled. Paste the image again.";
+    readonly "image-pending": "Image is still preparing. Wait before submitting.";
 };
 /** Trusted, payload-free diagnostics for user-correctable attachment failures. */
 export declare class ImageAttachmentError extends TypeError {

package/dist/contracts/owned-ui/image-attachments.js

@@ -6,6 +6,15 @@ const MESSAGES = {
     "image-count": "A prompt supports at most 8 images. Remove an attachment before adding another.",
     "image-data": "Image data is invalid. Paste a valid image again.",
     "image-mime": "Image MIME type is invalid. Paste a supported image again.",
+    "image-source-size": "Source image exceeds 20 MiB. Reduce the source size and paste it again.",
+    "image-pixels": "Source image exceeds 40 million pixels or a 32768-pixel dimension. Reduce its dimensions and paste again.",
+    "image-conversion": "This image cannot be safely resized. Paste a PNG or JPEG screenshot instead.",
+    "image-codec": "Image preparation is unavailable. Check the installation and paste again.",
+    "image-output": "Image cannot fit the output limits without excessive quality loss. Crop it and paste again.",
+    "image-timeout": "Image preparation timed out. Remove the failed image and paste again.",
+    "image-busy": "Image preparation is full (8 pending images). Wait or remove an image before pasting again.",
+    "image-canceled": "Image preparation was canceled. Paste the image again.",
+    "image-pending": "Image is still preparing. Wait before submitting.",
 };
 /** Trusted, payload-free diagnostics for user-correctable attachment failures. */
 export class ImageAttachmentError extends TypeError {
@@ -23,6 +32,8 @@ export function assertImageEncodedSize(data) {
     if (Math.ceil(data.length / 4) * 4 > MAX_IMAGE_DATA_BYTES)
         throw new ImageAttachmentError("image-size");
 }
+const VALIDATED_IMAGES = new WeakSet();
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 /** Final command admission also covers restored and deferred non-clipboard inputs. */
 export function assertPromptImages(images) {
     if (!Array.isArray(images) || images.length > MAX_PROMPT_IMAGES)
@@ -30,13 +41,20 @@ export function assertPromptImages(images) {
     for (const image of images) {
         if (!image || image.type !== "image")
             throw new ImageAttachmentError("image-data");
+        if (VALIDATED_IMAGES.has(image))
+            continue;
         assertImageEncodedSize(image.data);
         if (!/^[A-Za-z0-9+/]+={0,2}$/.test(image.data) || image.data.length % 4 !== 0
-            || Buffer.from(image.data, "base64").toString("base64") !== image.data) {
+            || (image.data.endsWith("==") && (BASE64_ALPHABET.indexOf(image.data.at(-3) ?? "") & 15) !== 0)
+            || (image.data.endsWith("=") && !image.data.endsWith("==") && (BASE64_ALPHABET.indexOf(image.data.at(-2) ?? "") & 3) !== 0)) {
             throw new ImageAttachmentError("image-data");
         }
         if (typeof image.mimeType !== "string" || image.mimeType.length > 256 || !/^image\/[a-z0-9.+-]+$/i.test(image.mimeType)) {
             throw new ImageAttachmentError("image-mime");
         }
+        // Security: cache only immutable own data properties, never frozen objects with changing getters.
+        if (Object.isFrozen(image) && ["type", "data", "mimeType"].every(key => Object.getOwnPropertyDescriptor(image, key)?.value === image[key])) {
+            VALIDATED_IMAGES.add(image);
+        }
     }
 }

package/dist/integrations/pi/components/owned-editor-ux.d.ts

@@ -15,6 +15,7 @@ export interface OwnedEditorUxInterceptor {
     hasSelection?(): boolean;
     ownsPointer?(): boolean;
     pasteClipboard?(): boolean;
+    cancelPendingPastes?(): void;
 }
 export interface OwnedEditorPointerEvent {
     readonly kind: "press" | "motion" | "release";
@@ -36,6 +37,7 @@ export declare class OwnedEditorUxInterception {
     handleInput(data: string): void;
     render(width: number): string[];
     reset(): void;
+    cancelPendingPastes(): void;
     handlePointer(event: OwnedEditorPointerEvent): boolean;
     hasSelection(): boolean;
     ownsPointer(): boolean;
@@ -44,6 +46,10 @@ export declare class OwnedEditorUxInterception {
 export interface PromptSelectionUxOptions {
     readonly copyText: (text: string) => void;
     readonly readClipboardContent: () => Promise<PiShellClipboardContent | null>;
+    readonly beginClipboardPaste?: () => {
+        readonly marker: string;
+        readonly result: Promise<string>;
+    };
     readonly transformPastedContent: (content: PiShellClipboardContent) => string;
     readonly atomicRanges: (line: string) => readonly PiShellEditorTextRange[];
     readonly expandCopiedText: (text: string) => string;

package/dist/integrations/pi/components/owned-editor-ux.js

@@ -31,6 +31,10 @@ export class OwnedEditorUxInterception {
         for (const interceptor of this.interceptors)
             interceptor.reset();
     }
+    cancelPendingPastes() {
+        for (const interceptor of this.interceptors)
+            interceptor.cancelPendingPastes?.();
+    }
     handlePointer(event) {
         return this.interceptors.some(interceptor => interceptor.handlePointer?.(event) === true);
     }
@@ -60,6 +64,7 @@ class PromptSelectionInterceptor {
     #lastClick;
     #redoStack = [];
     #selectionRevision = 0;
+    #pasteGeneration = 0;
     #wordDirection;
     #geometry;
     constructor(editor, keybindings, options) {
@@ -245,6 +250,7 @@ class PromptSelectionInterceptor {
         this.#redoStack = [];
         this.#selectionRevision += 1;
     }
+    cancelPendingPastes() { this.#pasteGeneration += 1; }
     hasSelection() {
         return this.#activeRange() !== undefined;
     }
@@ -404,6 +410,20 @@ class PromptSelectionInterceptor {
         this.#requestRender();
     }
     #pasteFromClipboard() {
+        if (this.options.beginClipboardPaste !== undefined) {
+            const generation = this.#pasteGeneration;
+            const restore = this.#orderedSelection() === undefined ? "" : this.#selectedText();
+            const paste = this.options.beginClipboardPaste();
+            if (this.#orderedSelection() !== undefined)
+                this.#replaceSelection(paste.marker);
+            else
+                this.editor.insertTextAtCursor(paste.marker);
+            this.#requestRender();
+            const replace = (text) => { if (generation === this.#pasteGeneration)
+                this.#replacePasteMarker(paste.marker, text || restore); };
+            void paste.result.then(replace).catch(() => replace(restore));
+            return;
+        }
         const revision = this.#selectionRevision;
         const selection = this.#orderedSelection();
         const atomicFocus = this.#atomicFocus();
@@ -428,6 +448,44 @@ class PromptSelectionInterceptor {
             this.#requestRender();
         }).catch(() => { });
     }
+    #replacePasteMarker(marker, replacement) {
+        const current = this.editor.getText();
+        const from = current.indexOf(marker);
+        if (from < 0)
+            return;
+        const to = from + marker.length;
+        const text = normalizeInsertedText(replacement);
+        const lines = editorState(this.editor).lines;
+        const remap = (position) => {
+            const offset = positionOffset(lines, position);
+            return offset <= from ? offset : offset >= to ? offset + text.length - marker.length : from + text.length;
+        };
+        const cursor = remap(this.#cursor());
+        const selection = this.#selection === undefined ? undefined : { anchor: remap(this.#selection.anchor), head: remap(this.#selection.head) };
+        const next = current.slice(0, from) + text + current.slice(to);
+        // Compatibility: completing a paste updates its provisional undo snapshots, not the user's undo history.
+        editorState(this.editor).lines = next.split("\n");
+        const undo = Reflect.get(this.editor, "undoStack");
+        const snapshots = typeof undo === "object" && undo !== null ? Reflect.get(undo, "stack") : undefined;
+        if (Array.isArray(snapshots))
+            for (const snapshot of snapshots) {
+                const state = typeof snapshot === "object" && snapshot !== null ? Reflect.get(snapshot, "state") : undefined;
+                if (isEditorState(state))
+                    replaceSnapshotMarker(state, marker, text);
+            }
+        for (const snapshot of this.#redoStack) {
+            const state = { lines: snapshot.text.split("\n"), cursorLine: snapshot.cursor.line, cursorCol: snapshot.cursor.col };
+            replaceSnapshotMarker(state, marker, text);
+            snapshot.text = state.lines.join("\n");
+            snapshot.cursor = { line: state.cursorLine, col: state.cursorCol };
+        }
+        this.#setCursor(positionAtOffset(next, cursor));
+        this.editor.onChange?.(this.editor.getText());
+        this.editor.invalidate();
+        if (selection !== undefined)
+            this.#selection = { anchor: positionAtOffset(next, selection.anchor), head: positionAtOffset(next, selection.head) };
+        this.#requestRender();
+    }
     #replaceSelection(text) {
         const selection = this.#orderedSelection();
         if (selection === undefined) {
@@ -825,6 +883,19 @@ function positionAtOffset(text, requestedOffset) {
     const before = text.slice(0, offset).split("\n");
     return { line: before.length - 1, col: (before.at(-1) ?? "").length };
 }
+function replaceSnapshotMarker(state, marker, replacement) {
+    const text = state.lines.join("\n");
+    const from = text.indexOf(marker);
+    if (from < 0)
+        return;
+    const cursor = positionOffset(state.lines, { line: state.cursorLine, col: state.cursorCol });
+    const offset = cursor <= from ? cursor : cursor >= from + marker.length ? cursor + replacement.length - marker.length : from + replacement.length;
+    const next = text.slice(0, from) + replacement + text.slice(from + marker.length);
+    const position = positionAtOffset(next, offset);
+    state.lines = next.split("\n");
+    state.cursorLine = position.line;
+    state.cursorCol = position.col;
+}
 function normalizeInsertedText(text) {
     return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "    ");
 }

package/dist/integrations/pi/components/shell-editor-autocomplete.js

@@ -54,6 +54,7 @@ export function createPiShellEditor(options) {
             createPromptSelectionInterceptor(editor, keybindings, {
                 copyText: options.onCopyText ?? (() => { }),
                 readClipboardContent: options.readClipboardContent ?? (async () => null),
+                ...(options.beginClipboardPaste === undefined ? {} : { beginClipboardPaste: options.beginClipboardPaste }),
                 transformPastedContent: options.transformPastedContent ?? (content => content.kind === "text" ? content.text : ""),
                 atomicRanges: options.editorAtomicRanges ?? (() => []),
                 expandCopiedText: options.expandCopiedEditorText ?? (text => text),
@@ -202,6 +203,7 @@ export function createPiShellEditor(options) {
         ownsPointer: () => editorUx?.ownsPointer() ?? false,
         handlePointer: event => editorUx?.handlePointer(event) ?? false,
         pasteClipboard: () => editorUx?.pasteClipboard() ?? false,
+        cancelPendingPastes: () => editorUx?.cancelPendingPastes(),
     };
 }
 function autocompleteCommand(command, addition) {

package/dist/integrations/pi/components/shell-shared-facade.d.ts

@@ -47,6 +47,7 @@ export interface PiShellEditorPort extends PiShellComponentPort {
     ownsPointer(): boolean;
     handlePointer(event: PiShellEditorPointerEvent): boolean;
     pasteClipboard(): boolean;
+    cancelPendingPastes?(): void;
 }
 export interface PiShellAutocompleteCommand {
     readonly name: string;
@@ -135,7 +136,11 @@ export interface PiShellEditorOptions {
     readonly onDequeue?: (() => void) | undefined;
     readonly onPromptSuggestionAccepted?: (text: string) => void;
     readonly onCopyText?: (text: string) => void;
-    readonly readClipboardContent?: () => Promise<PiShellClipboardContent | null>;
+    readonly readClipboardContent?: (signal?: AbortSignal) => Promise<PiShellClipboardContent | null>;
+    readonly beginClipboardPaste?: () => {
+        readonly marker: string;
+        readonly result: Promise<string>;
+    };
     readonly transformPastedContent?: (content: PiShellClipboardContent) => string;
     readonly editorAtomicRanges?: (line: string) => readonly PiShellEditorTextRange[];
     readonly expandCopiedEditorText?: (text: string) => string;

package/dist/integrations/pi/session-ui/clipboard-image.d.ts

@@ -7,5 +7,5 @@ export interface ClipboardImageData {
  * Clipboard adapters are untrusted at this boundary, so reject representations
  * that Node's permissive base64 decoder would otherwise partially accept.
  */
-export declare function canonicalizeClipboardImage(image: ClipboardImageData): ClipboardImageData | null;
-export declare function canonicalizeStandardBase64(value: string): string | null;
+export declare function canonicalizeClipboardImage(image: ClipboardImageData, source?: boolean): ClipboardImageData | null;
+export declare function canonicalizeStandardBase64(value: string, source?: boolean): string | null;

package/dist/integrations/pi/session-ui/clipboard-image.js

@@ -1,18 +1,21 @@
-import { assertImageEncodedSize } from "../../../contracts/owned-ui/index.js";
+import { ImageAttachmentError, MAX_IMAGE_DATA_BYTES } from "../../../contracts/owned-ui/index.js";
+import { MAX_SOURCE_IMAGE_BYTES } from "./image-source.js";
 const STANDARD_BASE64 = /^[A-Za-z0-9+/]*={0,2}$/u;
 /**
  * Converts valid padded or unpadded standard base64 into its unique padded form.
  * Clipboard adapters are untrusted at this boundary, so reject representations
  * that Node's permissive base64 decoder would otherwise partially accept.
  */
-export function canonicalizeClipboardImage(image) {
-    const data = canonicalizeStandardBase64(image.data);
+export function canonicalizeClipboardImage(image, source = false) {
+    const data = canonicalizeStandardBase64(image.data, source);
     return data === null ? null : { data, mimeType: image.mimeType };
 }
-export function canonicalizeStandardBase64(value) {
+export function canonicalizeStandardBase64(value, source = false) {
     if (typeof value !== "string" || value.length === 0)
         return null;
-    assertImageEncodedSize(value);
+    const maximum = source ? Math.ceil(MAX_SOURCE_IMAGE_BYTES / 3) * 4 : MAX_IMAGE_DATA_BYTES;
+    if (Math.ceil(value.length / 4) * 4 > maximum)
+        throw new ImageAttachmentError(source ? "image-source-size" : "image-size");
     if (!STANDARD_BASE64.test(value))
         return null;
     const paddingStart = value.indexOf("=");
@@ -26,6 +29,8 @@ export function canonicalizeStandardBase64(value) {
         return null;
     const padded = `${core}${"=".repeat(requiredPadding)}`;
     const decoded = Buffer.from(padded, "base64");
+    if (source && decoded.length > MAX_SOURCE_IMAGE_BYTES)
+        throw new ImageAttachmentError("image-source-size");
     if (decoded.length === 0)
         return null;
     const canonical = decoded.toString("base64");

package/dist/integrations/pi/session-ui/image-preparation-client.d.ts

@@ -0,0 +1,20 @@
+import type { PiShellClipboardContent } from "../components/index.js";
+import type { ImagePreparationLimits, PreparedImage } from "./image-preparation.js";
+import type { ImageWorkerRequest } from "./image-worker.js";
+export type PreparedClipboardContent = {
+    readonly kind: "text";
+    readonly text: string;
+} | ({
+    readonly kind: "image";
+} & PreparedImage) | null;
+export interface ImagePasteJob {
+    readonly result: Promise<PreparedClipboardContent>;
+    cancel(): void;
+}
+/** Owns bounded paste acquisition and one off-thread conversion, canceled on session disposal. */
+export declare class ImagePreparationClient {
+    #private;
+    start(read?: (signal: AbortSignal) => Promise<PiShellClipboardContent | null>, limits?: ImagePreparationLimits): ImagePasteJob;
+    dispose(): Promise<void>;
+}
+export declare function runImageWorker<T>(request: ImageWorkerRequest, signal: AbortSignal): Promise<T>;

package/dist/integrations/pi/session-ui/image-preparation-client.js

@@ -0,0 +1,145 @@
+import { Worker } from "node:worker_threads";
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { IMAGE_PREPARATION_MS, MAX_SOURCE_IMAGE_BYTES } from "./image-source.js";
+/** Owns bounded paste acquisition and one off-thread conversion, canceled on session disposal. */
+export class ImagePreparationClient {
+    #active = new Set();
+    #queue = [];
+    #stopping = new Set();
+    #converting = false;
+    #disposed = false;
+    start(read, limits = {}) {
+        const controller = new AbortController();
+        if (this.#disposed || this.#active.size >= 8) {
+            const result = Promise.reject(new ImageAttachmentError(this.#disposed ? "image-canceled" : "image-busy"));
+            void result.catch(() => { });
+            return { result, cancel: () => { } };
+        }
+        this.#active.add(controller);
+        const deadline = setTimeout(() => controller.abort(new ImageAttachmentError("image-timeout")), IMAGE_PREPARATION_MS);
+        const result = new Promise((resolve, reject) => {
+            controller.signal.addEventListener("abort", () => reject(abortError(controller.signal)), { once: true });
+            // Concurrency: the pending marker gets a render opportunity before any acquisition starts.
+            setImmediate(() => {
+                if (controller.signal.aborted)
+                    return;
+                const acquire = read === undefined
+                    ? runImageWorker({ kind: "clipboard" }, controller.signal)
+                    : Promise.resolve().then(() => read(controller.signal));
+                void acquire.then(content => {
+                    if (controller.signal.aborted)
+                        return;
+                    if (content?.kind !== "image") {
+                        resolve(content);
+                        return;
+                    }
+                    if (Math.ceil(content.data.length / 4) * 3 > MAX_SOURCE_IMAGE_BYTES + 2)
+                        throw new ImageAttachmentError("image-source-size");
+                    this.#queue.push({ signal: controller.signal, run: async () => {
+                            try {
+                                const image = await runImageWorker({ kind: "prepare", source: content, limits }, controller.signal);
+                                resolve({ kind: "image", ...image });
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                        } });
+                    this.#drain();
+                }).catch(reject);
+            });
+        }).finally(() => {
+            clearTimeout(deadline);
+            this.#active.delete(controller);
+            const stopped = waitForImageWorkers(controller.signal);
+            this.#stopping.add(stopped);
+            void stopped.finally(() => this.#stopping.delete(stopped));
+            const index = this.#queue.findIndex(item => item.signal === controller.signal);
+            if (index >= 0)
+                this.#queue.splice(index, 1);
+        });
+        void result.catch(() => { });
+        return { result, cancel: () => controller.abort(new ImageAttachmentError("image-canceled")) };
+    }
+    async dispose() {
+        this.#disposed = true;
+        for (const controller of this.#active)
+            controller.abort(new ImageAttachmentError("image-canceled"));
+        this.#queue.length = 0;
+        await Promise.resolve();
+        await Promise.all(this.#stopping);
+    }
+    #drain() {
+        if (this.#converting)
+            return;
+        const next = this.#queue.shift();
+        if (next === undefined)
+            return;
+        if (next.signal.aborted) {
+            this.#drain();
+            return;
+        }
+        this.#converting = true;
+        void next.run().finally(() => { this.#converting = false; this.#drain(); });
+    }
+}
+const ACTIVE_IMAGE_WORKERS = new Map();
+async function waitForImageWorkers(signal) {
+    await Promise.all([...ACTIVE_IMAGE_WORKERS].filter(([, owner]) => owner === signal)
+        .map(([worker]) => new Promise(resolve => { worker.once("exit", () => resolve()); })));
+}
+export function runImageWorker(request, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(abortError(signal));
+            return;
+        }
+        if (ACTIVE_IMAGE_WORKERS.size >= 8) {
+            reject(new ImageAttachmentError("image-busy"));
+            return;
+        }
+        // Compatibility: production uses the emitted sibling; source tests load TypeScript through tsx.
+        const source = import.meta.url.endsWith(".ts");
+        const entry = new URL(source ? "./image-worker.ts" : "./image-worker.js", import.meta.url);
+        const worker = source
+            ? new Worker(`import('tsx/esm/api').then(({ tsImport }) => tsImport(${JSON.stringify(entry.href)}, ${JSON.stringify(import.meta.url)}))`, { eval: true, workerData: request, stdout: true, stderr: true })
+            : new Worker(entry, { workerData: request, stdout: true, stderr: true });
+        // Security: native/codec output is not trusted diagnostics and must never reach the terminal or logs.
+        worker.stdout.resume();
+        worker.stderr.resume();
+        ACTIVE_IMAGE_WORKERS.set(worker, signal);
+        let outcome;
+        let stop;
+        const requestStop = () => {
+            if (stop !== undefined)
+                return;
+            worker.postMessage("cancel");
+            // Security: allow clipboard subprocess abort first; a busy codec cannot handle messages.
+            stop = setTimeout(() => { void worker.terminate().catch(() => { }); }, 50);
+            stop.unref();
+        };
+        const abort = () => { outcome = { error: abortError(signal) }; requestStop(); };
+        signal.addEventListener("abort", abort, { once: true });
+        worker.once("message", (message) => {
+            if (!signal.aborted)
+                outcome = message?.ok === true
+                    ? { value: message.value }
+                    : { error: new ImageAttachmentError(message?.code ?? "image-codec") };
+            requestStop();
+        });
+        worker.once("error", () => { outcome = { error: new ImageAttachmentError("image-codec") }; requestStop(); });
+        worker.once("exit", () => {
+            ACTIVE_IMAGE_WORKERS.delete(worker);
+            if (stop !== undefined)
+                clearTimeout(stop);
+            signal.removeEventListener("abort", abort);
+            // Concurrency: release the conversion slot only after the old executor has actually stopped.
+            if (outcome === undefined || outcome.error !== undefined)
+                reject(outcome?.error ?? new ImageAttachmentError("image-codec"));
+            else
+                resolve(outcome.value);
+        });
+    });
+}
+function abortError(signal) {
+    return signal.reason instanceof ImageAttachmentError ? signal.reason : new ImageAttachmentError("image-canceled");
+}

package/dist/integrations/pi/session-ui/image-preparation.d.ts

@@ -0,0 +1,18 @@
+export interface ImagePreparationLimits {
+    readonly encodedBytes?: number;
+    readonly decodedBytes?: number;
+    readonly maxDimension?: number;
+}
+export interface PreparedImage {
+    readonly data: string;
+    readonly mimeType: string;
+    readonly width: number;
+    readonly height: number;
+    readonly transformed: boolean;
+}
+export declare const IMAGE_TARGET_BASE64_BYTES: number;
+export declare const IMAGE_TARGET_DECODED_BYTES: number;
+export declare function prepareImage(source: {
+    readonly data: string;
+    readonly mimeType: string;
+}, limits?: ImagePreparationLimits): Promise<PreparedImage>;

package/dist/integrations/pi/session-ui/image-preparation.js

@@ -0,0 +1,126 @@
+import { isMainThread } from "node:worker_threads";
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { canonicalizeClipboardImage } from "./clipboard-image.js";
+import { sourceImageInfo } from "./image-source.js";
+export const IMAGE_TARGET_BASE64_BYTES = 4.5 * 1024 * 1024;
+export const IMAGE_TARGET_DECODED_BYTES = 5 * 1024 * 1024;
+export async function prepareImage(source, limits = {}) {
+    // Performance: an async signature does not move synchronous WASM work off the interactive thread.
+    if (isMainThread)
+        throw new Error("Image preparation requires a worker");
+    const canonical = canonicalizeClipboardImage(source, true);
+    if (canonical === null)
+        throw new ImageAttachmentError("image-data");
+    const bytes = Buffer.from(canonical.data, "base64");
+    const metadata = sourceImageInfo(bytes, canonical.mimeType);
+    const encodedLimit = Math.min(IMAGE_TARGET_BASE64_BYTES - 1, positive(limits.encodedBytes, Infinity));
+    const decodedLimit = Math.min(IMAGE_TARGET_DECODED_BYTES, positive(limits.decodedBytes, Infinity));
+    const maxDimension = positive(limits.maxDimension, Infinity);
+    const fits = (length) => length <= decodedLimit && 4 * Math.ceil(length / 3) <= encodedLimit;
+    if (fits(bytes.length) && Math.max(metadata.width, metadata.height) <= maxDimension) {
+        return { ...canonical, width: metadata.width, height: metadata.height, transformed: false };
+    }
+    if (metadata.conversionUnsafe)
+        throw new ImageAttachmentError("image-conversion");
+    const photon = await import("@silvia-odwyer/photon-node").catch(() => { throw new ImageAttachmentError("image-codec"); });
+    let image;
+    try {
+        image = photon.PhotonImage.new_from_byteslice(bytes);
+        if (image.get_width() !== metadata.width || image.get_height() !== metadata.height)
+            throw new ImageAttachmentError("image-data");
+        if (metadata.orientation !== 1) {
+            const raw = image.get_raw_pixels();
+            const oriented = orientPixels(raw, metadata.width, metadata.height, metadata.orientation);
+            image.free();
+            image = undefined;
+            image = new photon.PhotonImage(oriented.pixels, oriented.width, oriented.height);
+        }
+        const width = image.get_width(), height = image.get_height();
+        let scale = Math.min(1, 2000 / Math.max(width, height), maxDimension / Math.max(width, height));
+        const floor = Math.min(Math.max(width, height), 1024, maxDimension);
+        for (let level = 0; level < 4; level++, scale *= 0.75) {
+            const w = Math.max(1, Math.round(width * scale)), h = Math.max(1, Math.round(height * scale));
+            if (Math.max(w, h) < floor)
+                break;
+            const resized = photon.resize(image, w, h, photon.SamplingFilter.Lanczos3);
+            let opaque;
+            try {
+                const png = resized.get_bytes();
+                if (fits(png.length))
+                    return result(png, "image/png", w, h);
+                const pixels = resized.get_raw_pixels();
+                for (let p = 0; p < pixels.length; p += 4) {
+                    const alpha = (pixels[p + 3] ?? 255) / 255;
+                    for (let c = 0; c < 3; c++)
+                        pixels[p + c] = Math.round((pixels[p + c] ?? 0) * alpha + 255 * (1 - alpha));
+                    pixels[p + 3] = 255;
+                }
+                opaque = new photon.PhotonImage(pixels, w, h);
+                for (const quality of [85, 70, 55, 40]) {
+                    const jpeg = opaque.get_bytes_jpeg(quality);
+                    if (fits(jpeg.length))
+                        return result(jpeg, "image/jpeg", w, h);
+                }
+            }
+            finally {
+                opaque?.free();
+                resized.free();
+            }
+        }
+        throw new ImageAttachmentError("image-output");
+    }
+    catch (error) {
+        if (error instanceof ImageAttachmentError)
+            throw error;
+        throw new ImageAttachmentError("image-conversion");
+    }
+    finally {
+        image?.free();
+    }
+}
+function positive(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isFinite(value) || value < 1)
+        throw new ImageAttachmentError("image-output");
+    return Math.floor(value);
+}
+function result(bytes, mimeType, width, height) {
+    return { data: Buffer.from(bytes).toString("base64"), mimeType, width, height, transformed: true };
+}
+function orientPixels(pixels, width, height, orientation) {
+    const swapped = orientation >= 5;
+    const outputWidth = swapped ? height : width, outputHeight = swapped ? width : height;
+    const output = new Uint8Array(pixels.length);
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            let dx = x, dy = y;
+            if (orientation === 2)
+                dx = width - 1 - x;
+            if (orientation === 3) {
+                dx = width - 1 - x;
+                dy = height - 1 - y;
+            }
+            if (orientation === 4)
+                dy = height - 1 - y;
+            if (orientation === 5) {
+                dx = y;
+                dy = x;
+            }
+            if (orientation === 6) {
+                dx = height - 1 - y;
+                dy = x;
+            }
+            if (orientation === 7) {
+                dx = height - 1 - y;
+                dy = width - 1 - x;
+            }
+            if (orientation === 8) {
+                dx = y;
+                dy = width - 1 - x;
+            }
+            const from = (y * width + x) * 4, to = (dy * outputWidth + dx) * 4;
+            output.set(pixels.subarray(from, from + 4), to);
+        }
+    return { pixels: output, width: outputWidth, height: outputHeight };
+}

package/dist/integrations/pi/session-ui/image-source.d.ts

@@ -0,0 +1,13 @@
+export declare const MAX_SOURCE_IMAGE_BYTES: number;
+export declare const MAX_SOURCE_PIXELS = 40000000;
+export declare const MAX_SOURCE_DIMENSION = 32768;
+export declare const IMAGE_PREPARATION_MS = 15000;
+export interface ImageSourceInfo {
+    readonly width: number;
+    readonly height: number;
+    readonly mimeType: string;
+    readonly orientation: number;
+    readonly conversionUnsafe: boolean;
+}
+export declare function assertSourceBytes(length: number): void;
+export declare function sourceImageInfo(bytes: Uint8Array, mimeType: string): ImageSourceInfo;