@timurproko/a1 0.1.8-dev.3b54f21 → 0.1.8-dev.402

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

@@ -0,0 +1,171 @@
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+export const MAX_SOURCE_IMAGE_BYTES = 20 * 1024 * 1024;
+export const MAX_SOURCE_PIXELS = 40_000_000;
+export const MAX_SOURCE_DIMENSION = 32_768;
+export const IMAGE_PREPARATION_MS = 15_000;
+export function assertSourceBytes(length) {
+    if (length > MAX_SOURCE_IMAGE_BYTES)
+        throw new ImageAttachmentError("image-source-size");
+    if (!Number.isSafeInteger(length) || length <= 0)
+        throw new ImageAttachmentError("image-data");
+}
+export function sourceImageInfo(bytes, mimeType) {
+    assertSourceBytes(bytes.length);
+    try {
+        const info = readHeader(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+        if (info.mimeType !== mimeType.toLowerCase())
+            throw new ImageAttachmentError("image-mime");
+        if (info.width <= 0 || info.height <= 0)
+            throw new ImageAttachmentError("image-data");
+        if (info.width > MAX_SOURCE_DIMENSION || info.height > MAX_SOURCE_DIMENSION || info.width * info.height > MAX_SOURCE_PIXELS) {
+            throw new ImageAttachmentError("image-pixels");
+        }
+        return info;
+    }
+    catch (error) {
+        if (error instanceof ImageAttachmentError)
+            throw error;
+        throw new ImageAttachmentError("image-data");
+    }
+}
+function readHeader(b) {
+    let orientation = 1;
+    let conversionUnsafe = false;
+    const info = (width, height, mimeType) => ({ width, height, mimeType, orientation, conversionUnsafe });
+    if (b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+        if (b.toString("ascii", 12, 16) !== "IHDR" || b.readUInt32BE(8) !== 13)
+            throw new ImageAttachmentError("image-data");
+        for (let p = 8; p + 12 <= b.length;) {
+            const n = b.readUInt32BE(p);
+            if (p + n + 12 > b.length)
+                throw new ImageAttachmentError("image-data");
+            const type = b.toString("ascii", p + 4, p + 8);
+            if (type === "eXIf")
+                orientation = exifOrientation(b.subarray(p + 8, p + 8 + n));
+            if (type === "acTL" || type === "iCCP" || (type === "IHDR" && b[p + 16] === 16))
+                conversionUnsafe = true;
+            p += n + 12;
+        }
+        return info(b.readUInt32BE(16), b.readUInt32BE(20), "image/png");
+    }
+    if (b[0] === 255 && b[1] === 216) {
+        let width = 0, height = 0;
+        for (let p = 2; p < b.length;) {
+            if (b[p++] !== 255)
+                throw new ImageAttachmentError("image-data");
+            while (b[p] === 255)
+                p++;
+            const marker = b[p++];
+            if (marker === 218 || marker === 217)
+                break;
+            if (marker === 1 || (marker !== undefined && marker >= 208 && marker <= 215))
+                continue;
+            const n = b.readUInt16BE(p);
+            if (n < 2 || p + n > b.length)
+                throw new ImageAttachmentError("image-data");
+            if (marker === 225 && b.toString("ascii", p + 2, p + 8) === "Exif\0\0")
+                orientation = exifOrientation(b.subarray(p + 8, p + n));
+            if (marker === 226 && b.toString("ascii", p + 2, p + 13) === "ICC_PROFILE")
+                conversionUnsafe = true;
+            if (marker !== undefined && [192, 193, 194].includes(marker)) {
+                height = b.readUInt16BE(p + 3);
+                width = b.readUInt16BE(p + 5);
+                if (b[p + 7] === 4)
+                    conversionUnsafe = true;
+            }
+            p += n;
+        }
+        return info(width, height, "image/jpeg");
+    }
+    if (/^GIF8[79]a$/.test(b.toString("ascii", 0, 6))) {
+        conversionUnsafe = gifFrameCount(b) > 1;
+        return info(b.readUInt16LE(6), b.readUInt16LE(8), "image/gif");
+    }
+    if (b.toString("ascii", 0, 2) === "BM") {
+        const dib = b.readUInt32LE(14);
+        if (dib === 12)
+            return info(b.readUInt16LE(18), b.readUInt16LE(20), "image/bmp");
+        if (dib < 40)
+            throw new ImageAttachmentError("image-data");
+        return info(b.readInt32LE(18), Math.abs(b.readInt32LE(22)), "image/bmp");
+    }
+    if (b.toString("ascii", 0, 4) === "RIFF" && b.toString("ascii", 8, 12) === "WEBP") {
+        const kind = b.toString("ascii", 12, 16);
+        if (kind === "VP8X") {
+            conversionUnsafe = ((b[20] ?? 0) & 0x22) !== 0;
+            for (let p = 12; p + 8 <= b.length;) {
+                const n = b.readUInt32LE(p + 4);
+                if (p + n + 8 > b.length)
+                    throw new ImageAttachmentError("image-data");
+                if (b.toString("ascii", p, p + 4) === "EXIF")
+                    orientation = exifOrientation(b.subarray(p + 8, p + 8 + n));
+                p += 8 + n + (n % 2);
+            }
+            return info(1 + b.readUIntLE(24, 3), 1 + b.readUIntLE(27, 3), "image/webp");
+        }
+        if (kind === "VP8 " && b.toString("hex", 23, 26) === "9d012a")
+            return info(b.readUInt16LE(26) & 0x3fff, b.readUInt16LE(28) & 0x3fff, "image/webp");
+        if (kind === "VP8L" && b[20] === 47) {
+            const bits = b.readUInt32LE(21);
+            return info((bits & 0x3fff) + 1, ((bits >>> 14) & 0x3fff) + 1, "image/webp");
+        }
+    }
+    throw new ImageAttachmentError("image-conversion");
+}
+function gifFrameCount(b) {
+    let p = 13 + (((b[10] ?? 0) & 128) ? 3 * 2 ** (((b[10] ?? 0) & 7) + 1) : 0);
+    let frames = 0;
+    const skipBlocks = () => {
+        while (p < b.length) {
+            const length = b[p++] ?? 0;
+            if (length === 0)
+                return;
+            p += length;
+            if (p > b.length)
+                throw new ImageAttachmentError("image-data");
+        }
+        throw new ImageAttachmentError("image-data");
+    };
+    while (p < b.length) {
+        const marker = b[p++];
+        if (marker === 59)
+            return frames;
+        if (marker === 33) {
+            p++;
+            skipBlocks();
+            continue;
+        }
+        if (marker !== 44 || p + 9 > b.length)
+            throw new ImageAttachmentError("image-data");
+        frames++;
+        const packed = b[p + 8] ?? 0;
+        p += 9 + ((packed & 128) ? 3 * 2 ** ((packed & 7) + 1) : 0);
+        p++;
+        skipBlocks();
+    }
+    throw new ImageAttachmentError("image-data");
+}
+function exifOrientation(input) {
+    const b = input.toString("ascii", 0, 6) === "Exif\0\0" ? input.subarray(6) : input;
+    const little = b.toString("ascii", 0, 2) === "II";
+    if (!little && b.toString("ascii", 0, 2) !== "MM")
+        throw new ImageAttachmentError("image-conversion");
+    const u16 = (p) => little ? b.readUInt16LE(p) : b.readUInt16BE(p);
+    const u32 = (p) => little ? b.readUInt32LE(p) : b.readUInt32BE(p);
+    if (u16(2) !== 42)
+        throw new ImageAttachmentError("image-conversion");
+    const directory = u32(4);
+    const count = u16(directory);
+    if (directory + 2 + count * 12 > b.length)
+        throw new ImageAttachmentError("image-conversion");
+    for (let i = 0; i < count; i++) {
+        const p = directory + 2 + i * 12;
+        if (u16(p) !== 274)
+            continue;
+        const value = u16(p + 8);
+        if (u16(p + 2) !== 3 || u32(p + 4) !== 1 || value < 1 || value > 8)
+            throw new ImageAttachmentError("image-conversion");
+        return value;
+    }
+    return 1;
+}

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

@@ -0,0 +1,17 @@
+import { type ImagePreparationLimits } from "./image-preparation.js";
+export type ImageWorkerRequest = {
+    readonly kind: "clipboard";
+} | {
+    readonly kind: "canonicalize";
+    readonly source: {
+        readonly data: string;
+        readonly mimeType: string;
+    };
+} | {
+    readonly kind: "prepare";
+    readonly source: {
+        readonly data: string;
+        readonly mimeType: string;
+    };
+    readonly limits?: ImagePreparationLimits;
+};

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

@@ -0,0 +1,23 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { prepareImage } from "./image-preparation.js";
+import { canonicalizeClipboardImage } from "./clipboard-image.js";
+import { readSystemClipboardContent } from "./system-clipboard.js";
+const controller = new AbortController();
+parentPort?.on("message", message => { if (message === "cancel")
+    controller.abort(); });
+const request = workerData;
+try {
+    const value = request.kind === "clipboard"
+        ? await readSystemClipboardContent(controller.signal)
+        : request.kind === "canonicalize" ? canonicalizeClipboardImage(request.source, true)
+            : await prepareImage(request.source, request.limits);
+    parentPort?.postMessage({ ok: true, value });
+}
+catch (error) {
+    // Security: never forward native/codec exceptions which may contain input data.
+    parentPort?.postMessage({ ok: false, code: error instanceof ImageAttachmentError ? error.code : "image-codec" });
+}
+finally {
+    parentPort?.close();
+}

package/dist/integrations/pi/session-ui/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./clipboard-diagnostics.js";
+export * from "./prompt-suggestion-controller.js";
+export * from "./session-shell.js";
+export * from "./stream-presentation-coalescer.js";
+export * from "./route-host.js";

package/dist/integrations/pi/session-ui/index.js

@@ -0,0 +1,5 @@
+export * from "./clipboard-diagnostics.js";
+export * from "./prompt-suggestion-controller.js";
+export * from "./session-shell.js";
+export * from "./stream-presentation-coalescer.js";
+export * from "./route-host.js";

package/dist/integrations/pi/session-ui/paste-executor.d.ts

@@ -0,0 +1,10 @@
+import type { PiShellClipboardContent } from "../components/index.js";
+import { type PreparedPaste, type PasteEvent } from "./paste-protocol.js";
+export interface PasteExecutorJob {
+    readonly result: Promise<PreparedPaste>;
+    readonly stopped: Promise<void>;
+    cancel(): void;
+}
+export type PastePhase = (phase: PasteEvent["phase"], bytes?: number) => void;
+/** Streams bounded fragments through a killable child; native/codec/filesystem work never runs on the UI thread. */
+export declare function startPasteExecutor(content: PiShellClipboardContent | undefined, signal: AbortSignal, phase?: PastePhase, helper?: URL): PasteExecutorJob;

package/dist/integrations/pi/session-ui/paste-executor.js

@@ -0,0 +1,232 @@
+import { fork } from "node:child_process";
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { MAX_SOURCE_IMAGE_BYTES } from "./image-source.js";
+import { PASTE_CHUNK_UNITS, PASTE_REQUESTS, PASTE_STOP_MS, PASTE_TEXT_BYTES, pasteFragments } from "./paste-protocol.js";
+const live = new Set();
+const conversionQueue = [];
+let converting;
+function permitConversion() {
+    if (converting)
+        return;
+    const child = conversionQueue.shift();
+    if (!child)
+        return;
+    if (!live.has(child) || !child.connected) {
+        permitConversion();
+        return;
+    }
+    converting = child;
+    child.send({ kind: "convert" }, () => { });
+}
+/** Streams bounded fragments through a killable child; native/codec/filesystem work never runs on the UI thread. */
+export function startPasteExecutor(content, signal, phase = () => { }, helper) {
+    const tooLarge = content?.kind === "text" && content.text.length > PASTE_TEXT_BYTES;
+    if (signal.aborted || live.size >= PASTE_REQUESTS || tooLarge) {
+        const result = Promise.reject(new ImageAttachmentError(signal.aborted ? "image-canceled" : tooLarge ? "paste-size" : "paste-busy"));
+        void result.catch(() => { });
+        return { result, stopped: Promise.resolve(), cancel() { } };
+    }
+    const source = new URL(import.meta.url).pathname.endsWith(".ts");
+    const entry = helper ?? new URL(source ? "./paste-helper.ts" : "./paste-helper.js", import.meta.url);
+    const options = {
+        execArgv: entry.pathname.endsWith(".ts") ? ["--import", "tsx"] : [],
+        stdio: ["ignore", "ignore", "ignore", "ipc"], serialization: "json", windowsHide: true,
+        detached: process.platform !== "win32",
+    };
+    const child = fork(entry, [], options);
+    const forceStop = () => {
+        // Concurrency: POSIX command fallbacks share this isolated process group; kill descendants too.
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch {
+                child.kill("SIGKILL");
+            }
+        }
+        else
+            child.kill("SIGKILL");
+        child.unref();
+        child.channel?.unref();
+    };
+    live.add(child);
+    let input = sourceMessages(content);
+    let canceled = false, done = false;
+    let header;
+    let payload = "", bytes = 0;
+    let paths = [];
+    let failure;
+    let stopTimer;
+    const phases = new Set();
+    let resolve, reject, stopped;
+    const result = new Promise((ok, fail) => { resolve = ok; reject = fail; });
+    const exit = new Promise(end => { stopped = end; });
+    const send = (message) => {
+        if (!child.connected || canceled)
+            return;
+        child.send(message, error => { if (error)
+            cancel(); });
+    };
+    const cancel = () => {
+        if (canceled || !live.has(child))
+            return;
+        canceled = true;
+        input = undefined;
+        payload = "";
+        paths = [];
+        reject(failure ?? (signal.reason instanceof ImageAttachmentError ? signal.reason : new ImageAttachmentError("image-canceled")));
+        const queued = conversionQueue.indexOf(child);
+        if (queued >= 0)
+            conversionQueue.splice(queued, 1);
+        if (child.connected)
+            child.send({ kind: "cancel" }, () => { });
+        stopTimer = setTimeout(forceStop, PASTE_STOP_MS);
+        stopTimer.unref();
+    };
+    const fail = (code = "paste-unavailable") => { failure = new ImageAttachmentError(code); cancel(); };
+    signal.addEventListener("abort", cancel, { once: true });
+    child.on("message", value => {
+        if (canceled)
+            return;
+        const message = value;
+        try {
+            if (message?.kind === "ready") {
+                const next = input?.next();
+                if (!next || next.done) {
+                    fail();
+                    return;
+                }
+                send(next.value);
+            }
+            else if (message?.kind === "phase") {
+                if (!["acquired-text", "acquired-image", "classifying", "path-fallback", "prepared"].includes(message.phase) || phases.has(message.phase)) {
+                    fail();
+                    return;
+                }
+                phases.add(message.phase);
+                phase(message.phase, message.bytes);
+                // Concurrency: lifecycle observers may synchronously cancel; never grant new conversion work afterward.
+                if (canceled)
+                    return;
+                if (message.phase === "acquired-image") {
+                    conversionQueue.push(child);
+                    permitConversion();
+                }
+            }
+            else if (message?.kind === "output" && !header) {
+                if (!["text", "url", "paths", "image", "empty"].includes(message.type) || (message.label?.length ?? 0) > 256
+                    || (message.mimeType?.length ?? 0) > 256) {
+                    fail();
+                    return;
+                }
+                header = message;
+                input = undefined;
+                send({ kind: "next" });
+            }
+            else if (message?.kind === "data" && header && ["text", "url", "image"].includes(header.type)) {
+                if (typeof message.data !== "string" || message.data.length > PASTE_CHUNK_UNITS) {
+                    fail();
+                    return;
+                }
+                bytes += Buffer.byteLength(message.data);
+                if (bytes > (header.type === "image" ? 8 * 1024 * 1024 : PASTE_TEXT_BYTES)) {
+                    fail("paste-size");
+                    return;
+                }
+                // Performance: retain a rope of bounded fragments; no giant JSON parse/join is needed on the UI thread.
+                payload += message.data;
+                send({ kind: "next" });
+            }
+            else if (message?.kind === "path" && header?.type === "paths") {
+                const item = message.path;
+                if (!item || !["file", "folder"].includes(item.kind) || typeof item.fullPath !== "string" || item.fullPath.length > 32_768) {
+                    fail();
+                    return;
+                }
+                bytes += Buffer.byteLength(item.fullPath);
+                if (bytes > PASTE_TEXT_BYTES) {
+                    fail("paste-size");
+                    return;
+                }
+                paths.push(item);
+                send({ kind: "next" });
+            }
+            else if (message?.kind === "done" && header) {
+                done = true;
+                stopTimer = setTimeout(forceStop, PASTE_STOP_MS);
+                stopTimer.unref();
+            }
+            else if (message?.kind === "error") {
+                const candidate = new ImageAttachmentError(message.code);
+                failure = candidate.message ? candidate : new ImageAttachmentError("paste-unavailable");
+                cancel();
+            }
+            else
+                fail();
+        }
+        catch (error) {
+            fail(error instanceof ImageAttachmentError ? error.code : "paste-unavailable");
+        }
+    });
+    child.once("error", () => fail());
+    const cleanup = () => {
+        if (!live.delete(child))
+            return;
+        if (canceled)
+            forceStop();
+        input = undefined;
+        if (stopTimer)
+            clearTimeout(stopTimer);
+        signal.removeEventListener("abort", cancel);
+        child.removeAllListeners("message");
+        const queued = conversionQueue.indexOf(child);
+        if (queued >= 0)
+            conversionQueue.splice(queued, 1);
+        if (converting === child)
+            converting = undefined;
+        permitConversion();
+        if (!canceled && done && header) {
+            if (header.type === "empty")
+                resolve(null);
+            else if (header.type === "text")
+                resolve({ kind: "text", text: payload, ...(header.label === undefined ? {} : { label: header.label }) });
+            else if (header.type === "url")
+                resolve({ kind: "url", url: payload, label: header.label ?? "" });
+            else if (header.type === "paths")
+                resolve({ kind: "paths", paths });
+            else if (header.mimeType && Number.isSafeInteger(header.width) && Number.isSafeInteger(header.height) && header.width > 0 && header.height > 0)
+                resolve({
+                    kind: "image", data: payload, mimeType: header.mimeType, width: header.width, height: header.height, transformed: header.transformed === true,
+                });
+            else
+                reject(new ImageAttachmentError("paste-unavailable"));
+        }
+        else
+            reject(failure ?? new ImageAttachmentError(canceled ? "image-canceled" : "paste-unavailable"));
+        payload = "";
+        paths = [];
+        stopped();
+        try {
+            phase("cleanup");
+        }
+        catch { /* Invariant: cleanup observation cannot retain an exited executor. */ }
+    };
+    child.once("exit", cleanup);
+    child.once("close", cleanup);
+    void result.catch(() => { });
+    return { result, stopped: exit, cancel };
+}
+function* sourceMessages(content) {
+    yield { kind: "begin", source: content?.kind ?? "native", ...(content?.kind === "image" ? { mimeType: content.mimeType } : {}) };
+    if (content !== undefined) {
+        const data = content.kind === "text" ? content.text : content.data;
+        let bytes = 0;
+        for (const fragment of pasteFragments(data)) {
+            bytes += Buffer.byteLength(fragment);
+            if (bytes > (content.kind === "text" ? PASTE_TEXT_BYTES : Math.ceil(MAX_SOURCE_IMAGE_BYTES / 3) * 4 + 4))
+                throw new ImageAttachmentError(content.kind === "text" ? "paste-size" : "image-source-size");
+            yield { kind: "data", data: fragment };
+        }
+    }
+    yield { kind: "finish" };
+}

package/dist/integrations/pi/session-ui/paste-helper.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integrations/pi/session-ui/paste-helper.js

@@ -0,0 +1,173 @@
+import { Worker } from "node:worker_threads";
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { readSystemClipboardContent } from "./system-clipboard.js";
+import { MAX_SOURCE_IMAGE_BYTES } from "./image-source.js";
+import { preparePasteText } from "./paste-text-preparation.js";
+import { PASTE_CHUNK_UNITS, PASTE_TEXT_BYTES, pasteFragments } from "./paste-protocol.js";
+const abort = new AbortController();
+let header;
+let fragments = [], bytes = 0;
+let image;
+let output;
+let finished = false;
+function send(message) { process.send?.(message); }
+function fail(error) {
+    if (finished)
+        return;
+    finished = true;
+    process.send?.({ kind: "error", code: error instanceof ImageAttachmentError ? error.code : "paste-unavailable" }, () => process.exit(1));
+}
+function workerFor(name, data) {
+    const source = new URL(import.meta.url).pathname.endsWith(".ts");
+    const entry = new URL(`./${name}.${source ? "ts" : "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: data, stdout: true, stderr: true })
+        : new Worker(entry, { workerData: data, stdout: true, stderr: true });
+    worker.stdout.resume();
+    worker.stderr.resume();
+    return worker;
+}
+async function classifyText(text) {
+    const worker = workerFor("paste-text-worker", text);
+    return new Promise(resolve => {
+        let done = false;
+        const complete = (prepared) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            // Concurrency: a worker may be in a blocked native filesystem call. Never await its termination here;
+            // this child exits after transferring the safe text fallback and kills all its own threads.
+            void worker.terminate().catch(() => { });
+            if (!prepared)
+                send({ kind: "phase", phase: "path-fallback" });
+            resolve(prepared ?? preparePasteText(text, true));
+        };
+        const timer = setTimeout(() => complete(), 1_000);
+        worker.once("message", message => complete(message?.ok ? message.value : undefined));
+        worker.once("error", () => complete());
+        worker.once("exit", () => complete());
+    });
+}
+function imagePreparation(source) {
+    const worker = workerFor("image-worker", { kind: "prepare", source });
+    return new Promise((resolve, reject) => {
+        let done = false;
+        worker.once("message", message => {
+            done = true;
+            if (message?.ok)
+                resolve({ kind: "image", ...message.value });
+            else
+                reject(new ImageAttachmentError(message?.code ?? "image-codec"));
+            void worker.terminate().catch(() => { });
+        });
+        worker.once("error", () => reject(new ImageAttachmentError("image-codec")));
+        worker.once("exit", () => { if (!done)
+            reject(new ImageAttachmentError("image-codec")); });
+    });
+}
+function* outputMessages(value) {
+    if (value === null)
+        yield { kind: "output", type: "empty" };
+    else if (value.kind === "paths") {
+        yield { kind: "output", type: "paths" };
+        for (const path of value.paths)
+            yield { kind: "path", path };
+    }
+    else {
+        if (value.kind === "image")
+            yield { kind: "output", type: "image", mimeType: value.mimeType, width: value.width, height: value.height, transformed: value.transformed };
+        else
+            yield { kind: "output", type: value.kind, ...(value.label === undefined ? {} : { label: value.label }) };
+        const data = value.kind === "text" ? value.text : value.kind === "url" ? value.url : value.data;
+        for (const fragment of pasteFragments(data))
+            yield { kind: "data", data: fragment };
+    }
+    yield { kind: "done" };
+}
+function present(value) {
+    const bytes = value === null ? 0 : value.kind === "paths" ? value.paths.reduce((sum, path) => sum + Buffer.byteLength(path.fullPath), 0)
+        : Buffer.byteLength(value.kind === "image" ? value.data : value.kind === "url" ? value.url : value.text);
+    if (value !== null && value.kind !== "image" && bytes > PASTE_TEXT_BYTES)
+        throw new ImageAttachmentError("paste-size");
+    send({ kind: "phase", phase: "prepared", bytes });
+    output = outputMessages(value);
+    nextOutput();
+}
+function nextOutput() {
+    const next = output?.next();
+    if (!next || next.done)
+        throw new Error("protocol");
+    if (next.value.kind === "done") {
+        finished = true;
+        output = undefined;
+        process.send?.(next.value, () => process.exit(0));
+    }
+    else
+        send(next.value);
+}
+async function receive(message) {
+    if (message?.kind === "cancel") {
+        abort.abort();
+        fragments = [];
+        image = undefined;
+        output = undefined;
+        // Concurrency: allow an outstanding command read's AbortSignal to terminate its subprocess before exit.
+        setTimeout(() => process.exit(1), 100).unref();
+        return;
+    }
+    if (abort.signal.aborted || finished)
+        return;
+    if (message?.kind === "begin" && !header) {
+        if (!["native", "text", "image"].includes(message.source) || (message.mimeType?.length ?? 0) > 256)
+            throw new Error("protocol");
+        header = message;
+        send({ kind: "ready" });
+    }
+    else if (message?.kind === "data" && header && header.source !== "native") {
+        if (typeof message.data !== "string" || message.data.length > PASTE_CHUNK_UNITS)
+            throw new Error("protocol");
+        bytes += Buffer.byteLength(message.data);
+        if (bytes > (header.source === "text" ? PASTE_TEXT_BYTES : Math.ceil(MAX_SOURCE_IMAGE_BYTES / 3) * 4 + 4))
+            throw new ImageAttachmentError(header.source === "text" ? "paste-size" : "image-source-size");
+        fragments.push(message.data);
+        send({ kind: "ready" });
+    }
+    else if (message?.kind === "finish" && header) {
+        const content = header.source === "native" ? await readSystemClipboardContent(abort.signal, true)
+            : header.source === "image" ? { kind: "image", mimeType: header.mimeType ?? "", data: fragments.join("") }
+                : { kind: "text", text: fragments.join("") };
+        fragments = [];
+        if (abort.signal.aborted)
+            return;
+        if (content?.kind === "image") {
+            image = content;
+            send({ kind: "phase", phase: "acquired-image", bytes: Buffer.byteLength(content.data) });
+        }
+        else {
+            const text = content?.text ?? "";
+            const size = Buffer.byteLength(text);
+            if (size > PASTE_TEXT_BYTES)
+                throw new ImageAttachmentError("paste-size");
+            send({ kind: "phase", phase: "acquired-text", bytes: size });
+            if (!text) {
+                present(null);
+                return;
+            }
+            send({ kind: "phase", phase: "classifying", bytes: size });
+            present(await classifyText(text));
+        }
+    }
+    else if (message?.kind === "convert" && image) {
+        const source = image;
+        image = undefined;
+        present(await imagePreparation(source));
+    }
+    else if (message?.kind === "next" && output)
+        nextOutput();
+    else
+        throw new Error("protocol");
+}
+process.on("message", message => { void receive(message).catch(fail); });
+process.on("disconnect", () => { abort.abort(); process.exit(0); });
+send({ kind: "ready" });

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

@@ -0,0 +1,16 @@
+import { type PasteEvent, type PasteSource, type PreparedPaste } from "./paste-protocol.js";
+export interface PreparedPasteJob<T> {
+    readonly result: Promise<T>;
+    cancel(): void;
+    complete(): void;
+    isCurrent(): boolean;
+}
+/** Keeps eight distinct paste transactions alive through insertion; canceled executors retain capacity until fenced. */
+export declare class PastePreparationClient {
+    #private;
+    private readonly onEvent?;
+    constructor(onEvent?: ((event: PasteEvent) => void) | undefined);
+    start<T>(source: PasteSource, adopt: (value: PreparedPaste, signal: AbortSignal) => Promise<T> | T, onImage: () => void, onText?: () => void): PreparedPasteJob<T>;
+    reset(): void;
+    dispose(): Promise<void>;
+}