@timurproko/a1 0.2.6 → 0.2.7-dev.1221

package/dist/foundation/session-writer-lock/index.d.ts

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+export interface NativeLock {
+    readonly bound: boolean;
+    bindCreated(path: string): void;
+    release(): void;
+}
+export interface LockBackend {
+    acquire(path: string): NativeLock;
+}
+/** Reports that a canonical session identity already has a live writer. */
+export declare class SessionWriterConflict extends Error {
+    readonly path: string;
+    readonly holderKind: string;
+    constructor(path: string, holderKind?: string);
+}
+export interface SessionWriterHandle {
+    readonly path: string;
+    readonly bound: boolean;
+    bind(createdPath?: string): void;
+    release(): void;
+}
+/** Security: a release that carries its own terminal-host addon never loads one chosen by cwd. */
+export declare function nativeCandidates(moduleUrl?: string, env?: NodeJS.ProcessEnv, cwd?: string, exists?: typeof existsSync): string[];
+export declare function acquireExisting(path: string): SessionWriterHandle;
+export declare function reserveNew(parent: string, name: string): SessionWriterHandle;
+export declare function acquireSessionWriter(path: string): SessionWriterHandle;
+export declare function bind(handle: SessionWriterHandle, createdPath?: string): void;
+export declare function release(handle: SessionWriterHandle): void;
+/** Test-only backend seam; passing undefined restores native discovery. */
+export declare function setSessionWriterLockBackendForTest(value: LockBackend | undefined): void;

package/dist/foundation/session-writer-lock/index.js

@@ -0,0 +1,203 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+/** Reports that a canonical session identity already has a live writer. */
+export class SessionWriterConflict extends Error {
+    path;
+    holderKind;
+    constructor(path, holderKind = "another A1 process") {
+        super(`session is open in ${holderKind}`);
+        this.name = "SessionWriterConflict";
+        this.path = path;
+        this.holderKind = holderKind;
+    }
+}
+let backendOverride;
+let cachedBackend;
+/** Security: a release that carries its own terminal-host addon never loads one chosen by cwd. */
+export function nativeCandidates(moduleUrl = import.meta.url, env = process.env, cwd = process.cwd(), exists = existsSync) {
+    const addon = `${PRODUCT_IDENTITY.artifacts.terminalHostAddon}.node`;
+    // Invariant: this module sits at dist/foundation/session-writer-lock/ inside the release root.
+    const own = resolve(fileURLToPath(new URL("../../../", moduleUrl)), "dist", "native", `${process.platform}-${process.arch}`, addon);
+    const override = env[PRODUCT_IDENTITY.environment.developmentInstanceId]
+        ? env[PRODUCT_IDENTITY.environment.terminalHostPath]?.trim() || undefined
+        : undefined;
+    const local = exists(own)
+        ? [own]
+        : [resolve(cwd, "dist", "native", `${process.platform}-${process.arch}`, addon), resolve(cwd, ".artifacts", "terminal-host", addon)];
+    return override ? [override, ...local] : local;
+}
+function loadNativeBackend() {
+    const require = createRequire(import.meta.url);
+    for (const candidate of nativeCandidates()) {
+        if (!existsSync(candidate))
+            continue;
+        try {
+            const loaded = require(candidate);
+            if (loaded.SessionLock?.acquire)
+                return loaded.SessionLock;
+        }
+        catch {
+            // Compatibility: an addon for another Node ABI is unusable; try the next location.
+        }
+    }
+    return undefined;
+}
+function processIsLive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Development fallback. Installed releases carry the verified Node-API lock resolved above. */
+function portableBackend() {
+    const root = join(tmpdir(), "a1-session-writer-locks");
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const authorityPath = (kind, key) => join(root, `${createHash("sha256").update(`${kind}\0${key}`).digest("hex")}.lock`);
+    const locationKey = (path) => `${realpathSync.native(dirname(path))}\0${process.platform === "win32" ? basename(path).toLowerCase() : basename(path)}`;
+    const identityKey = (path) => {
+        const physical = realpathSync.native(path);
+        const metadata = statSync(physical, { bigint: true });
+        return `${metadata.dev}:${metadata.ino}`;
+    };
+    const acquireAuthority = (path) => {
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            try {
+                const descriptor = openSync(path, "wx", 0o600);
+                writeFileSync(descriptor, JSON.stringify({ pid: process.pid, kind: process.env.A1_TAB_ID ? "resident tab" : "another A1 process" }));
+                closeSync(descriptor);
+                return;
+            }
+            catch (error) {
+                if (attempt === 0) {
+                    try {
+                        const record = JSON.parse(readFileSync(path, "utf8"));
+                        if (typeof record.pid === "number" && !processIsLive(record.pid)) {
+                            rmSync(path, { force: true });
+                            continue;
+                        }
+                    }
+                    catch {
+                        // Security: malformed or racing lock evidence remains authoritative and fails closed.
+                    }
+                }
+                throw error;
+            }
+        }
+    };
+    return {
+        acquire(requested) {
+            const absolute = resolve(requested);
+            const location = authorityPath("location", locationKey(absolute));
+            acquireAuthority(location);
+            let identity;
+            let identityAcquired = false;
+            let bound = false;
+            try {
+                if (existsSync(absolute)) {
+                    const key = identityKey(absolute);
+                    identity = authorityPath("identity", key);
+                    acquireAuthority(identity);
+                    identityAcquired = true;
+                    if (identityKey(absolute) !== key) {
+                        throw new Error("session identity changed while its writer lock was acquired");
+                    }
+                    rmSync(location, { force: true });
+                    bound = true;
+                }
+            }
+            catch (error) {
+                rmSync(location, { force: true });
+                if (identityAcquired && identity !== undefined)
+                    rmSync(identity, { force: true });
+                throw error;
+            }
+            let released = false;
+            return {
+                get bound() { return bound; },
+                bindCreated(created) {
+                    if (bound || resolve(created) !== absolute || !existsSync(absolute)) {
+                        throw new Error("created session does not match its reservation");
+                    }
+                    const key = identityKey(absolute);
+                    identity = authorityPath("identity", key);
+                    acquireAuthority(identity);
+                    if (identityKey(absolute) !== key) {
+                        rmSync(identity, { force: true });
+                        identity = undefined;
+                        throw new Error("created session identity changed during bind");
+                    }
+                    rmSync(location, { force: true });
+                    bound = true;
+                },
+                release() {
+                    if (released)
+                        throw new Error("session lock was already released");
+                    released = true;
+                    rmSync(bound ? identity : location, { force: true });
+                },
+            };
+        },
+    };
+}
+function backend() {
+    return backendOverride ?? (cachedBackend ??= loadNativeBackend() ?? portableBackend());
+}
+function acquire(path) {
+    const absolute = resolve(path);
+    let lock;
+    try {
+        lock = backend().acquire(absolute);
+    }
+    catch {
+        throw new SessionWriterConflict(absolute, process.env.A1_TAB_ID ? "a resident tab" : "another A1 process");
+    }
+    let released = false;
+    return {
+        path: absolute,
+        get bound() { return lock.bound; },
+        bind(createdPath = absolute) {
+            if (released)
+                throw new Error("session writer lock was released");
+            if (!lock.bound)
+                lock.bindCreated(resolve(createdPath));
+        },
+        release() {
+            if (released)
+                return;
+            released = true;
+            lock.release();
+        },
+    };
+}
+export function acquireExisting(path) {
+    if (!existsSync(path))
+        throw new Error(`session file does not exist: ${path}`);
+    return acquire(path);
+}
+export function reserveNew(parent, name) {
+    if (!name || basename(name) !== name)
+        throw new Error("session reservation requires one file name");
+    return acquire(join(parent, name));
+}
+export function acquireSessionWriter(path) {
+    return acquire(path);
+}
+export function bind(handle, createdPath) {
+    handle.bind(createdPath);
+}
+export function release(handle) {
+    handle.release();
+}
+/** Test-only backend seam; passing undefined restores native discovery. */
+export function setSessionWriterLockBackendForTest(value) {
+    backendOverride = value;
+    cachedBackend = undefined;
+}

package/dist/foundation/startup/startup-descriptor.js

@@ -10,7 +10,7 @@ export const STARTUP_DESCRIPTOR = Object.freeze({
   ],
   "generatedArtifact": {
     "path": "dist/integrations/pi/startup-public.js",
-    "sha256": "62906f5056fabed7a83b97843e3a407c955103ab2bb7849e6713026fe7c760a9"
+    "sha256": "e065933fe374d7953c5aac0ff1735fa47d119ab97551e955c2a65e8c2df667eb"
   },
   "dependencyLayerIdentity": {
     "source": "A1_RELEASE_LAYERS",
@@ -19,7 +19,7 @@ export const STARTUP_DESCRIPTOR = Object.freeze({
   "compileCacheNamespace": {
     "strategy": "node-abi-version-and-ordered-layer-sha256-v1"
   },
-  "identity": "089bcfdc784e7d61cd028ede3b5546864ab49e6329e1296ed55afacb16bcb077"
+  "identity": "5c1afab4657c251b840e042279290bd1fa03ce608bc81bc6e7eaf8d332486eef"
 });
 
 export function loadDeclaredStartupGraph() {

package/dist/foundation/terminal-cleanup/index.d.ts

@@ -1,3 +1,3 @@
-export { EMERGENCY_TERMINAL_RESET, boundedCleanup, restoreAfterOwnedExit, restoreProcessTerminal } from "./terminal-reset.js";
+export { CLEAR_EXIT_INTERVAL_MS, EMERGENCY_TERMINAL_RESET, RESIDENT_DETACH_INTERVAL_MS, boundedCleanup, restoreAfterOwnedExit, restoreProcessTerminal } from "./terminal-reset.js";
 export { installFatalExit, writeFatalDiagnostic } from "./fatal-exit.js";
 export type { FatalExitOptions } from "./fatal-exit.js";

package/dist/foundation/terminal-cleanup/index.js

@@ -1,2 +1,2 @@
-export { EMERGENCY_TERMINAL_RESET, boundedCleanup, restoreAfterOwnedExit, restoreProcessTerminal } from "./terminal-reset.js";
+export { CLEAR_EXIT_INTERVAL_MS, EMERGENCY_TERMINAL_RESET, RESIDENT_DETACH_INTERVAL_MS, boundedCleanup, restoreAfterOwnedExit, restoreProcessTerminal } from "./terminal-reset.js";
 export { installFatalExit, writeFatalDiagnostic } from "./fatal-exit.js";

package/dist/foundation/terminal-cleanup/terminal-reset.d.ts

@@ -1,3 +1,9 @@
+export declare const CLEAR_EXIT_INTERVAL_MS = 500;
+/**
+ * How long a first `Ctrl+C` keeps the resident attach client's detach chord armed. It matches the
+ * owned dialogs' interrupt chord so an unhurried double press leaves resident tabs from any tab.
+ */
+export declare const RESIDENT_DETACH_INTERVAL_MS = 1500;
 export declare const EMERGENCY_TERMINAL_RESET: string;
 export declare function restoreProcessTerminal(): void;
 export declare function restoreAfterOwnedExit(ownsTerminal: boolean, code: number | null, signal: string | null, restore?: () => void): number;

package/dist/foundation/terminal-cleanup/terminal-reset.js

@@ -1,4 +1,10 @@
 import { writeSync } from "node:fs";
+export const CLEAR_EXIT_INTERVAL_MS = 500;
+/**
+ * How long a first `Ctrl+C` keeps the resident attach client's detach chord armed. It matches the
+ * owned dialogs' interrupt chord so an unhurried double press leaves resident tabs from any tab.
+ */
+export const RESIDENT_DETACH_INTERVAL_MS = 1_500;
 // Protocol: reset modes on both screens; setting keyboard flags to zero is idempotent,
 // unlike repeatedly popping a keyboard-protocol stack owned by a parent application.
 // Resetting parent-screen margins homes the cursor, so preserve its restored position.

package/dist/integrations/pi/components/editor-interaction.d.ts

@@ -25,6 +25,8 @@ export interface EditorRecallPort {
     };
     observe(listener: () => void): () => void;
     reset(): void;
+    /** Exit a recall browse cycle by restoring the unsent draft rather than keeping the recalled entry. */
+    restoreDraft?(): void;
 }
 export interface EditorSurface extends Pick<Editor, Exclude<keyof Editor, "setText" | "render" | "handleInput">> {
     setText(text: string): void;

package/dist/integrations/pi/components/modal-frame.d.ts

@@ -1,5 +1,21 @@
-import { Container, type Component, type TUI } from "@earendil-works/pi-tui";
+import { Container, Input, type Component, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
 export declare const PI_MODAL_CONTENT_PADDING_X = 1;
+/** Paints the standard Pi Input prompt as a live-themed dialog-search marker. */
+export declare function renderPiModalSearchInput(input: Input, width: number): string[];
+/** Keeps Pi Input behavior and geometry while owning only its standard dialog-search presentation. */
+export declare class PiModalSearchInput implements Component, Focusable {
+    #private;
+    constructor(input: Input);
+    get focused(): boolean;
+    set focused(value: boolean);
+    invalidate(): void;
+    render(width: number): string[];
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+}
+/** Replaces one explicitly identified direct Input child with the standard search presentation. */
+export declare function adoptPiModalSearchInput(container: Container, input: Component): PiModalSearchInput;
+/** Adds one standard dialog-search presentation while callers retain the Input controller. */
+export declare function addPiModalSearchInput(container: Container, input: Input): PiModalSearchInput;
 /** Adds the standard navigation/select/close footer before a dependency component's bottom rule. */
 export declare function addPiModalSelectFooter(container: Container): void;
 /** Owned cancellable operation frame with the canonical dialog close guidance. */

package/dist/integrations/pi/components/modal-frame.js

@@ -1,7 +1,47 @@
-import { CancellableLoader, Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { CancellableLoader, Container, Input, Spacer, Text, } from "@earendil-works/pi-tui";
+import { DIALOG_CONTENT_PADDING_X, dialogFrameGeometry, insetDialogContent } from "../../../contracts/presentation/index.js";
 import { DynamicBorder } from "../startup-public.js";
 import { DIALOG_CLOSE_SHORTCUT_HINT, paintPiBorder, piTheme, renderPiModalShortcutHints } from "./theme.js";
-export const PI_MODAL_CONTENT_PADDING_X = 1;
+export const PI_MODAL_CONTENT_PADDING_X = DIALOG_CONTENT_PADDING_X;
+/** Paints the standard Pi Input prompt as a live-themed dialog-search marker. */
+export function renderPiModalSearchInput(input, width) {
+    return input.render(width).map(row => {
+        if (row.length === 0)
+            return row;
+        if (!row.startsWith(">"))
+            throw new TypeError("modal search input does not use the standard prompt");
+        return `${piTheme().fg("accent", ">")}${row.slice(1)}`;
+    });
+}
+/** Keeps Pi Input behavior and geometry while owning only its standard dialog-search presentation. */
+export class PiModalSearchInput {
+    #input;
+    constructor(input) {
+        this.#input = input;
+    }
+    get focused() { return this.#input.focused; }
+    set focused(value) { this.#input.focused = value; }
+    invalidate() { this.#input.invalidate(); }
+    render(width) { return renderPiModalSearchInput(this.#input, width); }
+    handleMouse(event) { return this.#input.handleMouse(event); }
+}
+/** Replaces one explicitly identified direct Input child with the standard search presentation. */
+export function adoptPiModalSearchInput(container, input) {
+    if (!(input instanceof Input))
+        throw new TypeError("modal search component is not an Input");
+    const index = container.children.indexOf(input);
+    if (index === -1)
+        throw new TypeError("modal search Input is not a direct child");
+    const presentation = new PiModalSearchInput(input);
+    container.children.splice(index, 1, presentation);
+    return presentation;
+}
+/** Adds one standard dialog-search presentation while callers retain the Input controller. */
+export function addPiModalSearchInput(container, input) {
+    const presentation = new PiModalSearchInput(input);
+    container.addChild(presentation);
+    return presentation;
+}
 /** Adds the standard navigation/select/close footer before a dependency component's bottom rule. */
 export function addPiModalSelectFooter(container) {
     container.children.splice(container.children.length - 1, 0, new Text(renderPiModalShortcutHints([
@@ -67,21 +107,20 @@ export class PiModalFrame {
         this.#bottomRule.invalidate();
     }
     render(width) {
-        const padding = Math.min(PI_MODAL_CONTENT_PADDING_X, Math.max(0, width));
-        const contentWidth = Math.max(0, width - padding);
-        const rows = [...this.#topRule.render(width)];
+        const geometry = dialogFrameGeometry(width);
+        const rows = [...this.#topRule.render(geometry.frameWidth)];
         for (const component of this.#content) {
             if (this.#fullWidthContent.has(component) || this.#preInsetContent.has(component)) {
-                rows.push(...component.render(width));
+                rows.push(...component.render(geometry.frameWidth));
             }
             else if (component instanceof Spacer) {
-                rows.push(...component.render(contentWidth));
+                rows.push(...component.render(geometry.contentWidth));
             }
             else {
-                rows.push(...component.render(contentWidth).map(row => `${" ".repeat(padding)}${row}`));
+                rows.push(...component.render(geometry.contentWidth).map(row => insetDialogContent(row, geometry)));
             }
         }
-        rows.push(...this.#bottomRule.render(width));
+        rows.push(...this.#bottomRule.render(geometry.frameWidth));
         return rows;
     }
 }

package/dist/integrations/pi/components/models-dialog.js

@@ -1,6 +1,6 @@
 import { Input, getKeybindings, matchesKey, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
 import { DynamicBorder } from "../startup-public.js";
-import { PiModalFrame } from "./modal-frame.js";
+import { PiModalFrame, renderPiModalSearchInput } from "./modal-frame.js";
 import { DIALOG_CLOSE_SHORTCUT_HINT, paintPiBorder, piTheme, renderPiModalListRow, renderPiModalShortcutHints, } from "./theme.js";
 function renderHintsWithClose(entries, width) {
     const body = renderPiModalShortcutHints(entries.slice(0, -1));
@@ -13,7 +13,6 @@ function renderHintsWithClose(entries, width) {
 }
 const MAX_VISIBLE_ROWS = 10;
 const MODELS_TITLE = "Models";
-const REFRESHING_TITLE_MIN_DURATION_MS = 1_000;
 class ModalTitleLine {
     #text = "";
     setText(text) { this.#text = text; }
@@ -60,9 +59,6 @@ export class ModelsDialogComponent {
     #selectedIndex = 0;
     #preferredId;
     #refreshStatus;
-    #refreshing = false;
-    #refreshStartedAt;
-    #refreshOutcomeTimer;
     #disposed = false;
     #focused = false;
     constructor(config, callbacks) {
@@ -71,10 +67,6 @@ export class ModelsDialogComponent {
         this.#scopeIds = [...config.scopeIds];
         this.#savedScopeIds = [...config.savedScopeIds];
         this.#filter = config.initialFilter ?? "all";
-        if (config.refreshStatus !== undefined) {
-            this.#refreshing = true;
-            this.#refreshStartedAt = Date.now();
-        }
         if (config.initialQuery)
             this.#input.setValue(config.initialQuery);
         this.#replaceModels(config.models);
@@ -114,38 +106,10 @@ export class ModelsDialogComponent {
     setRefreshStatus(message, kind) {
         if (this.#disposed)
             return;
-        if (kind === "muted") {
-            this.#clearRefreshOutcome();
-            this.#refreshStatus = undefined;
-            this.#refreshing = true;
-            this.#refreshStartedAt = Date.now();
-            return;
-        }
-        const visibleMs = this.#refreshStartedAt === undefined ? REFRESHING_TITLE_MIN_DURATION_MS : Date.now() - this.#refreshStartedAt;
-        const remainingMs = Math.max(0, REFRESHING_TITLE_MIN_DURATION_MS - visibleMs);
-        if (this.#refreshing && remainingMs > 0) {
-            this.#clearRefreshOutcome();
-            const timer = setTimeout(() => {
-                if (this.#refreshOutcomeTimer !== timer)
-                    return;
-                this.#refreshOutcomeTimer = undefined;
-                if (this.#disposed)
-                    return;
-                this.#applyRefreshOutcome(message, kind);
-                this.#callbacks.requestRender();
-            }, remainingMs);
-            timer.unref?.();
-            this.#refreshOutcomeTimer = timer;
-            return;
-        }
-        this.#clearRefreshOutcome();
-        this.#applyRefreshOutcome(message, kind);
+        this.#refreshStatus = kind === "warning" ? { message, kind } : undefined;
     }
     dispose() {
         this.#disposed = true;
-        this.#clearRefreshOutcome();
-        this.#refreshing = false;
-        this.#refreshStartedAt = undefined;
     }
     invalidate() {
         this.#input.invalidate();
@@ -235,21 +199,9 @@ export class ModelsDialogComponent {
     render(width) {
         const theme = piTheme();
         this.#title.setText(theme.fg("accent", theme.bold(MODELS_TITLE))
-            + (this.dirty ? theme.fg("warning", " (unsaved)") : "")
-            + (this.#refreshing ? theme.fg("muted", " (refreshing)") : ""));
+            + (this.dirty ? theme.fg("warning", " (unsaved)") : ""));
         return this.#frame.render(width);
     }
-    #applyRefreshOutcome(message, kind) {
-        this.#refreshing = false;
-        this.#refreshStartedAt = undefined;
-        this.#refreshStatus = kind === "warning" ? { message, kind } : undefined;
-    }
-    #clearRefreshOutcome() {
-        if (this.#refreshOutcomeTimer === undefined)
-            return;
-        clearTimeout(this.#refreshOutcomeTimer);
-        this.#refreshOutcomeTimer = undefined;
-    }
     #renderBody(width) {
         const theme = piTheme();
         const lines = [];
@@ -261,7 +213,7 @@ export class ModelsDialogComponent {
             + theme.fg("dim", " | ")
             + theme.fg(this.#filter === "scoped" ? "mdHeading" : "dim", "scoped"));
         push();
-        for (const line of this.#input.render(width))
+        for (const line of renderPiModalSearchInput(this.#input, width))
             push(line);
         push();
         if (rows.length === 0) {

package/dist/integrations/pi/components/owned-editor-ux.d.ts

@@ -13,6 +13,7 @@ export interface OwnedEditorUxInterceptor {
     reset(): void;
     handlePointer?(event: OwnedEditorPointerEvent): boolean;
     hasSelection?(): boolean;
+    selectedText?(): string | undefined;
     ownsPointer?(): boolean;
     pasteClipboard?(): boolean;
     cancelPendingPastes?(): void;
@@ -40,15 +41,18 @@ export declare class OwnedEditorUxInterception {
     cancelPendingPastes(): void;
     handlePointer(event: OwnedEditorPointerEvent): boolean;
     hasSelection(): boolean;
+    selectedText(): string | undefined;
     ownsPointer(): boolean;
     pasteClipboard(): boolean;
 }
 export interface PromptSelectionUxOptions {
-    readonly copyText: (text: string) => void;
+    readonly copyText: (text: string, cut: boolean) => void;
     readonly readClipboardContent: () => Promise<PiShellClipboardContent | null>;
     readonly beginClipboardPaste?: () => PiShellPasteReservation;
     readonly beginTextPaste?: (text: string) => PiShellPasteReservation;
     readonly deferTextPaste?: (text: string) => boolean;
+    /** False consumes every paste transport without changing editor text. */
+    readonly pasteEnabled?: boolean;
     readonly onPasteRejected?: (error: unknown) => void;
     readonly onPasteInput?: (bytes: number, phase: "framing" | "inserting" | "settled") => void;
     readonly transformPastedContent: (content: PiShellClipboardContent) => string;
@@ -70,5 +74,6 @@ export interface PromptSelectionUxOptions {
     };
 }
 export declare function createPromptSelectionInterceptor(editor: Editor, keybindings: KeybindingsManager, options: PromptSelectionUxOptions): OwnedEditorUxInterceptor;
+export declare function editorInsertedText(data: string): string | undefined;
 /** Shares the existing atomic-aware body layout with prompt/menu composition. */
 export declare function editorVisualLineCount(editor: Editor, width: number): number | undefined;