@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/dist/app/session-shell/quit-outro-effects.js

@@ -0,0 +1,242 @@
+/**
+ * Deterministic quit-outro effect plans, ported from the v2 sketch.
+ *
+ * Each effect turns the captured frame's per-row visible widths and a seed into
+ * two sorted schedules over unit playback progress: sparkles paint a glyph at a
+ * cell from `start`, and clears blank a cell at `end`. The player consumes both
+ * in order, so a fixed seed yields a byte-stable animation.
+ */
+export const QUIT_OUTRO_EFFECTS = Object.freeze(["fall", "dissolve", "starburst", "waves"]);
+export function isQuitOutroEffect(value) {
+    return typeof value === "string" && QUIT_OUTRO_EFFECTS.includes(value);
+}
+const WHITE = "\x1b[38;2;238;238;238m";
+const DUST_GLYPHS = [".", "·", "'", ":", "+", "°"];
+const FALL_GLYPHS = [".", ".", "·", "'", ":", "°"];
+const GRAVITY = 85;
+function mulberry32(seed) {
+    let value = seed >>> 0;
+    return () => {
+        value = (value + 0x6d2b79f5) | 0;
+        let next = Math.imul(value ^ (value >>> 15), 1 | value);
+        next = (next + Math.imul(next ^ (next >>> 7), 61 | next)) ^ next;
+        return ((next ^ (next >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function pick(random, values) {
+    return values[Math.floor(random() * values.length)];
+}
+function rowWidth(rowWidths, row) {
+    return Math.max(0, Math.floor(rowWidths[row] ?? 0));
+}
+function finish(sparkles, clears) {
+    sparkles.sort((a, b) => a.start - b.start);
+    clears.sort((a, b) => a.end - b.end);
+    return { sparkles, clears };
+}
+/** Calm white ASCII dust dissolve. */
+function dissolvePlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const sparkles = [];
+    const clears = [];
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const sweep = (row / height) * 0.14 + (col / width) * 0.08;
+            const start = Math.min(0.76, sweep + random() * 0.54);
+            const cell = {
+                row, col, start,
+                end: Math.min(0.96, start + 0.1 + random() * 0.1),
+                glyph: pick(random, DUST_GLYPHS),
+                color: WHITE,
+            };
+            clears.push(cell);
+            if (random() < 0.34)
+                sparkles.push(cell);
+        }
+    }
+    return finish(sparkles, clears);
+}
+/** Soft white harmonic ripple dissolve. */
+function starburstPlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const center = (width - 1) / 2;
+    const sparkles = [];
+    const clears = [];
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const distance = Math.abs(col - center) / Math.max(1, width / 2);
+            const ripple = (Math.sin(distance * Math.PI * 3 + (row / height) * Math.PI) + 1) * 0.035;
+            const sweep = distance * 0.2 + (row / height) * 0.1 + ripple;
+            const start = Math.min(0.79, sweep + random() * 0.34);
+            const cell = {
+                row, col, start,
+                end: Math.min(0.97, start + 0.12 + random() * 0.1),
+                glyph: pick(random, DUST_GLYPHS),
+                color: WHITE,
+            };
+            clears.push(cell);
+            if (random() < 0.38)
+                sparkles.push(cell);
+        }
+    }
+    return finish(sparkles, clears);
+}
+/** White dotted fragments accelerating downward and collecting in a floor pile. */
+function fallPlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const floor = height - 1;
+    const area = Math.max(1, width * height);
+    const fragmentChance = clamp(150 / area, 0.1, 0.24);
+    const particles = [];
+    const sparkles = [];
+    const clears = [];
+    let fallbackParticle;
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const release = 0.025 + random() * 0.13 + (1 - row / height) * 0.035;
+            const glyph = pick(random, FALL_GLYPHS);
+            clears.push({ row, col, start: release, end: release + 0.04, glyph, color: WHITE });
+            if (row >= floor)
+                continue;
+            const particle = { row, col, release, glyph, velocityCol: (random() - 0.5) * 9 };
+            fallbackParticle ??= particle;
+            if (random() < fragmentChance)
+                particles.push(particle);
+        }
+    }
+    if (particles.length === 0 && fallbackParticle)
+        particles.push(fallbackParticle);
+    const arrival = (particle) => particle.release + Math.sqrt((2 * (floor - particle.row)) / GRAVITY);
+    particles.sort((a, b) => arrival(a) - arrival(b));
+    const pileHeights = Array(width).fill(0);
+    for (const particle of particles) {
+        const floorFallTime = Math.max(0.05, Math.sqrt((2 * (floor - particle.row)) / GRAVITY));
+        const predictedCol = clamp(Math.round(particle.col + particle.velocityCol * floorFallTime), 0, width - 1);
+        let landingCol = predictedCol;
+        for (let radius = 1; radius <= 3; radius++) {
+            for (const candidate of [predictedCol - radius, predictedCol + radius]) {
+                if (candidate >= 0 && candidate < width && pileHeights[candidate] < pileHeights[landingCol])
+                    landingCol = candidate;
+            }
+        }
+        const stackHeight = pileHeights[landingCol]++;
+        const restingRow = clamp(floor - stackHeight, particle.row + 1, floor);
+        const fallDistance = Math.max(1, restingRow - particle.row);
+        const fallTime = Math.sqrt((2 * fallDistance) / GRAVITY);
+        const velocityCol = (landingCol - particle.col) / fallTime;
+        const steps = Math.max(4, Math.min(14, Math.ceil(fallTime / 0.045)));
+        const interval = fallTime / steps;
+        for (let step = 1; step < steps; step++) {
+            const elapsed = step * interval;
+            const progress = step / steps;
+            const row = particle.row + 0.5 * GRAVITY * elapsed * elapsed;
+            const col = particle.col + velocityCol * elapsed + Math.sin(progress * Math.PI) * 0.3;
+            const start = clamp(particle.release + elapsed, 0, 0.93);
+            const cell = {
+                row: clamp(Math.round(row), 0, floor),
+                col: clamp(Math.round(col), 0, width - 1),
+                start,
+                end: Math.min(0.96, start + Math.max(0.025, interval * 0.72)),
+                glyph: particle.glyph,
+                color: WHITE,
+            };
+            sparkles.push(cell);
+            clears.push(cell);
+        }
+        const settledAt = clamp(particle.release + fallTime, 0, 0.93);
+        const settled = { row: restingRow, col: landingCol, start: settledAt, end: 0.97, glyph: particle.glyph, color: WHITE };
+        sparkles.push(settled);
+        clears.push(settled);
+    }
+    return finish(sparkles, clears);
+}
+/** Soft white dotted radio pulses expanding from a gently moving center. */
+function wavesPlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const baseCenterCol = (width - 1) / 2;
+    const baseCenterRow = (height - 1) / 2;
+    const sparkles = [];
+    const clears = [];
+    const addPulseCell = (row, col, start, lifetime, glyph) => {
+        const safeStart = clamp(start, 0, 0.94);
+        const cell = {
+            row: clamp(Math.round(row), 0, height - 1),
+            col: clamp(Math.round(col), 0, width - 1),
+            start: safeStart,
+            end: clamp(safeStart + lifetime, safeStart + 0.02, 0.98),
+            glyph,
+            color: WHITE,
+        };
+        sparkles.push(cell);
+        clears.push(cell);
+    };
+    // Rationale: clear the frame in the same outward direction as the expanding signal.
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const x = (col - baseCenterCol) / Math.max(1, width * 0.5);
+            const y = (row - baseCenterRow) / Math.max(1, height * 0.5);
+            const distance = Math.min(1.25, Math.sqrt(x * x + y * y));
+            const start = 0.04 + random() * 0.1;
+            const cell = {
+                row, col, start,
+                end: Math.min(0.95, 0.18 + distance * 0.54 + random() * 0.12),
+                glyph: pick(random, DUST_GLYPHS),
+                color: WHITE,
+            };
+            clears.push(cell);
+            if (random() < 0.055)
+                sparkles.push(cell);
+        }
+    }
+    const pulseCount = 4;
+    const expansionSteps = 9;
+    for (let pulse = 0; pulse < pulseCount; pulse++) {
+        const pulseStart = 0.025 + pulse * 0.135;
+        const phase = pulse * 1.47 + random() * 0.45;
+        for (let step = 0; step <= expansionSteps; step++) {
+            const progress = step / expansionSteps;
+            const centerCol = baseCenterCol + Math.sin(phase + progress * Math.PI) * width * 0.035;
+            const centerRow = baseCenterRow + Math.cos(phase + progress * Math.PI * 0.8) * height * 0.065;
+            const radiusCol = progress * width * 0.56;
+            const radiusRow = progress * height * 0.56;
+            const samples = Math.max(10, Math.min(58, Math.round(12 + radiusCol * 0.48)));
+            const time = pulseStart + progress * 0.28;
+            if (step === 0) {
+                addPulseCell(centerRow, centerCol, time, 0.1, pulse % 2 === 0 ? "+" : "°");
+                continue;
+            }
+            for (let sample = 0; sample < samples; sample++) {
+                if (random() < 0.08 + progress * 0.06)
+                    continue;
+                const angle = (sample / samples) * Math.PI * 2 + Math.sin(phase) * 0.035;
+                const shimmer = (random() - 0.5) * (0.25 + progress * 0.55);
+                const row = centerRow + Math.sin(angle) * radiusRow + shimmer * 0.4;
+                const col = centerCol + Math.cos(angle) * radiusCol + shimmer;
+                const glyph = progress < 0.28 ? "°" : progress < 0.62 ? "·" : random() < 0.72 ? "." : "'";
+                addPulseCell(row, col, time + random() * 0.018, 0.065 + (1 - progress) * 0.055, glyph);
+            }
+        }
+    }
+    return finish(sparkles, clears);
+}
+const PLANS = Object.freeze({
+    fall: fallPlan,
+    dissolve: dissolvePlan,
+    starburst: starburstPlan,
+    waves: wavesPlan,
+});
+/** Builds the selected effect's deterministic plan for the captured row widths. */
+export function createQuitOutroPlan(effect, rowWidths, seed) {
+    return PLANS[effect](rowWidths, seed);
+}

package/dist/app/session-shell/quit-outro.d.ts

@@ -0,0 +1,38 @@
+import { type QuitOutroEffect } from "./quit-outro-effects.js";
+export interface QuitOutroFrame {
+    /** Row content as presented, truncated to `columns`; index 0 is the top row. */
+    readonly lines: readonly string[];
+    readonly columns: number;
+    readonly rows: number;
+    /** Visible width of each line, at most `columns`. */
+    readonly rowWidths: readonly number[];
+}
+export interface QuitOutroPlayback {
+    write(data: string): void;
+    /** Monotonic clock seam; defaults to `Date.now`. */
+    now?(): number;
+    /** Delay seam; defaults to a timer. */
+    sleep?(ms: number): Promise<void>;
+    /** Plan seed; defaults to a time- and geometry-derived value. */
+    readonly seed?: number;
+}
+export declare const QUIT_OUTRO_MIN_MS = 300;
+export declare const QUIT_OUTRO_MAX_MS = 2000;
+/** Wall-clock allowance beyond the clamped duration before playback abandons remaining ticks. */
+export declare const QUIT_OUTRO_GUARD_MS = 500;
+/** Tick ceiling for a clock that stops advancing: the longest playback plus its guard at 30 fps. */
+export declare const QUIT_OUTRO_MAX_TICKS: number;
+export declare function clampQuitOutroDuration(durationMs: number): number;
+/**
+ * Captures the presented rows into an outro frame. Returns null when nothing is
+ * visible, so a blank screen never animates.
+ */
+export declare function captureQuitOutroFrame(presented: readonly string[], columns: number, rows: number): QuitOutroFrame | null;
+/** The clear-and-repaint block that seeds the animation surface with the captured frame. */
+export declare function createQuitOutroSurfaceFrame(frame: QuitOutroFrame): string;
+/**
+ * Plays the effect over the frame. Resolves true when the plan was played to
+ * completion or abandoned at its guard, false when there was nothing to play.
+ * Write failures propagate so the caller can decide to continue restoration.
+ */
+export declare function playQuitOutro(frame: QuitOutroFrame, effect: QuitOutroEffect, durationMs: number, playback: QuitOutroPlayback): Promise<boolean>;

package/dist/app/session-shell/quit-outro.js

@@ -0,0 +1,98 @@
+/**
+ * Bare A1's quit outro: the last presented fullscreen frame is captured, the
+ * selected effect animates over it on the alternate screen, and only then does
+ * the shell leave that screen. Every tick is one synchronized-output block so a
+ * terminal never shows a half-painted step, and playback is bounded so a slow
+ * terminal cannot delay restoration past the configured clamp.
+ */
+import { displayWidth, truncateToWidth } from "../../ui/components/index.js";
+import { createQuitOutroPlan } from "./quit-outro-effects.js";
+export const QUIT_OUTRO_MIN_MS = 300;
+export const QUIT_OUTRO_MAX_MS = 2000;
+/** Wall-clock allowance beyond the clamped duration before playback abandons remaining ticks. */
+export const QUIT_OUTRO_GUARD_MS = 500;
+const FRAME_MS = 1000 / 30;
+/** Tick ceiling for a clock that stops advancing: the longest playback plus its guard at 30 fps. */
+export const QUIT_OUTRO_MAX_TICKS = Math.ceil((QUIT_OUTRO_MAX_MS + QUIT_OUTRO_GUARD_MS) / FRAME_MS) + 1;
+const SYNC_BEGIN = "\x1b[?2026h";
+const SYNC_END = "\x1b[?2026l";
+const RESET = "\x1b[0m";
+const CLEAR_SCREEN = "\x1b[2J";
+const HOME = "\x1b[H";
+const HIDE_CURSOR = "\x1b[?25l";
+export function clampQuitOutroDuration(durationMs) {
+    if (!Number.isFinite(durationMs))
+        return QUIT_OUTRO_MIN_MS;
+    return Math.max(QUIT_OUTRO_MIN_MS, Math.min(QUIT_OUTRO_MAX_MS, Math.floor(durationMs)));
+}
+function cursorAt(row, col) {
+    return `\x1b[${row + 1};${col + 1}H`;
+}
+/**
+ * Captures the presented rows into an outro frame. Returns null when nothing is
+ * visible, so a blank screen never animates.
+ */
+export function captureQuitOutroFrame(presented, columns, rows) {
+    const width = Math.max(1, Math.floor(columns));
+    const height = Math.max(1, Math.floor(rows));
+    const lines = presented.slice(0, height).map(line => truncateToWidth(line, width));
+    while (lines.length < height)
+        lines.push("");
+    const rowWidths = lines.map(line => Math.min(width, displayWidth(line)));
+    if (rowWidths.every(w => w === 0))
+        return null;
+    return { lines, columns: width, rows: height, rowWidths };
+}
+/** The clear-and-repaint block that seeds the animation surface with the captured frame. */
+export function createQuitOutroSurfaceFrame(frame) {
+    let output = `${SYNC_BEGIN}${HIDE_CURSOR}${CLEAR_SCREEN}${HOME}${RESET}`;
+    for (let row = 0; row < frame.rows; row++) {
+        const line = frame.lines[row] ?? "";
+        if (frame.rowWidths[row] > 0)
+            output += `${cursorAt(row, 0)}${line}${RESET}`;
+    }
+    return `${output}${SYNC_END}`;
+}
+/**
+ * Plays the effect over the frame. Resolves true when the plan was played to
+ * completion or abandoned at its guard, false when there was nothing to play.
+ * Write failures propagate so the caller can decide to continue restoration.
+ */
+export async function playQuitOutro(frame, effect, durationMs, playback) {
+    const now = playback.now ?? (() => Date.now());
+    const sleep = playback.sleep ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const seed = playback.seed ?? (Date.now() ^ (frame.columns << 16) ^ frame.rows);
+    const plan = createQuitOutroPlan(effect, frame.rowWidths, seed);
+    if (plan.clears.length === 0)
+        return false;
+    const duration = clampQuitOutroDuration(durationMs);
+    let sparkleIndex = 0;
+    let clearIndex = 0;
+    let ticks = 0;
+    playback.write(createQuitOutroSurfaceFrame(frame));
+    const startedAt = now();
+    for (;;) {
+        ticks += 1;
+        const elapsed = now() - startedAt;
+        const progress = Math.min(1, elapsed / duration);
+        let output = `${SYNC_BEGIN}${RESET}`;
+        while (sparkleIndex < plan.sparkles.length && plan.sparkles[sparkleIndex].start <= progress) {
+            const cell = plan.sparkles[sparkleIndex++];
+            output += `${cursorAt(cell.row, cell.col)}${cell.color}${cell.glyph}`;
+        }
+        while (clearIndex < plan.clears.length && plan.clears[clearIndex].end <= progress) {
+            const cell = plan.clears[clearIndex++];
+            output += `${cursorAt(cell.row, cell.col)}${RESET} `;
+        }
+        const finished = clearIndex >= plan.clears.length || progress >= 1
+            || elapsed > duration + QUIT_OUTRO_GUARD_MS || ticks >= QUIT_OUTRO_MAX_TICKS;
+        // Invariant: the last block leaves the alternate screen blank regardless of which
+        // cells the plan reached, so the leave never reveals a half-cleared frame.
+        if (finished)
+            output += `${CLEAR_SCREEN}${HOME}`;
+        playback.write(`${output}${RESET}${SYNC_END}`);
+        if (finished)
+            return true;
+        await sleep(FRAME_MS);
+    }
+}

package/dist/app/session-shell/response-copy-coordinator.d.ts

@@ -0,0 +1,27 @@
+import { type SelectionCopySnapshot } from "../../ui/components/selection-copy.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/app/session-shell/response-copy-coordinator.js

@@ -0,0 +1,187 @@
+import { MAX_COPY_SOURCE_UNITS } from "../../ui/components/selection-copy.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 {
+    #sequence = 0;
+    #epoch = 0;
+    #active;
+    #pending;
+    #latest = Promise.resolve({ outcome: "delivered" });
+    #latestPending = false;
+    #disposed = false;
+    #quarantined = false;
+    options;
+    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. */ }
+    }
+}