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

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

@@ -0,0 +1,159 @@
+import { ImageAttachmentError } from "../../../contracts/owned-ui/index.js";
+import { startPasteExecutor } from "./paste-executor.js";
+import { PASTE_READ_MS, PASTE_REQUESTS, PASTE_STOP_MS, PASTE_TOTAL_MS } from "./paste-protocol.js";
+/** Keeps eight distinct paste transactions alive through insertion; canceled executors retain capacity until fenced. */
+export class PastePreparationClient {
+    onEvent;
+    #active = new Set();
+    #sequence = 0;
+    #disposed = false;
+    constructor(onEvent) {
+        this.onEvent = onEvent;
+    }
+    start(source, adopt, onImage, onText = () => { }) {
+        const controller = new AbortController();
+        const id = ++this.#sequence;
+        const admitted = performance.now();
+        let resolve, reject, finish;
+        let settled = false;
+        let executor;
+        const committed = new Promise(done => { finish = done; });
+        const result = new Promise((ok, fail) => { resolve = ok; reject = fail; });
+        const emit = (phase, bytes, outcome) => {
+            const atMs = performance.now();
+            try {
+                this.onEvent?.({ request: id, phase, atMs, elapsedMs: atMs - admitted, pending: this.#active.size, transport: source.kind === "text" ? "terminal" : source.kind,
+                    ...(bytes === undefined ? {} : { bytes }), ...(outcome === undefined ? {} : { outcome }) });
+            }
+            catch { /* Invariant: observations never affect input. */ }
+        };
+        const total = setTimeout(() => controller.abort(new ImageAttachmentError("paste-timeout")), PASTE_TOTAL_MS);
+        let reading = source.kind === "text" ? undefined
+            : setTimeout(() => controller.abort(new ImageAttachmentError("paste-timeout")), PASTE_READ_MS);
+        const clearRead = () => { if (reading)
+            clearTimeout(reading); reading = undefined; };
+        const complete = (outcome = "ready") => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(total);
+            clearRead();
+            finish();
+            emit("settled", undefined, outcome);
+        };
+        controller.signal.addEventListener("abort", () => {
+            if (settled)
+                return;
+            settled = true;
+            executor?.cancel();
+            clearTimeout(total);
+            clearRead();
+            finish();
+            reject(controller.signal.reason ?? new ImageAttachmentError("image-canceled"));
+            const reason = controller.signal.reason;
+            emit("settled", undefined, reason instanceof ImageAttachmentError && reason.code === "paste-timeout" ? "timed-out"
+                : reason instanceof ImageAttachmentError && reason.code === "paste-busy" ? "failed" : "canceled");
+        }, { once: true });
+        const job = {
+            result, complete: () => complete(), isCurrent: () => !controller.signal.aborted,
+            cancel: () => { if (!settled)
+                controller.abort(new ImageAttachmentError("image-canceled")); },
+        };
+        void result.catch(() => { });
+        if (this.#disposed || this.#active.size >= PASTE_REQUESTS) {
+            controller.abort(new ImageAttachmentError(this.#disposed ? "image-canceled" : "paste-busy"));
+            return job;
+        }
+        let stopped;
+        const active = { controller, stopped: new Promise(done => { stopped = done; }) };
+        this.#active.add(active);
+        emit("admitted");
+        // Concurrency: admission/reservation occurs in the input turn; startup and preparation get a later turn.
+        setImmediate(() => {
+            void (async () => {
+                try {
+                    if (controller.signal.aborted)
+                        return;
+                    let content;
+                    if (source.kind !== "text" && source.before) {
+                        emit("predecessor");
+                        if (!await source.before(controller.signal))
+                            throw new ImageAttachmentError("paste-write-failed");
+                    }
+                    if (controller.signal.aborted)
+                        return;
+                    emit("acquiring");
+                    if (source.kind === "text")
+                        content = { kind: "text", text: source.text };
+                    else if (source.kind === "provided") {
+                        const read = await source.read(controller.signal);
+                        clearRead();
+                        if (controller.signal.aborted)
+                            return;
+                        if (read?.kind !== "image")
+                            onText();
+                        if (read === null) {
+                            emit("inserting");
+                            resolve(await adopt(null, controller.signal));
+                            await committed;
+                            return;
+                        }
+                        content = read;
+                    }
+                    executor = startPasteExecutor(content, controller.signal, (phase, bytes) => {
+                        // Protocol: helper exit precedes adoption; only the request's finally block reports complete cleanup.
+                        if (phase === "cleanup")
+                            return;
+                        if (phase === "acquired-text" || phase === "acquired-image")
+                            clearRead();
+                        if (controller.signal.aborted)
+                            return;
+                        if (phase === "acquired-image")
+                            onImage();
+                        if (phase === "acquired-text")
+                            onText();
+                        emit(phase, bytes);
+                    });
+                    const value = await executor.result;
+                    if (controller.signal.aborted)
+                        return;
+                    emit("inserting");
+                    const insertion = await adopt(value, controller.signal);
+                    if (controller.signal.aborted)
+                        return;
+                    resolve(insertion);
+                    await committed;
+                }
+                catch (error) {
+                    if (!controller.signal.aborted) {
+                        reject(error instanceof ImageAttachmentError ? error : new ImageAttachmentError("paste-unavailable"));
+                        complete("failed");
+                    }
+                }
+                finally {
+                    // Invariant: capacity cannot be reused while an old native/codec executor can still consume resources.
+                    await executor?.stopped;
+                    clearTimeout(total);
+                    clearRead();
+                    this.#active.delete(active);
+                    stopped();
+                    emit("cleanup");
+                }
+            })();
+        });
+        return job;
+    }
+    reset() {
+        for (const active of this.#active)
+            active.controller.abort(new ImageAttachmentError("image-canceled"));
+    }
+    async dispose() {
+        this.#disposed = true;
+        this.reset();
+        let timer;
+        await Promise.race([Promise.all([...this.#active].map(active => active.stopped)),
+            new Promise(resolve => { timer = setTimeout(resolve, PASTE_STOP_MS); timer.unref(); })]);
+        if (timer)
+            clearTimeout(timer);
+    }
+}

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

@@ -0,0 +1,78 @@
+import type { PiShellClipboardContent } from "../components/index.js";
+import type { PreparedPasteText, ClipboardPath } from "./paste-text-preparation.js";
+import type { PreparedImage } from "./image-preparation.js";
+export declare const PASTE_READ_MS = 5000;
+export declare const PASTE_TOTAL_MS = 15000;
+export declare const PASTE_STOP_MS = 250;
+export declare const PASTE_TEXT_BYTES: number;
+export declare const PASTE_CHUNK_UNITS = 16384;
+export declare const PASTE_REQUESTS = 8;
+export type PreparedPaste = PreparedPasteText | ({
+    readonly kind: "image";
+} & PreparedImage) | null;
+/** The predecessor is captured at admission; a later copy cannot change what this paste waits for. */
+export type PasteSource = {
+    readonly kind: "native";
+    readonly before?: (signal: AbortSignal) => Promise<boolean>;
+} | {
+    readonly kind: "provided";
+    readonly read: (signal: AbortSignal) => Promise<PiShellClipboardContent | null>;
+    readonly before?: (signal: AbortSignal) => Promise<boolean>;
+} | {
+    readonly kind: "text";
+    readonly text: string;
+};
+export interface PasteEvent {
+    readonly request: number;
+    readonly phase: "receipt" | "framing" | "admitted" | "predecessor" | "acquiring" | "acquired-text" | "acquired-image" | "classifying" | "path-fallback" | "prepared" | "inserting" | "settled" | "cleanup";
+    readonly atMs: number;
+    readonly elapsedMs?: number;
+    readonly pending: number;
+    readonly transport?: "native" | "terminal" | "provided";
+    readonly bytes?: number;
+    readonly outcome?: "ready" | "failed" | "canceled" | "timed-out";
+}
+export type PasteHelperInput = {
+    readonly kind: "begin";
+    readonly source: "native" | "text" | "image";
+    readonly mimeType?: string;
+} | {
+    readonly kind: "data";
+    readonly data: string;
+} | {
+    readonly kind: "finish";
+} | {
+    readonly kind: "convert";
+} | {
+    readonly kind: "next";
+} | {
+    readonly kind: "cancel";
+};
+export type PasteHelperOutput = {
+    readonly kind: "ready";
+} | {
+    readonly kind: "phase";
+    readonly phase: "acquired-text" | "acquired-image" | "classifying" | "path-fallback" | "prepared";
+    readonly bytes?: number;
+} | {
+    readonly kind: "output";
+    readonly type: "text" | "url" | "paths" | "image" | "empty";
+    readonly label?: string;
+    readonly mimeType?: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly transformed?: boolean;
+} | {
+    readonly kind: "data";
+    readonly data: string;
+} | {
+    readonly kind: "path";
+    readonly path: ClipboardPath;
+} | {
+    readonly kind: "done";
+} | {
+    readonly kind: "error";
+    readonly code: string;
+};
+/** Split without breaking UTF-16 surrogate pairs, so per-fragment UTF-8 accounting is exact. */
+export declare function pasteFragments(text: string): Generator<string>;

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

@@ -0,0 +1,72 @@
+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;
+    readonly mimeType: string;
+}
+export interface PreparedPrompt {
+    readonly text: string;
+    readonly images: readonly PromptImageAttachment[];
+}
+/** Owns semantic chips and bounded pending paste references; cancels background work on reset or disposal. */
+export declare class PromptChipStore {
+    #private;
+    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>;
+    reconcileDraft(text: string): void;
+    resetPastes(text: string): string;
+    dispose(): Promise<void>;
+    transformPastedContent(content: PiShellClipboardContent, currentText?: string): string;
+    /** Hide provisional clipboard identities until the read identifies an actual image. */
+    hiddenRanges(line: string): readonly PiShellEditorTextRange[];
+    atomicRanges(line: string): readonly PiShellEditorTextRange[];
+    hyperlinkRanges(text: string): readonly {
+        start: number;
+        end: number;
+        target: string;
+    }[];
+    expandCopiedText(text: string): string;
+    /**
+     * Recall-safe history text. Text / URL / file / folder chips expand to their resolved value
+     * so a restart can reuse them without the originating chip cache. Image chip tags are
+     * preserved verbatim so the sidecar-backed rehydration path can re-render them into live
+     * chips carrying the original attachment bytes.
+     */
+    prepareHistoryText(text: string): string;
+    /**
+     * Extract the image chip attachments referenced by an editor draft in occurrence order,
+     * paired with their sidecar identifier. Callers use this to persist image sidecars before a
+     * history row commits, so a fresh process can rehydrate the same chip layout. Unresolved
+     * pending pastes and non-image chips are skipped; caller is responsible for waiting on
+     * pending readiness before this point.
+     */
+    imageChipAttachments(text: string): {
+        readonly id: string;
+        readonly tag: string;
+        readonly image: PromptImageAttachment;
+    }[];
+    /**
+     * Rehydrate a durable recall value into an editor-ready draft: image chip tags are looked up
+     * against a caller-supplied sidecar resolver, and detectable URL / file / folder / large text
+     * substrings are re-registered as atomic chips through the same identity rules the paste path
+     * uses. Image chips whose sidecar returns null are silently stripped without a placeholder.
+     *
+     * Every chip returned is registered in the session `#chips` map so atomic-range,
+     * hyperlink-range, and submission-expansion paths behave identically to a freshly typed draft.
+     * Callers should treat the returned string as programmatic editor text, not another draft to
+     * scan.
+     */
+    rehydrateHistoryText(text: string, resolveImage: (id: string) => PromptImageAttachment | null): string;
+    prepareSubmission(text: string): PreparedPrompt;
+}