@celljs/ta-web 0.0.0-stage → 4.6.0

package/esm/browser/extension/web-extension-api.d.ts

@@ -0,0 +1,362 @@
+import type { TaEvent, TaPackageServer, TaServer, TaSessionInfo, TaTerminalServer, TaWorkspaceServer } from '@celljs/ta-protocol';
+import type * as React from 'react';
+import type { Mood } from '../avatar/dino-avatar.js';
+import type { Language, Theme } from '../settings/settings-protocol.js';
+/**
+ * What a web extension gets: the web client's side of pi's extension API, with the same names where
+ * the two mean the same. A web extension is one ES module without imports, the `web` part of a pi
+ * package (see TaWebExtensionInfo); it exports a {@link WebExtensionFactory}.
+ */
+export interface WebExtensionAPI {
+    /** The React of the page: an extension brings no React of its own. */
+    readonly React: typeof React;
+    /** The sessions of ta serve, for what the rest of the API does not do: the commands of pi's RPC mode. */
+    readonly server: TaServer;
+    /** The files and programs of a directory on the machine of ta serve. */
+    readonly workspace: TaWorkspaceServer;
+    /** Shells; their output comes by {@link onTerminalData}. */
+    readonly terminals: TaTerminalServer;
+    /** The packages pi loads; for the data of the extension's own package, {@link storage}. */
+    readonly packages: TaPackageServer;
+    readonly ui: WebExtensionUI;
+    /** A view of its own: a page or a sidebar view, in the navigation on the left, or a tool of the workbench on the right. */
+    registerView(name: string, view: WebView): void;
+    /** Shows the custom messages of this type, which a pi extension sends with `pi.sendMessage`. */
+    registerMessageRenderer(customType: string, renderer: React.ComponentType<{
+        message: WebCustomMessage;
+    }>): void;
+    /**
+     * Who answers in the sessions of its group (TaOpenSessionOptions.group, the name of the extension's
+     * package), drawn at the head of each turn in place of ta.
+     */
+    registerAvatar(avatar: React.ComponentType<WebAvatarProps>): void;
+    /** A tool of the conversations the page opens, run in the browser. */
+    registerTool(tool: WebTool): void;
+    /**
+     * Opens what links of replies point to: files (at the lines they name), directories, pages of the web.
+     * Openers are asked in the order they were registered; the first that returns true has opened it.
+     * Without one, a page opens in the browser of the system after the user said so.
+     */
+    registerOpener(opener: WebOpener): void;
+    /** The events of the conversation shown. */
+    on<T extends TaEvent['type']>(type: T, handler: (event: Extract<TaEvent, {
+        type: T;
+    }>) => void): void;
+    /** A message to the conversation shown, as if the user typed it; `/name args` runs a command. */
+    sendUserMessage(text: string): Promise<void>;
+    /** Shows another open session of ta serve (TaSessionInfo.sessionId) as the conversation, as pi's `switchSession` does in its terminal. */
+    switchSession(sessionId: string): Promise<void>;
+    /**
+     * Calls a method of the server side of the extension's package (`pi.host` of its package.json, which
+     * ta serve runs for the packages that come with Ta), with JSON values: what the page cannot do itself.
+     */
+    callHost<T = unknown>(method: string, ...params: unknown[]): Promise<T>;
+    /**
+     * Loads the web extensions again, and the pi extensions of the conversation shown, as when a reply that
+     * changed a package ends: after the extension installed, imported or removed a package itself.
+     */
+    reloadExtensions(): Promise<void>;
+    /** Small JSON values the package keeps on the server, so they stay across browsers. */
+    readonly storage: WebPackageStorage;
+    /** Output of the terminals this page opened (terminals.openTerminal); with `exitCode`, the terminal ended. Stops when the extension unloads. */
+    onTerminalData(listener: (terminalId: string, data: string, exitCode?: number) => void): () => void;
+}
+/** Lines and columns of a file, from 1: a line, a place in it, or a range. */
+export interface TextSelection {
+    startLine: number;
+    startColumn?: number;
+    endLine?: number;
+    endColumn?: number;
+}
+/**
+ * What a link of a reply points to, once the page knows it is there: a file or a directory of `cwd`
+ * (`path` relative to it, `''` for `cwd` itself), or a page of the web, opened inside Ta.
+ */
+export type WebLink = {
+    type: 'file';
+    cwd: string;
+    path: string;
+    selection?: TextSelection;
+} | {
+    type: 'directory';
+    cwd: string;
+    path: string;
+} | {
+    type: 'url';
+    url: string;
+};
+/** True when it opened the link; false leaves it to the next opener. */
+export type WebOpener = (link: WebLink) => boolean | Promise<boolean>;
+export interface WebStorage {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    /** `null` removes the key. */
+    set(key: string, value: unknown): Promise<void>;
+    /**
+     * Keys that changed, by this page, another page, or the package on the server; a few times a second
+     * at most, with the keys of that time together. It hears them once the page read one of its keys.
+     * Stops when the extension unloads.
+     */
+    onChange(listener: (keys: string[]) => void): () => void;
+}
+export interface WebPackageStorage extends WebStorage {
+    /**
+     * The values of the package for one directory (`ui.useCwd()`), with keys of their own: what belongs
+     * to it, as the folders open in an explorer, found again in any browser that shows that directory.
+     * The same directory on another execution environment is another one.
+     */
+    directory(cwd: string): WebStorage;
+}
+export interface WebAvatarProps {
+    session: TaSessionInfo;
+    /** What the agent does at the time, as ta's avatar shows it. */
+    mood: Mood;
+    /** In pixels. */
+    size: number;
+}
+/** An icon, drawn at `size` pixels in `currentColor`. */
+export type WebIcon = React.ComponentType<{
+    size?: number | string;
+    strokeWidth?: number | string;
+}>;
+export interface WebExtensionUI {
+    /** A widget around the message box, as pi's, or a card in the workbench on the right; `undefined` removes it. */
+    setWidget(key: string, widget: React.ComponentType | undefined, options?: WidgetOptions): void;
+    /** A notice in the corner of the page, as pi's: it goes by itself, an error later than the rest. */
+    notify(message: string, type?: 'info' | 'warning' | 'error'): void;
+    /**
+     * Asks before going ahead, as pi's `confirm`: resolves with whether the user did. `confirmLabel` names
+     * the button that goes ahead; `danger` makes it red, for what cannot be undone.
+     */
+    confirm(title: string, message?: string, options?: {
+        confirmLabel?: string;
+        danger?: boolean;
+    }): Promise<boolean>;
+    /** Asks for a line of text, as pi's `input`: resolves with it, or `undefined` when the user cancelled. */
+    input(title: string, placeholder?: string, options?: {
+        value?: string;
+    }): Promise<string | undefined>;
+    /** Asks for text of several lines, as pi's `editor`, the box holding `prefill` at first. */
+    editor(title: string, prefill?: string): Promise<string | undefined>;
+    readonly theme: Theme;
+    readonly language: Language;
+    /**
+     * A tab in the editor area beside the conversation (a file, a diff, a browser); an open id is shown
+     * again. With `preserveFocus`, it opens behind the tab shown, and the workbench is not revealed: for
+     * tabs opened again when the page loads. With `preview`, as a single click in an IDE: its title is in
+     * italics, and the next tab opened as a preview takes its place, until it is pinned (`pinEditor`, or a
+     * double click on it); opening it again without `preview` pins it too.
+     */
+    openEditor(editor: WebEditor, options?: {
+        preserveFocus?: boolean;
+        preview?: boolean;
+    }): void;
+    closeEditor(id: string): void;
+    /** Keeps a tab opened as a preview: the next preview opens beside it. */
+    pinEditor(id: string): void;
+    /**
+     * Marks a tab as changed and not saved: a dot in place of its close button, and the user is asked
+     * before closing it. Dirty tabs are pinned.
+     */
+    setEditorDirty(id: string, dirty: boolean): void;
+    /** A React hook: the id of the tab shown in the workbench, whoever opened it. */
+    useActiveEditor(): string | undefined;
+    /** A React hook: the directory of the conversation shown, or the server's when none is. */
+    useCwd(): string;
+    /** A React hook: the session of the conversation shown (TaSessionInfo.sessionId). */
+    useSessionId(): string | undefined;
+    /**
+     * Shows a view of any web extension by its id, `<extension name>/<view name>` (`assistant/assistant`
+     * for the double): a page in the main area, a tool of the workbench as its tab; `''` the conversation again.
+     */
+    showView(id: string): void;
+    /** A React hook: the view of that id while one is loaded, and whether it is shown. */
+    useView(id: string): WebViewInfo | undefined;
+    /** ta: the dinosaur of the Cell logo; `mark`, one or two characters, tells agents apart. */
+    readonly Avatar: React.ComponentType<{
+        mood?: Mood;
+        size?: number;
+        mark?: string;
+    }>;
+    /** The lucide icons of the page, by name (extension/icons.ts): a web extension cannot import them. */
+    readonly icons: Readonly<Record<string, WebIcon>>;
+    /** Monaco, the editor of VS Code, on the text of a file; it loads the first time one is shown. */
+    readonly CodeEditor: React.ComponentType<CodeEditorProps>;
+    /** Monaco's diff editor on two texts of a file, side by side or inline; the right side can be edited. */
+    readonly DiffEditor: React.ComponentType<DiffEditorProps>;
+    /** The message box of the conversations of the page, with its + menu: one look for every conversation. */
+    readonly Composer: React.ComponentType<WebComposerProps>;
+    /** Markdown as the conversations show it. */
+    readonly Markdown: React.ComponentType<{
+        text: string;
+    }>;
+    /** A dialog over the page, as the dialogs of ta: a title, a button to close it, what it holds; Escape and a click outside close it too. */
+    readonly Dialog: React.ComponentType<WebDialogProps>;
+    /** The dialog in which ta picks a directory of the server, folder by folder or by a path typed in. */
+    readonly FolderPicker: React.ComponentType<WebFolderPickerProps>;
+}
+export interface WebFolderPickerProps {
+    /** Where it opens; default: the directory of ta serve. */
+    initial?: string;
+    /** The directory picked; the dialog stays open until it returns, and closes with `onClose`. */
+    onPick(path: string): void | Promise<void>;
+    onClose(): void;
+}
+export interface CodeEditorProps {
+    /** The path of the file: its name tells the language (`.ts`, `Dockerfile`); another path is another editor. */
+    path: string;
+    /** The text shown; a different one replaces it, as an edit the user can undo. */
+    value: string;
+    readOnly?: boolean;
+    /** A line, 1 for the first, shown in the middle with the cursor at its start (at `column`, 1 for the first, when given). */
+    line?: number;
+    column?: number;
+    /** With `line` and `column`: the text up to this column of that line is selected, as a match of a search. */
+    endColumn?: number;
+    /** Lines or a place to select, shown in the middle; over `line`. */
+    selection?: TextSelection;
+    /** The user changed the text. */
+    onChange?(value: string): void;
+    /** Ctrl+S or Cmd+S. */
+    onSave?(value: string): void;
+}
+export interface DiffEditorProps {
+    /** The path of the file: its name tells the language. */
+    path: string;
+    /** The text before (left), as HEAD or the index has it. */
+    original: string;
+    /** The text after (right). */
+    modified: string;
+    /** Default: side by side, inline when it is narrow. */
+    inline?: boolean;
+    /** Default true; false lets the user change the right side, `onChange` and `onSave` hear it. */
+    readOnly?: boolean;
+    onChange?(value: string): void;
+    onSave?(value: string): void;
+    /** How many changes it found once it compared the texts, and how to go to the next or the one before. */
+    onDiff?(diff: {
+        changes: number;
+        next(): void;
+        previous(): void;
+    }): void;
+}
+export interface WebDialogProps {
+    title: string;
+    onClose(): void;
+    children?: React.ReactNode;
+}
+export interface WebComposerProps {
+    placeholder?: string;
+    /** Sends what was typed; when it fails, the text comes back into the box and the reason is a notice of the page. */
+    onSend(text: string): Promise<void> | void;
+    /** What `@` lists, by name; and the + menu entry that starts an `@`. */
+    mentions?: {
+        name: string;
+        detail?: string;
+    }[];
+    mentionLabel?: string;
+    /** More sections of the + menu, each set apart by a line. */
+    actions?: WebComposerAction[][];
+    /** The directory the conversation will work in, empty for that of ta serve: a button beside the + shows it. */
+    cwd?: string;
+    /** With it, the button beside the + picks another directory, as that of a new conversation does. */
+    onPickCwd?(cwd: string): void | Promise<void>;
+}
+/** An entry of the + menu of the message box. */
+export interface WebComposerAction {
+    key: string;
+    label: string;
+    /** On the left: an icon of 16 pixels, or an avatar. */
+    icon?: React.ReactNode;
+    detail?: string;
+    disabled?: boolean;
+    /** Text the entry puts where the caret is, as `@name `; else `run` runs. */
+    insert?: string;
+    run?(): void;
+}
+export interface WebEditor {
+    id: string;
+    title: WebLabel;
+    icon?: WebIcon;
+    render: React.ComponentType;
+    /** The user closed the tab. */
+    onClose?(): void;
+}
+/** Words on the page; a function is read again when the language changes. */
+export type WebLabel = string | (() => string);
+export interface WidgetOptions {
+    /** Default: `aboveEditor`, as in pi. `panel`: a card in the cards tab of the workbench on the right, which opens when the first card comes. */
+    placement?: 'aboveEditor' | 'belowEditor' | 'panel';
+    /** The title of a card in the workbench. */
+    title?: WebLabel;
+}
+export interface WebView {
+    title: WebLabel;
+    render: React.ComponentType;
+    /** Its icon in the navigation or the workbench, drawn at `size` pixels in `currentColor`. */
+    icon?: WebIcon;
+    /**
+     * `page` (default): the main area. `sidebar`: the column beside the navigation, as the list of
+     * chats. `panel`: a tool of the workbench beside the conversation, as the explorer or the terminal
+     * of an IDE: its `+` and its empty state list it, and it opens as one of its tabs.
+     */
+    location?: 'page' | 'sidebar' | 'panel';
+    /** Smaller first among those of its location; default 100. */
+    order?: number;
+    /**
+     * A page: its … where a list shows it (the sidebar view that leads to it), in sections set apart by
+     * a line; read each time the menu opens, so it can say what holds now.
+     */
+    menu?(): WebMenuItem[][];
+    /**
+     * Its top bar, in place of the title: for a sidebar view, the row above it (a search, a button
+     * to add); for a page, the middle of the bar that has the menu and the button of the workbench.
+     */
+    head?: React.ComponentType;
+    /**
+     * A sidebar view: the pages it leads to (`<extension name>/<view name>`, as `ui.showView` takes),
+     * which the navigation then leaves out, since the view lists them.
+     */
+    pages?: string[];
+}
+/** An entry of the … of a page (WebView.menu). */
+export interface WebMenuItem {
+    key: string;
+    label: string;
+    icon?: WebIcon;
+    disabled?: boolean;
+    /** Cannot be undone, as delete: drawn in red. */
+    danger?: boolean;
+    run(): void;
+}
+/** A view of any web extension, as `ui.useView` sees it. */
+export interface WebViewInfo {
+    title: string;
+    location: 'page' | 'sidebar' | 'panel';
+    /** The page is in the main area, or the tool is the tab shown in the workbench. */
+    shown: boolean;
+    /** WebView.menu: the list that shows the page draws a … with it. */
+    menu?(): WebMenuItem[][];
+}
+export interface WebTool {
+    /** Letters, digits, `_` and `-`, starting with a letter. */
+    name: string;
+    description: string;
+    /** JSON schema of an object. */
+    parameters: Record<string, unknown>;
+    /** What the model reads; throwing fails the call with the message. */
+    execute(toolCallId: string, params: Record<string, unknown>): string | Promise<string>;
+}
+/** pi's custom message, as the conversation holds it. */
+export interface WebCustomMessage {
+    role: 'custom';
+    customType: string;
+    content: string | {
+        type: string;
+        text?: string;
+    }[];
+    display: boolean;
+    details?: unknown;
+    timestamp: number;
+}
+/** The default export of a web extension. The function it returns, if any, runs when it unloads. */
+export type WebExtensionFactory = (pi: WebExtensionAPI) => (() => void) | undefined;

package/esm/browser/extension/web-extension-api.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=web-extension-api.js.map

package/esm/browser/extension/web-extension-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-extension-api.js","sourceRoot":"","sources":["../../../src/browser/extension/web-extension-api.ts"],"names":[],"mappings":""}

package/esm/browser/extension/web-extension-protocol.d.ts

@@ -0,0 +1,132 @@
+import type { TaEvent, TaWebExtensionInfo } from '@celljs/ta-protocol';
+import type * as React from 'react';
+import type { MessageId } from '../i18n/messages.js';
+import type { WebAvatarProps, WebCustomMessage, WebEditor, WebExtensionFactory, WebIcon, WebLabel, WebMenuItem, WebOpener, WebTool, WidgetOptions } from './web-extension-api.js';
+export declare const TaWebExtensions: unique symbol;
+export declare const BuiltinWebExtension: unique symbol;
+/** A web extension that comes with the web client: on until the user turns it off in the settings. */
+export interface BuiltinWebExtension {
+    /** `assistant` is `builtin:assistant`. */
+    readonly name: string;
+    readonly title: MessageId;
+    readonly description: MessageId;
+    readonly activate: WebExtensionFactory;
+}
+export interface LoadedWebExtension {
+    /** `builtin:<name>`, or the id of the server's TaWebExtensionInfo. */
+    id: string;
+    name: string;
+    /** For a web extension of a package. */
+    info?: TaWebExtensionInfo;
+    /** Why it did not load or failed when it started. */
+    error?: string;
+}
+export interface WebWidgetEntry extends Required<Pick<WidgetOptions, 'placement'>> {
+    /** `<extension id>/<key>`. */
+    id: string;
+    extension: string;
+    title?: WebLabel;
+    component: React.ComponentType;
+}
+export interface WebViewEntry {
+    /** `<extension name>/<view name>`. */
+    id: string;
+    extension: string;
+    title: WebLabel;
+    component: React.ComponentType;
+    icon?: WebIcon;
+    location: 'page' | 'sidebar' | 'panel';
+    order: number;
+    head?: React.ComponentType;
+    pages?: string[];
+    menu?(): WebMenuItem[][];
+}
+export interface WebEditorEntry extends WebEditor {
+    /** The id of the extension that opened it. */
+    extension: string;
+    /** Opened as a preview: the next preview takes its place (WebExtensionUI.openEditor). */
+    preview?: boolean;
+    /** Changed and not saved (WebExtensionUI.setEditorDirty). */
+    dirty?: boolean;
+}
+/** What of the workbench is kept for the user: the tools open in it, and the tab shown. */
+export interface WorkbenchTabs {
+    /** The ids of the `panel` views open as tabs. */
+    views: string[];
+    /** The tab shown: a view's, or one an extension opens again itself (a file). */
+    active?: string;
+}
+export interface WebExtensionsState {
+    extensions: LoadedWebExtension[];
+    views: WebViewEntry[];
+    widgets: WebWidgetEntry[];
+    renderers: Record<string, React.ComponentType<{
+        message: WebCustomMessage;
+    }>>;
+    /** By the name of the extension, the group of the sessions it draws (WebExtensionAPI.registerAvatar). */
+    avatars: Record<string, React.ComponentType<WebAvatarProps>>;
+    /** The first tool of each name. */
+    tools: WebTool[];
+    /** Those of links (WebExtensionAPI.registerOpener), in the order the extensions registered them. */
+    openers: WebOpener[];
+    /** The tabs of the editor area (the workbench), in the order they opened. */
+    editors: WebEditorEntry[];
+    activeEditor?: string;
+    /** One more each time a tab opens or is shown to be seen: the workbench then shows. */
+    focus: number;
+    /** The directory of the conversation shown. */
+    cwd?: string;
+    /** The session of the conversation shown. */
+    sessionId?: string;
+    /** The view of the page shown in the main area; `''` for the conversation. */
+    page: string;
+}
+export declare namespace WebLabelUtil {
+    function text(label: WebLabel | undefined): string;
+}
+/** What `on` and `sendUserMessage` of web extensions reach: the conversation shown. */
+export interface WebExtensionConversation {
+    /** None for a new conversation, which opens with its first message. */
+    send?(text: string): Promise<void>;
+    /** Where it works: what `ui.useCwd` gives. */
+    cwd?: string;
+    sessionId?: string;
+    /** Loads its pi extensions again, once the web extensions loaded again (reloadExtensions). */
+    reload?(): Promise<void>;
+}
+/**
+ * The web extensions of the page: the built-ins not turned off in the settings, and those of the packages
+ * pi loads (TaPackageServer.listWebExtensions). Each runs once; what it registers goes when it unloads.
+ */
+export interface TaWebExtensions {
+    readonly state: WebExtensionsState;
+    readonly builtins: readonly BuiltinWebExtension[];
+    subscribe(listener: (state: WebExtensionsState) => void): () => void;
+    /** Loads what is new, unloads what is gone or off, and loads again what changed. True when anything did. */
+    refresh(): Promise<boolean>;
+    /** Removes the package of a web extension from the server. */
+    remove(id: string): Promise<void>;
+    /** Shows an open tab of the editor area. */
+    showEditor(id: string): void;
+    /** Opens a `panel` view as a tab of the editor area, or shows its tab. */
+    openView(id: string): void;
+    /** Shows a page in the main area by the id of its view, or the conversation for `''`. */
+    showPage(id: string): void;
+    /**
+     * Opens a tab of the page itself (the cards of web extensions), or shows it again; behind the one shown
+     * with `preserveFocus`. A `preview` entry takes the place of the preview open, whose `onClose` runs.
+     */
+    open(editor: WebEditorEntry, preserveFocus?: boolean): void;
+    /** Closes a tab of the editor area, as the user does: its `onClose` runs; a dirty one only once the user agrees. */
+    closeEditor(id: string): Promise<void>;
+    /** Closes tabs at once, as the menu of a tab does: one question for those that are dirty, then the rest close in order. */
+    closeEditors(ids: readonly string[]): Promise<void>;
+    /** Keeps a preview tab, as a double click on it does. */
+    pinEditor(id: string): void;
+    /** The conversation shown, while there is one. */
+    connect(conversation: WebExtensionConversation | undefined): void;
+    /** An event of the conversation shown, for the handlers of `on`. */
+    emit(event: TaEvent): void;
+    /** What `switchSession` of web extensions does: the page shows that session; `undefined` until it can. */
+    setSessionSwitcher(switcher: ((sessionId: string) => Promise<void>) | undefined): void;
+}

package/esm/browser/extension/web-extension-protocol.js

@@ -0,0 +1,10 @@
+export const TaWebExtensions = Symbol('TaWebExtensions');
+export const BuiltinWebExtension = Symbol('BuiltinWebExtension');
+export var WebLabelUtil;
+(function (WebLabelUtil) {
+    function text(label) {
+        return typeof label === 'function' ? label() : (label !== null && label !== void 0 ? label : '');
+    }
+    WebLabelUtil.text = text;
+})(WebLabelUtil || (WebLabelUtil = {}));
+//# sourceMappingURL=web-extension-protocol.js.map

package/esm/browser/extension/web-extension-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-extension-protocol.js","sourceRoot":"","sources":["../../../src/browser/extension/web-extension-protocol.ts"],"names":[],"mappings":"AAgBA,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;AACzD,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;AAoFjE,MAAM,KAAW,YAAY,CAI5B;AAJD,WAAiB,YAAY;IACzB,SAAgB,IAAI,CAAC,KAA2B;QAC5C,OAAO,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,EAAE,CAAC,CAAC;IACjE,CAAC;IAFe,aAAA,IAAI,OAEnB,CAAA;AACL,CAAC,EAJgB,YAAY,KAAZ,YAAY,QAI5B"}

package/esm/browser/extension/web-extensions.d.ts

@@ -0,0 +1,118 @@
+import type { TaEvent, TaWebExtensionInfo } from '@celljs/ta-protocol';
+import * as React from 'react';
+import { TaNotices } from '../notices/notices-protocol.js';
+import { TaSettings } from '../settings/settings-protocol.js';
+import { type StateSpec, TaState } from '../state/state-protocol.js';
+import { TaWorkbench } from '../workbench-protocol.js';
+import type { CodeEditorProps, DiffEditorProps, WebComposerProps, WebEditor, WebExtensionAPI, WebExtensionFactory, WebFolderPickerProps, WebOpener, WebStorage, WebTool, WebView, WidgetOptions } from './web-extension-api.js';
+import { BuiltinWebExtension, type LoadedWebExtension, TaWebExtensions, type WebEditorEntry, type WebExtensionConversation, type WebExtensionsState, type WorkbenchTabs } from './web-extension-protocol.js';
+/** One web extension that runs, and what it registered. */
+interface Running {
+    loaded: LoadedWebExtension;
+    /** Of the file it runs; a change loads it again. */
+    hash?: string;
+    /** Its function has returned: what it registers from now on shows at once. */
+    started: boolean;
+    stopped: boolean;
+    views: Map<string, WebView>;
+    widgets: Map<string, {
+        component: React.ComponentType;
+        options: WidgetOptions;
+    }>;
+    renderers: Map<string, WebExtensionsState['renderers'][string]>;
+    avatar?: WebExtensionsState['avatars'][string];
+    tools: WebTool[];
+    openers: WebOpener[];
+    handlers: {
+        type: string;
+        handler: (event: TaEvent) => void;
+    }[];
+    /** Undo what it subscribed to outside this class (the terminals of the workbench). */
+    unsubscribes: (() => void)[];
+    dispose?: () => void;
+}
+export declare namespace WebExtensionUtil {
+    function builtinId(name: string): string;
+    /** The default export of a module of source code. */
+    function load(code: string): Promise<WebExtensionFactory>;
+    function message(error: unknown): string;
+}
+export declare namespace WebViewUtil {
+    /** The tab a `panel` view opens as. */
+    function editorId(viewId: string): string;
+    /** The page shown last in this tab of the browser: another tab may show another. */
+    const PAGE: StateSpec<string>;
+    /** The tools open in the workbench, for the user in any browser: the workbench is one for the whole page. */
+    const TABS: StateSpec<WorkbenchTabs>;
+    /** What to keep of the tabs: the views open, and the one shown, or the one still to open again. */
+    function tabs(editors: readonly {
+        id: string;
+    }[], active: string | undefined): WorkbenchTabs;
+}
+export declare class TaWebExtensionsImpl implements TaWebExtensions {
+    protected readonly workbench: TaWorkbench;
+    protected readonly settings: TaSettings;
+    protected readonly notices: TaNotices;
+    protected readonly persisted: TaState;
+    readonly builtins: BuiltinWebExtension[];
+    protected current: WebExtensionsState;
+    protected readonly running: Map<string, Running>;
+    protected readonly listeners: Set<(state: WebExtensionsState) => void>;
+    protected conversation?: WebExtensionConversation;
+    protected switcher?: (sessionId: string) => Promise<void>;
+    protected refreshing: Promise<boolean>;
+    /** The tabs of before are open again: from now on, what is open is kept. */
+    protected restored: boolean;
+    /** The tab shown before the page loaded, until it opens again or the user shows another. */
+    protected pendingActive?: string;
+    get state(): WebExtensionsState;
+    protected init(): void;
+    subscribe(listener: (state: WebExtensionsState) => void): () => void;
+    /** One at a time: a refresh while one runs follows it. */
+    refresh(): Promise<boolean>;
+    remove(id: string): Promise<void>;
+    showEditor(id: string): void;
+    openView(id: string, preserveFocus?: boolean): void;
+    showPage(id: string): void;
+    protected showView(id: string): void;
+    protected isShown(id: string): boolean;
+    closeEditor(id: string): Promise<void>;
+    closeEditors(ids: readonly string[]): Promise<void>;
+    pinEditor(id: string): void;
+    /** Removes a tab and tells the extension that opened it. */
+    protected dropEditor(editor: WebEditorEntry): void;
+    protected setDirty(run: Running, id: string, dirty: boolean): void;
+    connect(conversation: WebExtensionConversation | undefined): void;
+    setSessionSwitcher(switcher: ((sessionId: string) => Promise<void>) | undefined): void;
+    emit(event: TaEvent): void;
+    protected reconcile(): Promise<boolean>;
+    /** The tools open before, behind what is shown; the tab shown before, once it is open again. */
+    protected restoreTabs(): Promise<void>;
+    protected keepTabs(): void;
+    protected startPackage(info: TaWebExtensionInfo): Promise<void>;
+    protected start(loaded: LoadedWebExtension, factory: WebExtensionFactory, hash?: string): void;
+    protected stop(run: Running): void;
+    protected openEditor(run: Running, editor: WebEditor, preserveFocus?: boolean, preview?: boolean): void;
+    open(editor: WebEditorEntry, preserveFocus?: boolean): void;
+    protected removeEditors(match: (editor: WebExtensionsState['editors'][number]) => boolean): void;
+    protected record(loaded: LoadedWebExtension, hash?: string): Running;
+    /** The API of one extension: what it registers is its own and goes when it stops. */
+    /** Monaco in the theme and language of the settings, the same component for every extension. */
+    protected readonly codeEditor: (props: CodeEditorProps) => React.FunctionComponentElement<CodeEditorProps & {
+        settings: TaSettings;
+    }>;
+    protected readonly diffEditor: (props: DiffEditorProps) => React.FunctionComponentElement<DiffEditorProps & {
+        settings: TaSettings;
+    }>;
+    protected readonly listDirectory: (directory: string) => Promise<import("@celljs/ta-protocol").TaDirEntry[]>;
+    /** The message box, whose button of the directory lists those of the server. */
+    protected readonly composer: (props: WebComposerProps) => React.FunctionComponentElement<import("../components/web-composer.js").WebComposerHostProps>;
+    protected readonly folderPicker: ({ initial, onPick, onClose }: WebFolderPickerProps) => React.FunctionComponentElement<import("../components/folder-picker.js").FolderPickerProps>;
+    protected api(run: Running): WebExtensionAPI;
+    /** The data of the package of an extension on the server; of a directory with `cwd`. */
+    protected storage(run: Running, cwd?: string): WebStorage;
+    protected guard(run: Running, action: () => void): void;
+    protected publish(): void;
+    protected update(change: Partial<WebExtensionsState>): void;
+}
+export {};