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

package/dist/integrations/pi/session-ui/prompt-history-controller.js

@@ -0,0 +1,170 @@
+import { randomUUID } from "node:crypto";
+import { PROMPT_HISTORY_MAX_TEXT_BYTES } from "../../../contracts/owned-ui/index.js";
+/** Merges bounded recall snapshots; the editor alone owns browsing, draft, cursor, and undo state. */
+export class PromptHistoryController {
+    options;
+    #local = new Map();
+    #unsubscribe;
+    #snapshot;
+    #fallback;
+    #rehydrateCache;
+    #disposed = false;
+    #generation = 0;
+    #unsubscribeSnapshot;
+    #unsubscribeFailure;
+    #closeFailed = false;
+    #closePromise;
+    constructor(options) {
+        this.options = options;
+        if (options.editor.recall === undefined)
+            throw new Error("The selected editor does not expose typed history");
+        this.#snapshot = { revision: 0, limit: options.limit, entries: [] };
+        this.#rehydrateCache = new Map();
+        this.#fallback = boundedTexts([...options.fallback].reverse(), options.limit);
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#unsubscribeFailure = options.store.onFailure(() => {
+            if (this.#disposed)
+                this.#closeFailed = true;
+        });
+        this.#unsubscribe = [
+            options.editor.recall.observe(() => {
+                if (this.#disposed)
+                    return;
+                if (options.editor.recall.position().index === -1)
+                    this.synchronize();
+                options.store.refresh();
+            }),
+        ];
+        this.synchronize();
+    }
+    start() { this.options.store.start(); }
+    capture(text, kind, cwd, sessionId) {
+        const canonical = text.trim();
+        if (!canonical || this.#disposed)
+            return;
+        const id = randomUUID();
+        const generation = this.#generation;
+        this.#local.set(id, { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+        void this.options.store.record({ id, text: canonical, timestamp: Date.now(), kind, cwd, sessionId }).then(outcome => {
+            if (this.#disposed || generation !== this.#generation)
+                return;
+            const local = this.#local.get(id);
+            if (local === undefined || outcome !== "committed")
+                return;
+            local.committed = true;
+            if (this.#snapshot.entries.some(entry => entry.submissionId === id))
+                this.#local.delete(id);
+            this.synchronize();
+        }).catch(() => { });
+    }
+    rememberRecovery(text) {
+        if (this.#disposed || !text.trim())
+            return;
+        const canonical = text.trim();
+        if ([...this.#local.values()].some(item => item.text === canonical)
+            || this.#snapshot.entries.some(item => item.text === canonical))
+            return;
+        this.#local.set(randomUUID(), { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+    }
+    synchronize() {
+        if (this.#disposed || !this.options.active())
+            return;
+        const local = [...this.#local.values()].reverse().map(item => item.text);
+        const saved = this.#snapshot.entries.map(item => item.text);
+        const values = this.#rehydrateAll(local.concat(saved, this.#fallback));
+        this.options.editor.recall.replace(boundedTexts(values, this.#snapshot.limit));
+        this.options.render();
+    }
+    #rehydrateAll(values) {
+        const rehydrate = this.options.rehydrate;
+        if (rehydrate === undefined)
+            return [...values];
+        const cache = this.#rehydrateCache;
+        const results = [];
+        for (const value of values) {
+            const cached = cache.get(value);
+            if (cached !== undefined) {
+                results.push(cached);
+                continue;
+            }
+            const rendered = rehydrate(value);
+            cache.set(value, rendered);
+            results.push(rendered);
+        }
+        if (cache.size > 512) {
+            // Performance: keep the cache bounded so long sessions cannot grow it without limit.
+            const keys = [...cache.keys()].slice(0, cache.size - 256);
+            for (const key of keys)
+                cache.delete(key);
+        }
+        return results;
+    }
+    reset(fallback) {
+        this.#generation++;
+        this.#unsubscribeSnapshot();
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#fallback = boundedTexts([...fallback].reverse(), this.options.limit);
+        this.#local.clear();
+        this.#rehydrateCache.clear();
+        this.options.editor.recall.reset();
+        this.synchronize();
+        this.options.store.refresh();
+    }
+    close() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
+        this.#disposed = true;
+        this.#unsubscribeSnapshot();
+        for (const unsubscribe of this.#unsubscribe)
+            unsubscribe();
+        this.#local.clear();
+        this.#fallback = [];
+        this.#closePromise = this.options.store.close().then(() => !this.#closeFailed, () => false)
+            .finally(() => this.#unsubscribeFailure());
+        return this.#closePromise;
+    }
+    #subscribeSnapshot() {
+        const generation = this.#generation;
+        return this.options.store.onSnapshot(snapshot => {
+            if (this.#disposed || generation !== this.#generation || snapshot.revision < this.#snapshot.revision)
+                return;
+            this.#snapshot = snapshot;
+            for (const [id, entry] of this.#local) {
+                if (entry.committed || snapshot.entries.some(saved => saved.submissionId === id))
+                    this.#local.delete(id);
+            }
+            this.synchronize();
+        });
+    }
+    #boundLocal() {
+        let bytes = [...this.#local.values()].reduce((sum, item) => sum + Buffer.byteLength(item.text), 0);
+        while (this.#local.size > this.options.limit || bytes > PROMPT_HISTORY_MAX_TEXT_BYTES) {
+            const id = this.#local.keys().next().value;
+            bytes -= Buffer.byteLength(this.#local.get(id).text);
+            this.#local.delete(id);
+        }
+    }
+}
+function boundedTexts(values, limit) {
+    const result = [];
+    const seen = new Set();
+    let bytes = 0;
+    for (const value of values) {
+        const text = value.trim();
+        if (!text || seen.has(text))
+            continue;
+        const size = Buffer.byteLength(text);
+        if (bytes + size > PROMPT_HISTORY_MAX_TEXT_BYTES)
+            continue;
+        result.push(text);
+        seen.add(text);
+        bytes += size;
+        if (result.length >= limit)
+            break;
+    }
+    return result;
+}

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

@@ -0,0 +1,35 @@
+import { type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionIdentity, type OwnedUiPromptSuggestionState, type SuggestionDecision, type SuggestionDecisionReason, type SuggestionDiagnosticObserver } from "../../../contracts/owned-ui/index.js";
+export interface ContextualPromptSuggestionSurface {
+    canPresent(identity: OwnedUiPromptSuggestionIdentity): boolean;
+    presentationBlockReason?(identity: OwnedUiPromptSuggestionIdentity): SuggestionDecision;
+    present(text: string): boolean;
+    clear(): void;
+    requestRender(): void;
+}
+export interface ContextualPromptSuggestionControllerOptions {
+    readonly generator: OwnedUiPromptSuggestionGeneratorPort;
+    readonly surface: ContextualPromptSuggestionSurface;
+    readonly enabled: boolean;
+    readonly timeoutMs?: number;
+    readonly diagnostics?: SuggestionDiagnosticObserver;
+    readonly now?: () => number;
+}
+type DecisionIdentity = Omit<OwnedUiPromptSuggestionIdentity, "model"> & {
+    readonly model: OwnedUiPromptSuggestionIdentity["model"] | null;
+};
+/** Prefetches one inert candidate; owns retirement even when a provider ignores abort. */
+export declare class ContextualPromptSuggestionController {
+    #private;
+    readonly options: ContextualPromptSuggestionControllerOptions;
+    constructor(options: ContextualPromptSuggestionControllerOptions);
+    get state(): OwnedUiPromptSuggestionState;
+    setEnabled(enabled: boolean): void;
+    skip(identity: DecisionIdentity, reason: SuggestionDecisionReason): void;
+    consider(identity: OwnedUiPromptSuggestionIdentity, decision: boolean | SuggestionDecision): void;
+    settle(identity: OwnedUiPromptSuggestionIdentity): void;
+    accept(): void;
+    invalidate(): void;
+    dispose(): void;
+}
+export declare function samePromptSuggestionIdentity(left: OwnedUiPromptSuggestionIdentity, right: OwnedUiPromptSuggestionIdentity): boolean;
+export {};

package/dist/integrations/pi/session-ui/prompt-suggestion-controller.js

@@ -0,0 +1,207 @@
+import { assertOwnedUiPromptSuggestionResult, normalizePromptSuggestionCandidate, } from "../../../contracts/owned-ui/index.js";
+/** Prefetches one inert candidate; owns retirement even when a provider ignores abort. */
+export class ContextualPromptSuggestionController {
+    options;
+    #state = { status: "idle" };
+    #request = null;
+    #lastConsidered = "";
+    #enabled;
+    #disposed = false;
+    #sessionKey = "";
+    #sessionSequence = 0;
+    #requestSequence = 0;
+    #timeoutMs;
+    #now;
+    constructor(options) {
+        this.options = options;
+        this.#enabled = options.enabled;
+        this.#timeoutMs = options.timeoutMs ?? 15_000;
+        this.#now = options.now ?? Date.now;
+    }
+    get state() { return this.#state; }
+    setEnabled(enabled) {
+        if (this.#enabled === enabled)
+            return;
+        this.#enabled = enabled;
+        this.invalidate();
+    }
+    skip(identity, reason) {
+        this.invalidate();
+        this.#emit(this.#metadata(identity), "skipped", reason);
+    }
+    consider(identity, decision) {
+        const key = identityKey(identity);
+        if (key === this.#lastConsidered)
+            return;
+        this.#lastConsidered = key;
+        this.invalidate();
+        const reason = this.#disposed ? "disposed" : !this.#enabled ? "disabled"
+            : decision === false ? "ineligible" : decision === true ? null : decision;
+        if (reason !== null) {
+            this.#emit(this.#metadata(identity), "skipped", reason);
+            return;
+        }
+        let reasoning = "unavailable";
+        try {
+            reasoning = this.options.generator.suggestionReasoningPolicy?.() ?? "unavailable";
+        }
+        catch { /* Security: isolate diagnostic metadata failure. */ }
+        const request = {
+            identity,
+            metadata: { ...this.#metadata(identity), request: ++this.#requestSequence, reasoning },
+            abort: new AbortController(), startedAt: this.#now(), terminal: false,
+        };
+        this.#request = request;
+        this.#state = { status: "generating", identity, settled: false };
+        this.#emit(request.metadata, "started");
+        request.timer = setTimeout(() => {
+            if (this.#request !== request || this.#state.status !== "generating")
+                return;
+            this.#finish(request, "timeout");
+            this.#state = { status: "idle" };
+            this.#request = null;
+            request.abort.abort();
+        }, this.#timeoutMs);
+        request.timer.unref?.();
+        try {
+            void this.options.generator.generate({ identity, signal: request.abort.signal })
+                .then(result => this.#receive(request, result), () => this.#failed(request))
+                .finally(() => clearTimeout(request.timer));
+        }
+        catch {
+            this.#failed(request);
+        }
+    }
+    settle(identity) {
+        if (this.#disposed || !this.#enabled || this.#state.status === "idle")
+            return;
+        if (!samePromptSuggestionIdentity(this.#state.identity, identity)) {
+            if (this.#request)
+                this.#finish(this.#request, "stale-result", "stale-identity");
+            this.invalidate();
+            return;
+        }
+        if (this.#state.status === "generating")
+            this.#state = { ...this.#state, settled: true };
+        else if (this.#state.status === "prepared" && this.#request)
+            this.#show(this.#request, this.#state.text);
+    }
+    accept() { this.#invalidate(false); }
+    invalidate() { this.#invalidate(true); }
+    dispose() {
+        this.#disposed = true;
+        this.invalidate();
+        this.#lastConsidered = "";
+        this.#sessionKey = "";
+    }
+    #invalidate(clearSurface) {
+        const hadVisibleSuggestion = this.#state.status === "available";
+        const request = this.#request;
+        if (request)
+            this.#finish(request, "cancelled");
+        this.#request = null;
+        this.#state = { status: "idle" };
+        request?.abort.abort();
+        if (clearSurface && hadVisibleSuggestion) {
+            this.options.surface.clear();
+            this.options.surface.requestRender();
+        }
+    }
+    #failed(request) {
+        if (this.#request !== request || request.terminal) {
+            this.#late(request);
+            return;
+        }
+        this.#finish(request, "provider-failure");
+        this.#request = null;
+        this.#state = { status: "idle" };
+    }
+    #receive(request, result) {
+        if (this.#disposed || this.#request !== request || request.terminal || this.#state.status !== "generating") {
+            this.#late(request);
+            return;
+        }
+        try {
+            assertOwnedUiPromptSuggestionResult(result);
+        }
+        catch {
+            this.#finish(request, "rejected");
+            this.invalidate();
+            return;
+        }
+        if (!samePromptSuggestionIdentity(request.identity, result.identity)) {
+            this.#finish(request, "stale-result", "stale-identity");
+            this.invalidate();
+            return;
+        }
+        if (result.outcome !== "candidate") {
+            this.#finish(request, result.outcome);
+            this.invalidate();
+            return;
+        }
+        const text = normalizePromptSuggestionCandidate(result.text);
+        if (text === null) {
+            this.#finish(request, "rejected");
+            this.invalidate();
+            return;
+        }
+        clearTimeout(request.timer);
+        if (this.#state.settled)
+            this.#show(request, text);
+        else
+            this.#state = { status: "prepared", identity: request.identity, text };
+    }
+    #show(request, text) {
+        const reason = this.options.surface.presentationBlockReason?.(request.identity)
+            ?? (this.options.surface.canPresent(request.identity) ? null : "presentation-unavailable");
+        if (reason !== null || !this.options.surface.present(text)) {
+            this.#finish(request, "presentation-blocked", reason ?? "presentation-unavailable");
+            this.invalidate();
+            return;
+        }
+        this.#state = { status: "available", identity: request.identity, text };
+        this.#finish(request, "displayed");
+        this.options.surface.requestRender();
+    }
+    #finish(request, event, reason) {
+        if (request.terminal)
+            return;
+        // Concurrency: retire before notifying observers or aborting; neither may rewrite the winner.
+        request.terminal = true;
+        clearTimeout(request.timer);
+        this.#emit({ ...request.metadata, elapsedMs: Math.max(0, this.#now() - request.startedAt) }, event, reason);
+    }
+    #late(request) {
+        if (!this.#disposed)
+            this.#emit({ ...request.metadata, elapsedMs: Math.max(0, this.#now() - request.startedAt) }, "late-result-discarded");
+    }
+    #metadata(identity) {
+        const key = `${identity.sessionId}\0${identity.sessionGeneration}`;
+        if (this.#sessionKey !== key) {
+            this.#sessionKey = key;
+            this.#sessionSequence++;
+        }
+        return {
+            event: "skipped", session: this.#sessionSequence, run: identity.runSequence, response: identity.responseSequence,
+            request: 0, provider: identity.model?.providerId ?? "", model: identity.model?.modelId ?? "",
+            reasoning: "unavailable", elapsedMs: 0,
+        };
+    }
+    #emit(metadata, event, reason) {
+        try {
+            this.options.diagnostics?.record({ ...metadata, event, ...(reason === undefined ? {} : { reason }) });
+        }
+        catch { /* Security: diagnostics never own input or lifecycle. */ }
+    }
+}
+export function samePromptSuggestionIdentity(left, right) {
+    return left.sessionId === right.sessionId
+        && left.sessionGeneration === right.sessionGeneration
+        && left.runSequence === right.runSequence
+        && left.responseSequence === right.responseSequence
+        && left.model.providerId === right.model.providerId
+        && left.model.modelId === right.model.modelId;
+}
+function identityKey(identity) {
+    return `${identity.sessionId}\0${identity.sessionGeneration}\0${identity.runSequence}\0${identity.responseSequence}\0${identity.model.providerId}\0${identity.model.modelId}`;
+}

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;
+}

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

@@ -0,0 +1,189 @@
+import { MAX_COPY_SOURCE_UNITS } from "../../../ui/components/index.js";
+import { COPY_CLEANUP_MS, COPY_DEADLINE_MS } from "./response-copy-protocol.js";
+/** Owns one delivery and one newest pending copy, including expiry and side-effect fencing. */
+export class ResponseCopyCoordinator {
+    options;
+    #sequence = 0;
+    #epoch = 0;
+    #active;
+    #pending;
+    #latest = Promise.resolve({ outcome: "delivered" });
+    #latestPending = false;
+    #disposed = false;
+    #quarantined = false;
+    constructor(options) {
+        this.options = options;
+    }
+    get busy() { return this.#active !== undefined || this.#pending !== undefined; }
+    get latest() { return this.#latest; }
+    /** Exact prompt copy/cut shares the write lifetime without transcript text transformations. */
+    submitText(text) {
+        return this.submit(Object.freeze({
+            literal: true, revision: 0, sourceUnits: text.length,
+            selection: Object.freeze({ start: Object.freeze({ line: 0, column: 0 }), end: Object.freeze({ line: 0, column: Number.MAX_SAFE_INTEGER }) }),
+            rows: Object.freeze(text.length > MAX_COPY_SOURCE_UNITS ? [] : [Object.freeze({ text })]),
+            ...(text.length > MAX_COPY_SOURCE_UNITS ? { rejected: "size" } : {}),
+        }));
+    }
+    /** Admission is synchronous, but preparation/startup never runs in the input handler's stack. */
+    submit(snapshot, before = Promise.resolve()) {
+        const id = ++this.#sequence;
+        const admitted = this.#now() - (snapshot.captureMs ?? 0);
+        let resolve;
+        const result = new Promise(done => { resolve = done; });
+        this.#latest = result;
+        this.#latestPending = true;
+        const request = {
+            id, epoch: this.#epoch, admitted, sourceUnits: snapshot.sourceUnits, snapshot, before, resolve, done: false, submitting: false,
+            timer: setTimeout(() => this.#cancel(request, { outcome: "timed-out" }), Math.max(0, COPY_DEADLINE_MS - (snapshot.captureMs ?? 0))),
+        };
+        request.timer.unref?.();
+        this.#trace(request, "capture", { elapsedMs: snapshot.captureMs ?? 0 });
+        if (snapshot.literal !== true)
+            this.#trace(request, "selection-clear");
+        if (this.#disposed || this.#quarantined || snapshot.rejected) {
+            this.#settle(request, { outcome: this.#disposed ? "canceled" : "failed", failure: snapshot.rejected ? "size" : "unsafe" });
+            return result;
+        }
+        if (this.#pending)
+            this.#cancel(this.#pending, { outcome: "superseded" });
+        this.#pending = request;
+        if (this.#active && !this.#active.submitting)
+            this.#cancel(this.#active, { outcome: "superseded" });
+        this.#trace(request, "queued");
+        this.#drain();
+        return result;
+    }
+    /** Capture the current copy barrier, without making later copies retroactively delay this paste. */
+    canPaste(signal) { return this.capturePasteBarrier()(signal); }
+    /** Only a pending write is a prerequisite; a completed failure cannot poison independent future reads. */
+    capturePasteBarrier() {
+        const latest = this.#latestPending ? this.#latest : undefined;
+        return async (signal) => {
+            if (signal.aborted)
+                return false;
+            if (latest === undefined)
+                return true;
+            return new Promise(resolve => {
+                const abort = () => resolve(false);
+                signal.addEventListener("abort", abort, { once: true });
+                void latest.then(result => {
+                    signal.removeEventListener("abort", abort);
+                    resolve(!signal.aborted && (result.outcome === "delivered" || result.outcome === "submitted-unverified"));
+                });
+            });
+        };
+    }
+    /** Session replacement fences the old executor rather than discarding its live side effects. */
+    reset() {
+        this.#epoch++;
+        if (this.#pending)
+            this.#cancel(this.#pending, { outcome: "canceled" });
+        if (this.#active)
+            this.#cancel(this.#active, { outcome: "canceled" });
+        this.#latestPending = false;
+        this.#latest = Promise.resolve({ outcome: "delivered" });
+    }
+    dispose() { this.#disposed = true; this.reset(); }
+    #drain() {
+        if (this.#active || this.#disposed || this.#quarantined)
+            return;
+        const request = this.#pending;
+        this.#pending = undefined;
+        if (!request || request.done)
+            return;
+        this.#active = request;
+        // Concurrency: render and input get an event-loop turn before child startup or source transfer.
+        setImmediate(() => {
+            if (request.done) {
+                this.#release(request);
+                return;
+            }
+            let canceled = false;
+            let executor;
+            const run = request.before.then(async () => {
+                if (canceled || request.done || request.snapshot === undefined)
+                    return { outcome: "canceled" };
+                this.#trace(request, "preparing");
+                executor = this.options.execute(request.snapshot, (phase, bytes, transport) => {
+                    if (request.done)
+                        return;
+                    if (phase === "submitting")
+                        request.submitting = true;
+                    this.#trace(request, phase, { bytes, transport });
+                });
+                return executor.result;
+            }).catch(() => ({ outcome: "failed", failure: "transport" }));
+            // Concurrency: a canceled gate has not started any side effect. Do not wait for an unrelated prior prompt indefinitely.
+            let cancelGate;
+            const gateStopped = new Promise(resolve => { cancelGate = resolve; });
+            const stopped = Promise.race([
+                run.then(async () => { await executor?.stopped; }), gateStopped,
+            ]);
+            request.job = { result: run, stopped, cancel: () => {
+                    canceled = true;
+                    if (executor)
+                        executor.cancel();
+                    else
+                        cancelGate();
+                } };
+            void run.then(result => this.#settle(request, result));
+            void stopped.then(() => this.#release(request));
+        });
+    }
+    #cancel(request, result) {
+        if (request.done)
+            return;
+        this.#settle(request, result);
+        request.job?.cancel();
+        if (this.#pending === request)
+            this.#pending = undefined;
+        if (this.#active === request && request.job) {
+            const cleanup = setTimeout(() => {
+                if (this.#active !== request)
+                    return;
+                this.#quarantined = true;
+                this.#trace(request, "cleanup");
+                if (this.#pending)
+                    this.#cancel(this.#pending, { outcome: "failed", failure: "unsafe" });
+            }, COPY_CLEANUP_MS);
+            cleanup.unref?.();
+            void request.job.stopped.then(() => clearTimeout(cleanup));
+        }
+    }
+    #settle(request, result) {
+        if (request.done)
+            return;
+        request.done = true;
+        if (request.id === this.#sequence)
+            this.#latestPending = false;
+        request.snapshot = undefined;
+        clearTimeout(request.timer);
+        this.#trace(request, "settled", { outcome: result.outcome });
+        request.resolve(result);
+        if (!this.#disposed && request.epoch === this.#epoch && request.id === this.#sequence
+            && (result.outcome === "failed" || result.outcome === "timed-out")) {
+            this.options.onFailure?.(result);
+        }
+    }
+    #release(request) {
+        if (this.#active !== request)
+            return;
+        this.#active = undefined;
+        this.#quarantined = false;
+        this.#trace(request, "cleanup");
+        this.#drain();
+    }
+    #now() { return this.options.now?.() ?? performance.now(); }
+    #trace(request, phase, extra = {}) {
+        if (this.options.onEvent === undefined)
+            return;
+        const atMs = this.#now();
+        // Security: observations contain only bounded scalar metadata, never copied source or encoded content.
+        try {
+            this.options.onEvent({ request: request.id, phase, atMs, elapsedMs: atMs - request.admitted,
+                sourceUnits: request.sourceUnits, pending: Number(this.#active !== undefined) + Number(this.#pending !== undefined), ...extra });
+        }
+        catch { /* Invariant: diagnostics must not alter copy semantics. */ }
+    }
+}

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

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