@timurproko/a1 0.1.8-dev.368 → 0.1.8-dev.402

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

@@ -0,0 +1,18 @@
+import { MAX_CLIPBOARD_TEXT_BYTES } from "../../../contracts/owned-ui/index.js";
+export const PASTE_READ_MS = 5_000;
+export const PASTE_TOTAL_MS = 15_000;
+export const PASTE_STOP_MS = 250;
+export const PASTE_TEXT_BYTES = MAX_CLIPBOARD_TEXT_BYTES;
+export const PASTE_CHUNK_UNITS = 16_384;
+export const PASTE_REQUESTS = 8;
+/** Split without breaking UTF-16 surrogate pairs, so per-fragment UTF-8 accounting is exact. */
+export function* pasteFragments(text) {
+    for (let offset = 0; offset < text.length;) {
+        let end = Math.min(text.length, offset + PASTE_CHUNK_UNITS);
+        const last = text.charCodeAt(end - 1);
+        if (end < text.length && last >= 0xd800 && last <= 0xdbff)
+            end--;
+        yield text.slice(offset, end);
+        offset = end;
+    }
+}

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

@@ -0,0 +1,20 @@
+export interface ClipboardPath {
+    readonly fullPath: string;
+    readonly kind: "folder" | "file";
+}
+export type PreparedPasteText = {
+    readonly kind: "text";
+    readonly text: string;
+    readonly label?: string;
+} | {
+    readonly kind: "url";
+    readonly url: string;
+    readonly label: string;
+} | {
+    readonly kind: "paths";
+    readonly paths: readonly ClipboardPath[];
+};
+/** Small non-path text has a fixed CPU bound and cannot enter filesystem probing. */
+export declare function canPreparePasteInline(text: string): boolean;
+/** The shared chip classifier; interactive callers run path/filesystem probing in an isolated executor. */
+export declare function preparePasteText(text: string, skipPaths?: boolean, compactPaths?: boolean): PreparedPasteText;

package/dist/integrations/pi/session-ui/paste-text-preparation.js

@@ -0,0 +1,134 @@
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { prepareTextPaste } from "./text-paste.js";
+import { preparePathPresentation } from "./path-chip-presentation.js";
+const URL_PATTERN = /^https?:\/\/[^\s\u0000-\u001f\u007f]+$/iu;
+/** Small non-path text has a fixed CPU bound and cannot enter filesystem probing. */
+export function canPreparePasteInline(text) {
+    return text.length <= 1000 && !/^(?:[A-Za-z]:\\|\/|file:\/\/|["'&])/iu.test(text.trimStart());
+}
+/** The shared chip classifier; interactive callers run path/filesystem probing in an isolated executor. */
+export function preparePasteText(text, skipPaths = false, compactPaths = false) {
+    const url = text.trim();
+    if (URL_PATTERN.test(url))
+        return { kind: "url", url, label: url.length <= 40 ? url : `${url.slice(0, 40)}…` };
+    const paths = skipPaths ? [] : pathsFromClipboard(text);
+    if (paths.length > 0)
+        return compactPaths ? preparePathPresentation(paths) : { kind: "paths", paths };
+    return { kind: "text", ...prepareTextPaste(text) };
+}
+function pathsFromClipboard(text) {
+    const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+    if (normalized.length === 0)
+        return [];
+    const paths = [];
+    for (const line of normalized.split("\n").filter(value => value.trim().length > 0)) {
+        const wholeLine = existingClipboardPath(line);
+        if (wholeLine !== null) {
+            paths.push(wholeLine);
+            continue;
+        }
+        const tokens = tokenizePathLine(line)?.filter(token => token.quoted || token.text !== "&");
+        if (tokens === undefined || tokens.length === 0)
+            return [];
+        for (let index = 0; index < tokens.length;) {
+            const token = tokens[index];
+            if (token === undefined)
+                return [];
+            if (token.quoted) {
+                const quoted = existingClipboardPath(token.text);
+                if (quoted === null)
+                    return [];
+                paths.push(quoted);
+                index++;
+                continue;
+            }
+            if (normalizePath(token.text) === null)
+                return [];
+            let runEnd = index;
+            while (runEnd < tokens.length && tokens[runEnd]?.quoted !== true)
+                runEnd++;
+            let matched = null;
+            let matchedEnd = index;
+            for (let end = runEnd; end > index; end--) {
+                matched = existingClipboardPath(tokens.slice(index, end).map(candidate => candidate.text).join(" "));
+                if (matched !== null) {
+                    matchedEnd = end;
+                    break;
+                }
+            }
+            if (matched === null)
+                return [];
+            paths.push(matched);
+            index = matchedEnd;
+        }
+    }
+    return paths;
+}
+function existingClipboardPath(value) {
+    const fullPath = normalizePath(unquote(value.trim()));
+    if (fullPath === null || !existsSync(fullPath))
+        return null;
+    try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory())
+            return { fullPath, kind: "folder" };
+        if (stat.isFile())
+            return { fullPath, kind: "file" };
+    }
+    catch { /* Compatibility: unavailable paths remain ordinary text. */ }
+    return null;
+}
+function tokenizePathLine(line) {
+    const tokens = [];
+    let index = 0;
+    while (index < line.length) {
+        while (index < line.length && /\s/u.test(line[index] ?? ""))
+            index++;
+        if (index >= line.length)
+            break;
+        const quote = line[index] === '"' || line[index] === "'" ? line[index] : undefined;
+        if (quote !== undefined) {
+            index++;
+            const start = index;
+            while (index < line.length && line[index] !== quote)
+                index++;
+            if (index >= line.length)
+                return undefined;
+            tokens.push({ text: line.slice(start, index), quoted: true });
+            index++;
+            if (index < line.length && !/\s/u.test(line[index] ?? ""))
+                return undefined;
+            continue;
+        }
+        const start = index;
+        while (index < line.length && !/\s/u.test(line[index] ?? ""))
+            index++;
+        tokens.push({ text: line.slice(start, index), quoted: false });
+    }
+    return tokens;
+}
+function normalizePath(value) {
+    let candidate = value;
+    if (/^file:\/\//iu.test(candidate)) {
+        try {
+            candidate = fileURLToPath(candidate);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (process.platform === "win32") {
+        const msys = /^\/([A-Za-z])\/(.*)$/u.exec(candidate);
+        if (msys !== null)
+            candidate = `${msys[1]}:\\${msys[2]?.replaceAll("/", "\\") ?? ""}`;
+    }
+    return /^(?:[A-Za-z]:\\|\/)/u.test(candidate) ? path.normalize(candidate) : null;
+}
+function unquote(value) {
+    let result = value.startsWith("& ") ? value.slice(2).trim() : value;
+    if ((result.startsWith('"') && result.endsWith('"')) || (result.startsWith("'") && result.endsWith("'")))
+        result = result.slice(1, -1).trim();
+    return result;
+}

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

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

package/dist/integrations/pi/session-ui/paste-text-worker.js

@@ -0,0 +1,12 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { preparePasteText } from "./paste-text-preparation.js";
+// Concurrency: the containing paste process can exit even if a filesystem probe blocks this worker.
+try {
+    parentPort?.postMessage({ ok: true, value: preparePasteText(workerData, false, true) });
+}
+catch {
+    parentPort?.postMessage({ ok: false });
+}
+finally {
+    parentPort?.close();
+}

package/dist/integrations/pi/session-ui/path-chip-presentation.d.ts

@@ -0,0 +1,7 @@
+import type { ClipboardPath, PreparedPasteText } from "./paste-text-preparation.js";
+export declare const PATH_CHIP_PRESENTATION_UNITS = 4096;
+export declare const PATH_CHIP_SUFFIX_UNITS = 20;
+/** Shared base tag for presentation budgeting and actual chip adoption, including image-file spacing. */
+export declare function pathChipTag(item: ClipboardPath): string;
+/** Run in the isolated preparer: compact before path arrays become an oversized editor presentation. */
+export declare function preparePathPresentation(paths: readonly ClipboardPath[]): PreparedPasteText;

package/dist/integrations/pi/session-ui/path-chip-presentation.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+export const PATH_CHIP_PRESENTATION_UNITS = 4096;
+// Invariant: a collision suffix containing any safe-integer index fits this per-occurrence reserve.
+export const PATH_CHIP_SUFFIX_UNITS = 20;
+const IMAGE_EXTENSION = /\.(?:jpe?g|png|webp|gif|bmp|tiff?)$/iu;
+/** Shared base tag for presentation budgeting and actual chip adoption, including image-file spacing. */
+export function pathChipTag(item) {
+    const label = path.basename(item.fullPath) || path.parse(item.fullPath).root.replace(/[\\/]+$/u, "") || item.fullPath;
+    const icon = item.kind === "folder" ? "📁" : IMAGE_EXTENSION.test(item.fullPath) ? "🖼 " : "📄";
+    return `[${icon} ${label}]`;
+}
+/** Run in the isolated preparer: compact before path arrays become an oversized editor presentation. */
+export function preparePathPresentation(paths) {
+    let units = 0;
+    for (const item of paths) {
+        units += pathChipTag(item).length + PATH_CHIP_SUFFIX_UNITS;
+        if (units > PATH_CHIP_PRESENTATION_UNITS) {
+            // Compatibility: individual adjacent chips expand without inserted separators or text re-normalization.
+            const text = paths.map(value => value.fullPath).join("");
+            return { kind: "text", text, label: `${text.length} chars` };
+        }
+    }
+    return { kind: "paths", paths };
+}

package/dist/integrations/pi/session-ui/prompt-chips.d.ts

@@ -1,4 +1,5 @@
 import type { PiShellClipboardContent, PiShellEditorTextRange } from "../components/index.js";
+import type { PasteEvent, PasteSource } from "./paste-protocol.js";
 export interface PromptImageAttachment {
     readonly type: "image";
     readonly data: string;
@@ -11,9 +12,15 @@ export interface PreparedPrompt {
 /** Owns semantic chips and bounded pending paste references; cancels background work on reset or disposal. */
 export declare class PromptChipStore {
     #private;
-    beginPaste(currentText: string, read: (signal: AbortSignal) => Promise<PiShellClipboardContent | null>, onError: (error: unknown) => void, onImage?: () => void): {
+    constructor(options?: {
+        readonly isolated?: boolean;
+        readonly onEvent?: (event: PasteEvent) => void;
+    });
+    beginPaste(currentText: string, read: ((signal: AbortSignal) => Promise<PiShellClipboardContent | null>) | PasteSource, onError: (error: unknown) => void, onImage?: () => void): {
         marker: string;
         result: Promise<string>;
+        complete?(): void;
+        isCurrent?(): boolean;
     };
     hasPending(text: string): boolean;
     waitForPastes(text: string, signal: AbortSignal, readDraft?: () => string): Promise<PreparedPrompt>;

package/dist/integrations/pi/session-ui/prompt-chips.js

@@ -1,14 +1,12 @@
 import { randomBytes } from "node:crypto";
-import { existsSync, statSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { canonicalizeClipboardImage } from "./clipboard-image.js";
 import { assertImageEncodedSize, assertPromptImages, ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
 import { ImagePreparationClient } from "./image-preparation-client.js";
-import { prepareTextPaste } from "./text-paste.js";
+import { preparePasteText } from "./paste-text-preparation.js";
+import { pathChipTag } from "./path-chip-presentation.js";
+import { PastePreparationClient } from "./paste-preparation-client.js";
 const CHIP_PATTERN = /\[(?:paste #\d+ (?:\+\d+ lines|\d+ chars)|📷 [^\]]+|📁 [^\]]+|📄 [^\]]+|🖼 {1,2}[^\]]+|🔗 [^\]]+)\]/gu;
-const IMAGE_EXTENSION = /\.(?:jpe?g|png|webp|gif|bmp|tiff?)$/iu;
-const URL_PATTERN = /^https?:\/\/[^\s\u0000-\u001f\u007f]+$/iu;
 const URL_SUBSTRING_PATTERN = /https?:\/\/[^\s\u0000-\u001f\u007f\]]+/giu;
 const IMAGE_CHIP_IDENTIFIER_PATTERN = /^\[📷 screenshot-([a-f0-9]+)(?:-resized)?\]$/u;
 const URL_DISPLAY_LENGTH = 40;
@@ -24,7 +22,17 @@ export class PromptChipStore {
     #pending = new Map();
     #preparation = new ImagePreparationClient();
     #stopping = new Set();
+    #isolated;
+    #provisionalOwners = new Map();
+    #ownedChipTags = new Map();
+    constructor(options = {}) {
+        this.#isolated = options.isolated ? new PastePreparationClient(options.onEvent) : undefined;
+    }
     beginPaste(currentText, read, onError, onImage = () => { }) {
+        if (this.#isolated)
+            return this.#beginIsolatedPaste(currentText, typeof read === "function" ? { kind: "provided", read } : read, onError, onImage);
+        if (typeof read !== "function")
+            throw new Error("Clipboard sources require isolated paste preparation");
         const id = randomBytes(5).toString("hex");
         // Invariant: reserve paste identity immediately, but only display a screenshot after identifying an image.
         const marker = `[📷 screenshot-${id}]`;
@@ -57,6 +65,56 @@ export class PromptChipStore {
         this.#pending.set(marker, entry);
         return { marker, result: entry.completion };
     }
+    #beginIsolatedPaste(currentText, source, onError, onImage) {
+        const id = randomBytes(5).toString("hex");
+        const marker = `[📷 screenshot-${id}]`;
+        let entry;
+        const owner = Symbol("paste");
+        this.#ownedChipTags.set(owner, new Set());
+        const job = this.#isolated.start(source, async (value, signal) => {
+            if (signal.aborted)
+                throw new ImageAttachmentError("image-canceled");
+            if (value === null)
+                return "";
+            if (value.kind === "image")
+                return this.#addPreparedImage(value, id, owner);
+            entry.kind = "text";
+            return this.#adoptPreparedText(value, signal, owner);
+        }, () => {
+            entry.kind = "image";
+            onImage();
+            if (this.#imageCount(currentText) >= 8)
+                throw new ImageAttachmentError("image-count");
+        }, () => { entry.kind = "text"; });
+        entry = { marker, job, references: 0, kind: "unknown", completion: job.result.catch(error => {
+                this.#finishChipOwnership(owner, false);
+                entry.error = error instanceof ImageAttachmentError ? error : new ImageAttachmentError("paste-unavailable");
+                // Compatibility: typed image validation can fail before transfer identifies the payload to this store.
+                if (entry.kind === "unknown" && entry.error.code.startsWith("image-") && entry.error.code !== "image-canceled")
+                    entry.kind = "image";
+                if (entry.error.code !== "image-canceled" && entry.references === 0)
+                    onError(entry.error);
+                return entry.kind === "image" ? marker.replace("screenshot-", "failed-") : "";
+            }).then(replacement => { entry.replacement = replacement; return replacement; }) };
+        entry.onComplete = () => {
+            this.#finishChipOwnership(owner, job.isCurrent() && entry.error === undefined);
+            job.complete();
+        };
+        this.#pending.set(marker, entry);
+        return { marker, result: entry.completion, complete: entry.onComplete, isCurrent: () => job.isCurrent() };
+    }
+    async #adoptPreparedText(value, signal, owner) {
+        if (value.kind !== "paths")
+            return this.#recordPreparedText(value, owner);
+        let text = "";
+        for (let start = 0; start < value.paths.length; start += 32) {
+            if (signal.aborted)
+                throw new ImageAttachmentError("image-canceled");
+            text += this.#recordPreparedText({ kind: "paths", paths: value.paths.slice(start, start + 32) }, owner);
+            await new Promise(resolve => setImmediate(resolve));
+        }
+        return text;
+    }
     hasPending(text) {
         return [...this.#pending.values()].some(item => text.includes(item.marker) && item.replacement === undefined);
     }
@@ -82,6 +140,8 @@ export class PromptChipStore {
         finally {
             for (const entry of entries) {
                 entry.references--;
+                if (entry.replacement !== undefined)
+                    entry.onComplete?.();
                 if (signal.aborted && entry.references === 0 && !readDraft().includes(entry.marker))
                     entry.job.cancel();
             }
@@ -89,8 +149,13 @@ export class PromptChipStore {
     }
     reconcileDraft(text) {
         for (const entry of this.#pending.values()) {
-            if (entry.references === 0 && entry.replacement === undefined && !text.includes(entry.marker))
+            if (entry.references === 0 && !text.includes(entry.marker) && !text.includes(entry.marker.replace("screenshot-", "failed-"))) {
                 entry.job.cancel();
+                if (entry.replacement !== undefined) {
+                    entry.onComplete?.();
+                    this.#pending.delete(entry.marker);
+                }
+            }
         }
     }
     resetPastes(text) {
@@ -98,6 +163,7 @@ export class PromptChipStore {
         for (const entry of this.#pending.values())
             if (entry.replacement === undefined)
                 remaining = remaining.replaceAll(entry.marker, "");
+        this.#isolated?.reset();
         const stopped = this.#preparation.dispose();
         this.#stopping.add(stopped);
         void stopped.finally(() => this.#stopping.delete(stopped));
@@ -108,9 +174,11 @@ export class PromptChipStore {
         return remaining;
     }
     async dispose() {
-        await Promise.all([this.#preparation.dispose(), ...this.#stopping]);
+        await Promise.all([this.#preparation.dispose(), this.#isolated?.dispose(), ...this.#stopping]);
         this.#chips.clear();
         this.#pending.clear();
+        this.#provisionalOwners.clear();
+        this.#ownedChipTags.clear();
     }
     #imageCount(text) {
         const tags = new Set([...this.#chips.values()].filter(chip => chip.kind === "image" && text.includes(chip.tag)).map(chip => chip.tag));
@@ -122,11 +190,12 @@ export class PromptChipStore {
         }
         return tags.size;
     }
-    #addPreparedImage(image, id) {
+    #addPreparedImage(image, id, owner) {
         const tag = `[📷 screenshot-${id}${image.transformed ? "-resized" : ""}]`;
         const attachment = Object.freeze({ type: "image", data: image.data, mimeType: image.mimeType });
         assertPromptImages([attachment]);
         this.#chips.set(tag, { kind: "image", tag, image: attachment });
+        this.#claimChip(tag, owner, true);
         return tag;
     }
     transformPastedContent(content, currentText = "") {
@@ -146,30 +215,30 @@ export class PromptChipStore {
             return tag;
         }
         const text = content.text;
-        if (this.#chips.has(text.trim()))
+        if (this.#chips.has(text.trim())) {
+            this.#claimChip(text.trim(), undefined, false);
             return text.trim();
-        const url = text.trim();
-        if (URL_PATTERN.test(url)) {
-            const label = url.length <= URL_DISPLAY_LENGTH ? url : `${url.slice(0, URL_DISPLAY_LENGTH)}…`;
-            return this.#recordUnique({ kind: "url", tag: `[🔗 ${label}]`, label, url });
         }
-        const paths = pathsFromClipboard(text);
-        if (paths.length === 0) {
-            const paste = prepareTextPaste(text);
-            if (paste.label === undefined)
+        return this.#recordPreparedText(preparePasteText(text));
+    }
+    #recordPreparedText(paste, owner) {
+        if (paste.kind === "url")
+            return this.#recordUnique({ kind: "url", tag: `[🔗 ${paste.label}]`, label: paste.label, url: paste.url }, owner);
+        if (paste.kind === "text") {
+            if (paste.label === undefined) {
+                const tag = paste.text.trim();
+                if (this.#chips.has(tag)) {
+                    this.#claimChip(tag, owner, false);
+                    return tag;
+                }
                 return paste.text;
+            }
             const tag = `[paste #${++this.#textCounter} ${paste.label}]`;
             this.#chips.set(tag, Object.freeze({ kind: "text", tag, text: paste.text }));
+            this.#claimChip(tag, owner, true);
             return tag;
         }
-        return paths.map(item => {
-            const label = pathLabel(item.fullPath);
-            if (item.kind === "folder") {
-                return this.#recordUnique({ kind: "folder", tag: `[📁 ${label}]`, path: item.fullPath });
-            }
-            const icon = IMAGE_EXTENSION.test(item.fullPath) ? "🖼 " : "📄";
-            return this.#recordUnique({ kind: "file", tag: `[${icon} ${label}]`, path: item.fullPath });
-        }).join("");
+        return paste.paths.map(item => this.#recordUnique({ kind: item.kind, tag: pathChipTag(item), path: item.fullPath }, owner)).join("");
     }
     /** Hide provisional clipboard identities until the read identifies an actual image. */
     hiddenRanges(line) {
@@ -373,142 +442,53 @@ export class PromptChipStore {
         });
         return { text: expanded, images };
     }
-    #recordUnique(chip) {
+    #claimChip(tag, owner, created) {
+        if (owner === undefined) {
+            this.#provisionalOwners.delete(tag);
+            return;
+        }
+        let owners = this.#provisionalOwners.get(tag);
+        if (!owners && !created)
+            return; // Invariant: existing committed chips must survive canceled later pastes.
+        if (!owners) {
+            owners = new Set();
+            this.#provisionalOwners.set(tag, owners);
+        }
+        owners.add(owner);
+        this.#ownedChipTags.get(owner)?.add(tag);
+    }
+    #finishChipOwnership(owner, commit) {
+        for (const tag of this.#ownedChipTags.get(owner) ?? []) {
+            const owners = this.#provisionalOwners.get(tag);
+            if (!owners?.has(owner))
+                continue;
+            if (commit)
+                this.#provisionalOwners.delete(tag);
+            else {
+                owners.delete(owner);
+                if (owners.size === 0) {
+                    this.#provisionalOwners.delete(tag);
+                    this.#chips.delete(tag);
+                }
+            }
+        }
+        this.#ownedChipTags.delete(owner);
+    }
+    #recordUnique(chip, owner) {
         const existing = this.#chips.get(chip.tag);
         if (existing === undefined || sameChipValue(existing, chip)) {
             this.#chips.set(chip.tag, chip);
+            this.#claimChip(chip.tag, owner, existing === undefined);
             return chip.tag;
         }
         const suffix = randomBytes(2).toString("hex");
         const uniqueTag = `${chip.tag.slice(0, -1)} #${suffix}]`;
         const unique = { ...chip, tag: uniqueTag };
         this.#chips.set(uniqueTag, unique);
+        this.#claimChip(uniqueTag, owner, true);
         return uniqueTag;
     }
 }
-function pathsFromClipboard(text) {
-    const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
-    if (normalized.length === 0)
-        return [];
-    const paths = [];
-    for (const line of normalized.split("\n").filter(value => value.trim().length > 0)) {
-        const wholeLine = existingClipboardPath(line);
-        if (wholeLine !== null) {
-            paths.push(wholeLine);
-            continue;
-        }
-        const tokens = tokenizePathLine(line)?.filter(token => token.quoted || token.text !== "&");
-        if (tokens === undefined || tokens.length === 0)
-            return [];
-        for (let index = 0; index < tokens.length;) {
-            const token = tokens[index];
-            if (token === undefined)
-                return [];
-            if (token.quoted) {
-                const quoted = existingClipboardPath(token.text);
-                if (quoted === null)
-                    return [];
-                paths.push(quoted);
-                index += 1;
-                continue;
-            }
-            if (normalizePath(token.text) === null)
-                return [];
-            let runEnd = index;
-            while (runEnd < tokens.length && tokens[runEnd]?.quoted !== true)
-                runEnd += 1;
-            let matched = null;
-            let matchedEnd = index;
-            for (let end = runEnd; end > index; end -= 1) {
-                matched = existingClipboardPath(tokens.slice(index, end).map(candidate => candidate.text).join(" "));
-                if (matched !== null) {
-                    matchedEnd = end;
-                    break;
-                }
-            }
-            if (matched === null)
-                return [];
-            paths.push(matched);
-            index = matchedEnd;
-        }
-    }
-    return paths;
-}
-function existingClipboardPath(value) {
-    const fullPath = normalizePath(unquote(value.trim()));
-    if (fullPath === null || !existsSync(fullPath))
-        return null;
-    try {
-        const stat = statSync(fullPath);
-        if (stat.isDirectory())
-            return { fullPath, kind: "folder" };
-        if (stat.isFile())
-            return { fullPath, kind: "file" };
-    }
-    catch {
-        // Compatibility: clipboard path probing is best-effort.
-    }
-    return null;
-}
-function tokenizePathLine(line) {
-    const tokens = [];
-    let index = 0;
-    while (index < line.length) {
-        while (index < line.length && /\s/u.test(line[index] ?? ""))
-            index += 1;
-        if (index >= line.length)
-            break;
-        const quote = line[index] === '"' || line[index] === "'" ? line[index] : undefined;
-        if (quote !== undefined) {
-            index += 1;
-            const start = index;
-            while (index < line.length && line[index] !== quote)
-                index += 1;
-            if (index >= line.length)
-                return undefined;
-            tokens.push({ text: line.slice(start, index), quoted: true });
-            index += 1;
-            if (index < line.length && !/\s/u.test(line[index] ?? ""))
-                return undefined;
-            continue;
-        }
-        const start = index;
-        while (index < line.length && !/\s/u.test(line[index] ?? ""))
-            index += 1;
-        tokens.push({ text: line.slice(start, index), quoted: false });
-    }
-    return tokens;
-}
-function normalizePath(value) {
-    let candidate = value;
-    if (/^file:\/\//iu.test(candidate)) {
-        try {
-            candidate = fileURLToPath(candidate);
-        }
-        catch {
-            return null;
-        }
-    }
-    if (process.platform === "win32") {
-        const msys = /^\/([A-Za-z])\/(.*)$/u.exec(candidate);
-        if (msys !== null)
-            candidate = `${msys[1]}:\\${msys[2]?.replaceAll("/", "\\") ?? ""}`;
-    }
-    return /^(?:[A-Za-z]:\\|\/)/u.test(candidate) ? path.normalize(candidate) : null;
-}
-function unquote(value) {
-    let result = value.startsWith("& ") ? value.slice(2).trim() : value;
-    if ((result.startsWith('"') && result.endsWith('"')) || (result.startsWith("'") && result.endsWith("'"))) {
-        result = result.slice(1, -1).trim();
-    }
-    return result;
-}
-function pathLabel(fullPath) {
-    const basename = path.basename(fullPath);
-    if (basename.length > 0)
-        return basename;
-    return path.parse(fullPath).root.replace(/[\\/]+$/u, "") || fullPath;
-}
 function sameChipValue(left, right) {
     if (left.kind !== right.kind)
         return false;

package/dist/integrations/pi/session-ui/response-copy-coordinator.d.ts

@@ -0,0 +1,27 @@
+import { type SelectionCopySnapshot } from "../../../ui/components/index.js";
+import { type CopyResult, type ResponseCopyEvent } from "./response-copy-protocol.js";
+import type { ResponseCopyExecutor } from "./response-copy-transport.js";
+/** Owns one delivery and one newest pending copy, including expiry and side-effect fencing. */
+export declare class ResponseCopyCoordinator {
+    #private;
+    private readonly options;
+    constructor(options: {
+        readonly execute: ResponseCopyExecutor;
+        readonly onEvent?: (event: ResponseCopyEvent) => void;
+        readonly onFailure?: (result: CopyResult) => void;
+        readonly now?: () => number;
+    });
+    get busy(): boolean;
+    get latest(): Promise<CopyResult>;
+    /** Exact prompt copy/cut shares the write lifetime without transcript text transformations. */
+    submitText(text: string): Promise<CopyResult>;
+    /** Admission is synchronous, but preparation/startup never runs in the input handler's stack. */
+    submit(snapshot: SelectionCopySnapshot, before?: Promise<void>): Promise<CopyResult>;
+    /** Capture the current copy barrier, without making later copies retroactively delay this paste. */
+    canPaste(signal: AbortSignal): Promise<boolean>;
+    /** Only a pending write is a prerequisite; a completed failure cannot poison independent future reads. */
+    capturePasteBarrier(): (signal: AbortSignal) => Promise<boolean>;
+    /** Session replacement fences the old executor rather than discarding its live side effects. */
+    reset(): void;
+    dispose(): void;
+}