@litfamily/litopencode 1.0.29 → 1.0.31

package/dist/v2/hooks.js

@@ -0,0 +1,61 @@
+// Tool hooks on OpenCode 2, reusing the OpenCode 1 guards. OpenCode 2 renamed two tools (bash is shell,
+// task is subagent) and names a file argument `path`, so each call is shown to the guards under the
+// names they know. A throw in `execute.before` fails that one call; `execute.after` must never throw.
+import { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "../hooks.js";
+const v1ToolNames = { shell: "bash", subagent: "task" };
+function v1ToolName(tool) {
+    return v1ToolNames[tool] ?? tool;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The arguments as the OpenCode 1 guards read them: a `path` also answers to `filePath`. */
+function v1Args(input) {
+    if (!isRecord(input) || typeof input.path !== "string" || "filePath" in input)
+        return { args: input, aliased: false };
+    return { args: { ...input, filePath: input.path }, aliased: true };
+}
+function contentText(content) {
+    if (content === undefined)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return undefined;
+}
+export function createV2ToolHooks(options) {
+    const before = createToolExecuteBeforeHook({ getSession: options.getSession, deliverableHedgeGuard: options.deliverableHedgeGuard });
+    const after = createToolExecuteAfterHook({
+        projectRoot: options.projectRoot,
+        knowledgeCaptureEnabled: options.knowledgeCaptureEnabled,
+        deliverableHedgeGuard: options.deliverableHedgeGuard
+    });
+    async function executeBefore(event) {
+        const { args, aliased } = v1Args(event.input);
+        const output = { args };
+        await before({ tool: v1ToolName(event.tool), sessionID: event.sessionID, callID: event.id }, output);
+        if (output.args === args)
+            return;
+        if (aliased && isRecord(output.args)) {
+            const { filePath: _alias, ...rest } = output.args;
+            event.input = rest;
+            return;
+        }
+        event.input = output.args;
+    }
+    async function executeAfter(event) {
+        if (event.status !== "completed" || event.result === undefined)
+            return;
+        const text = contentText(event.result.content);
+        if (text === undefined)
+            return;
+        const output = { title: "", output: text, metadata: { ...(event.result.metadata ?? {}) } };
+        try {
+            await after({ tool: v1ToolName(event.tool), sessionID: event.sessionID, callID: event.id, args: v1Args(event.input).args }, output);
+        }
+        catch { // no-excuse-ok: catch -- OpenCode 2 treats a throw after a tool ran as a crash; the result stays as it was.
+            return;
+        }
+        event.result = { ...event.result, content: output.output, metadata: output.metadata };
+    }
+    return { executeBefore, executeAfter };
+}

package/dist/v2/server.d.ts

@@ -0,0 +1,2 @@
+import { type ServerContextLike } from "./context.ts";
+export declare function setupLitOpenCodeServer(context: ServerContextLike): Promise<() => Promise<void>>;

package/dist/v2/server.js

@@ -0,0 +1,68 @@
+// LitOpenCode's OpenCode 2 server plugin. OpenCode 2 runs one instance per project location and calls
+// `setup` once for it; every registration below is released by the host when the instance stops, and
+// the returned cleanup releases what the plugin itself holds. There is no automatic self-update here:
+// OpenCode 2 updates plugins itself (`opencode plugin update` and its update policy).
+import path from "node:path";
+import { loadConfig } from "../config.js";
+import { createDeliverableHedgeGuard } from "../deliverable-hedge-guard.js";
+import { createLogger } from "../logger.js";
+import { defaultOpenCodeConfigRoot } from "../state.js";
+import { applyLitAgents, createSessionModelRoute, enforcePlanningOnly, planLitAgents, registerOpenAiProviderModels } from "./agents.js";
+import { createSessionLookupV2, projectRootFromLocation } from "./context.js";
+import { createV2Commands } from "./commands.js";
+import { createV2Events } from "./events.js";
+import { createV2ToolHooks } from "./hooks.js";
+import { createV2SessionHooks } from "./session-hooks.js";
+import { addLitTools, litToolsForProject } from "./tools.js";
+export async function setupLitOpenCodeServer(context) {
+    const root = projectRootFromLocation(context.location);
+    const loaded = await loadConfig(root);
+    const logger = createLogger(loaded.paths);
+    const getSession = createSessionLookupV2(context.session);
+    const deliverableHedgeGuard = createDeliverableHedgeGuard({ projectRoot: context.location.directory.trim() || root });
+    const agentPlan = planLitAgents(loaded.config);
+    const toolHooks = createV2ToolHooks({
+        projectRoot: root,
+        knowledgeCaptureEnabled: loaded.config.knowledge.capture,
+        getSession,
+        deliverableHedgeGuard
+    });
+    await context.model.transform(registerOpenAiProviderModels);
+    await context.agent.transform((editor) => applyLitAgents(editor, agentPlan));
+    await context.permission.hook("evaluate", enforcePlanningOnly);
+    const tools = litToolsForProject(root);
+    await context.tool.transform((editor) => addLitTools(editor, tools));
+    await context.tool.hook("execute.before", toolHooks.executeBefore);
+    await context.tool.hook("execute.after", toolHooks.executeAfter);
+    const commands = createV2Commands([defaultOpenCodeConfigRoot(), path.join(root, ".opencode")], context.session);
+    await context.command.transform((editor) => commands.add(editor));
+    const events = createV2Events({
+        projectRoot: root,
+        paths: loaded.paths,
+        autoHandoffConfig: loaded.config.autoHandoff,
+        boundedAuthority: loaded.config.boundedAuthority,
+        getSession,
+        session: context.session,
+        model: context.model,
+        onSessionDeleted: (sessionID) => sessionHooks.clear(sessionID)
+    });
+    const sessionHooks = createV2SessionHooks({
+        projectRoot: root,
+        config: loaded.config,
+        getSession,
+        routeModel: createSessionModelRoute(agentPlan, context.session, context.model),
+        requestOptions: agentPlan.requestOptions,
+        autoHandoffRoute: events.route,
+        extraSystem: events.systemText,
+        acceptCommandMark: commands.acceptMark
+    });
+    await context.session.hook("prompt", sessionHooks.prompt);
+    await context.session.hook("context", sessionHooks.context);
+    await context.session.hook("compaction", sessionHooks.compaction);
+    const stopEvents = events.start(context.event);
+    return async () => {
+        await stopEvents();
+        deliverableHedgeGuard.dispose();
+        await logger.dispose();
+    };
+}

package/dist/v2/session-hooks.d.ts

@@ -0,0 +1,64 @@
+import { type ChatActivationMode } from "../activation-routing.ts";
+import { type AutoHandoffRouteMode } from "../auto-handoff.ts";
+import type { LitOpenCodeConfig } from "../config.ts";
+import type { AgentRequestOptions } from "./agents.ts";
+export type SystemPartLike = {
+    readonly type: "text";
+    readonly text: string;
+};
+export type PromptEvent = {
+    readonly sessionID: string;
+    readonly messageID: string;
+    prompt: {
+        text: string;
+    };
+    metadata?: Record<string, unknown>;
+};
+/** An OpenCode 2 request message: an instance of the host's own message class. */
+export type MessageLike = {
+    readonly role: string;
+    readonly content: readonly unknown[];
+};
+export type ContextEvent = {
+    readonly sessionID: string;
+    readonly agent: string;
+    system: SystemPartLike[];
+    messages?: MessageLike[];
+    options: Record<string, unknown>;
+};
+export type SessionAgentLookup = (sessionID: string) => Promise<{
+    readonly parentID?: string;
+    readonly agent?: string;
+} | undefined>;
+export type V2SessionHookOptions = {
+    readonly projectRoot: string;
+    readonly config: Pick<LitOpenCodeConfig, "outputStyle" | "boundedAuthority">;
+    readonly getSession: SessionAgentLookup;
+    /** Puts a session that has no model of its own on its agent's route. */
+    readonly routeModel?: (sessionID: string) => Promise<void>;
+    readonly requestOptions: ReadonlyMap<string, AgentRequestOptions>;
+    readonly autoHandoffRoute?: (text: string, mode: AutoHandoffRouteMode) => Promise<string | undefined>;
+    /** Extra system text for this request, such as the saved handoff after a compaction. */
+    readonly extraSystem?: (sessionID: string) => Promise<readonly string[]>;
+    readonly onActivation?: (sessionID: string, mode: ChatActivationMode | string) => void;
+    /** Accepts a command mark the plugin itself sent for this session; anything else is dropped. */
+    readonly acceptCommandMark?: (sessionID: string, marker: unknown) => {
+        readonly command: string;
+        readonly banner: string;
+    } | undefined;
+};
+/**
+ * `opencode2 run "lit fix it"` sends the message wrapped in double quotes (each multi-word argument is
+ * quoted, inner quotes escaped). The prompt hook runs in the server, so the run's argv is not available
+ * the way it is on OpenCode 1; a message that is exactly one such quoted argument is read without the
+ * quotes. Quoted text inside a longer prompt stays inactive. The server cannot tell a run argument from
+ * a TUI prompt typed entirely inside double quotes, so such a typed `"lit fix it"` activates as well;
+ * on OpenCode 1 it stayed inert.
+ */
+export declare function unwrapRunArgument(input: string): string;
+export declare function createV2SessionHooks(options: V2SessionHookOptions): {
+    prompt: (event: PromptEvent) => Promise<void>;
+    context: (event: ContextEvent) => Promise<void>;
+    compaction: (event: ContextEvent) => Promise<void>;
+    clear(sessionID: string): void;
+};

package/dist/v2/session-hooks.js

@@ -0,0 +1,230 @@
+// Prompt admission and request context on OpenCode 2. OpenCode 1 appended activation text to the user
+// message as an extra part; OpenCode 2 has no parts. Here the `prompt` hook marks a lit prompt in the
+// user message metadata (which the TUI reads for the ignition toast and the footer line), and the
+// `context` hook hands the activation text, the static rules and the reader contract to every model
+// request of that session as system parts. Text that comes from the project or a lifecycle file rather
+// than from LitOpenCode's own instructions (local knowledge, a start-work receipt, an auto-handoff setting
+// reply) rides the latest user message instead, the channel it had on OpenCode 1.
+import { fileURLToPath } from "node:url";
+import { createActivationMemory, decideReentry } from "../activation-reentry.js";
+import { detectChatActivationMode, promptForChatActivationMode } from "../activation-routing.js";
+import { startWorkPromptInjection } from "../activation-workflow-prompts.js";
+import { autoHandoffSettingText } from "../auto-handoff.js";
+import { applyTrustedStartWorkDirective, parseStartWorkLifecycleDirective } from "../bounded-authority-hooks.js";
+import { queryKnowledge } from "../knowledge.js";
+import { createLitGoalOperations } from "../ledger.js";
+import { applyCompactionRuleReset, applyStaticRuleInjection } from "../rules/hooks.js";
+import { isReadOnlyWorkflowFamilyPlan } from "../workflow-families.js";
+const bundledRulesDir = fileURLToPath(new URL("../../rules/bundled-rules", import.meta.url));
+/**
+ * `opencode2 run "lit fix it"` sends the message wrapped in double quotes (each multi-word argument is
+ * quoted, inner quotes escaped). The prompt hook runs in the server, so the run's argv is not available
+ * the way it is on OpenCode 1; a message that is exactly one such quoted argument is read without the
+ * quotes. Quoted text inside a longer prompt stays inactive. The server cannot tell a run argument from
+ * a TUI prompt typed entirely inside double quotes, so such a typed `"lit fix it"` activates as well;
+ * on OpenCode 1 it stayed inert.
+ */
+export function unwrapRunArgument(input) {
+    const match = /^"((?:[^"\\]|\\.)*)"$/su.exec(input);
+    return match === null ? input : match[1].replace(/\\"/gu, '"');
+}
+function text(value) {
+    return { type: "text", text: value };
+}
+/**
+ * Adds text parts to the latest user message. The host builds each message with its own class, so the
+ * copy is made with that class; false when there is no user message to carry the text.
+ */
+function appendToLatestUserMessage(messages, texts) {
+    if (messages === undefined)
+        return false;
+    let index = messages.length - 1;
+    while (index >= 0 && messages[index].role !== "user")
+        index -= 1;
+    if (index < 0)
+        return false;
+    const latest = messages[index];
+    const Message = latest.constructor;
+    messages[index] = new Message({ ...latest, content: [...latest.content, ...texts.map(text)] });
+    return true;
+}
+export function createV2SessionHooks(options) {
+    const operations = createLitGoalOperations(options.projectRoot);
+    const sessions = new Map();
+    // The latest activation stays in every request of its session, so a repeated lit only adds a note to it.
+    const activationMemory = createActivationMemory();
+    function stateFor(sessionID) {
+        let state = sessions.get(sessionID);
+        if (state === undefined) {
+            state = { turn: [], user: [] };
+            sessions.set(sessionID, state);
+        }
+        return state;
+    }
+    async function lookup(sessionID) {
+        try {
+            const session = await options.getSession(sessionID);
+            if (session === undefined)
+                return { child: true };
+            return { child: session.parentID !== undefined, ...(session.agent === undefined ? {} : { agent: session.agent }) };
+        }
+        catch {
+            // Fail closed: a session whose lineage cannot be read is treated as delegated.
+            return { child: true };
+        }
+    }
+    /** Keeps a command mark only when the plugin sent it; returns true for such a trusted command turn. */
+    function admitCommandMark(event) {
+        const metadata = event.metadata;
+        if (metadata === undefined || !("litopencode" in metadata))
+            return false;
+        const { litopencode: marker, ...rest } = metadata;
+        const accepted = options.acceptCommandMark?.(event.sessionID, marker);
+        if (accepted === undefined) {
+            event.metadata = Object.keys(rest).length === 0 ? undefined : rest;
+            return false;
+        }
+        event.metadata = { ...rest, litopencode: { command: accepted.command, banner: accepted.banner, source: "command" } };
+        options.onActivation?.(event.sessionID, accepted.command);
+        return true;
+    }
+    async function prompt(event) {
+        const input = unwrapRunArgument(event.prompt.text);
+        try {
+            await options.routeModel?.(event.sessionID);
+        }
+        catch { // no-excuse-ok: catch -- a failed route switch must never block the user message.
+            // The session keeps the model the host chose.
+        }
+        if (admitCommandMark(event)) {
+            const state = stateFor(event.sessionID);
+            state.turn = [];
+            state.user = [];
+            return;
+        }
+        const session = await lookup(event.sessionID);
+        if (session.child)
+            return;
+        const state = stateFor(event.sessionID);
+        state.turn = [];
+        state.user = [];
+        if (input.trim() === "")
+            return;
+        if (options.autoHandoffRoute !== undefined) {
+            const reply = await options.autoHandoffRoute(input, "chat");
+            if (reply !== undefined) {
+                state.user.push(autoHandoffSettingText(reply));
+                return;
+            }
+        }
+        try {
+            const knowledge = await queryKnowledge(options.projectRoot, input.slice(0, 4096));
+            if (knowledge.text !== "")
+                state.user.push(knowledge.text);
+        }
+        catch { // no-excuse-ok: catch -- local relevance must never block the user message.
+            // A malformed or unreadable knowledge store stays silent instead of inventing context.
+        }
+        const mode = detectChatActivationMode(input, session.agent);
+        if (mode === undefined)
+            return;
+        const trigger = mode === "lit-handoff" ? "handoff" : mode === "lit-scientific-visualization" ? mode : "lit";
+        let activation = promptForChatActivationMode(mode, input);
+        if (mode === "start-work" && session.agent !== "lit-plan") {
+            const directive = parseStartWorkLifecycleDirective(input, { chat: true });
+            if (directive?.action === "resume") {
+                try {
+                    const receipt = await applyTrustedStartWorkDirective(options.projectRoot, event.sessionID, directive, options.config.boundedAuthority);
+                    state.user.push(receipt.text);
+                    activation = startWorkPromptInjection;
+                }
+                catch {
+                    activation = "BLOCKED: bounded-authority lifecycle resume rejected. Use /start-work with the exact pending boundary, grant, work id, session, and CAS revision.";
+                }
+            }
+        }
+        const reentry = await decideReentry({
+            memory: activationMemory,
+            projectRoot: options.projectRoot,
+            sessionID: event.sessionID,
+            mode,
+            text: input
+        });
+        if (reentry.kind === "continue") {
+            state.turn.push(reentry.text);
+            event.metadata = { ...(event.metadata ?? {}), litopencode: { mode: reentry.mode, trigger, source: "prompt", reentry: "continue" } };
+            options.onActivation?.(event.sessionID, reentry.mode);
+            return;
+        }
+        if (reentry.kind === "resume")
+            activation = `${reentry.line}\n${activation}`;
+        else if (reentry.kind === "confirm")
+            activation = `${activation}\n${reentry.line}`;
+        state.activation = activation;
+        event.metadata = {
+            ...(event.metadata ?? {}),
+            litopencode: { mode, trigger, source: "prompt", ...(reentry.kind === "full" ? {} : { reentry: reentry.kind }) }
+        };
+        options.onActivation?.(event.sessionID, mode);
+        if (reentry.kind !== "confirm" && mode !== "lit-handoff" && mode !== "lit-scientific-visualization") {
+            activationMemory.remember(event.sessionID, mode);
+        }
+        if (mode === "lit-task" || mode === "lit-recap" || mode === "lit-brainstorm" || isReadOnlyWorkflowFamilyPlan(mode))
+            return;
+        try {
+            await operations.init();
+            await operations.append({
+                type: "prompt.activated",
+                trigger,
+                source: "prompt",
+                mode,
+                sessionID: event.sessionID,
+                messageID: event.messageID,
+                ...(session.agent === undefined ? {} : { agent: session.agent }),
+                timestamp: new Date().toISOString()
+            });
+        }
+        catch { // no-excuse-ok: catch -- activation must survive best-effort ledger failure.
+            // The activation text is the primary surface; the ledger write is best-effort.
+        }
+    }
+    async function context(event) {
+        const state = sessions.get(event.sessionID);
+        if (state?.activation !== undefined)
+            event.system.push(text(state.activation));
+        for (const entry of state?.turn ?? [])
+            event.system.push(text(entry));
+        const user = state?.user ?? [];
+        if (user.length > 0 && !appendToLatestUserMessage(event.messages, user)) {
+            for (const entry of user)
+                event.system.push(text(entry));
+        }
+        for (const entry of (await options.extraSystem?.(event.sessionID)) ?? [])
+            event.system.push(text(entry));
+        const rules = { system: [] };
+        await applyStaticRuleInjection({ projectRoot: options.projectRoot, bundledRulesDir, outputStyle: options.config.outputStyle }, { sessionID: event.sessionID }, rules);
+        for (const entry of rules.system)
+            event.system.push(text(entry));
+        const request = options.requestOptions.get(event.agent);
+        if (request !== undefined) {
+            for (const [key, value] of Object.entries(request))
+                if (event.options[key] === undefined)
+                    event.options[key] = value;
+        }
+    }
+    async function compaction(event) {
+        const output = { context: [] };
+        await applyCompactionRuleReset({ sessionID: event.sessionID }, output);
+        for (const entry of output.context)
+            event.system.push(text(entry));
+    }
+    return {
+        prompt,
+        context,
+        compaction,
+        clear(sessionID) {
+            sessions.delete(sessionID);
+            activationMemory.forget(sessionID);
+        }
+    };
+}

package/dist/v2/tools.d.ts

@@ -0,0 +1,26 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+export type ToolCallContextLike = {
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly signal: AbortSignal;
+};
+export type ToolResultLike = {
+    readonly content?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+};
+export type ToolInfoLike = {
+    readonly name: string;
+    readonly description: string;
+    readonly input: Record<string, unknown>;
+    readonly options: {
+        readonly codemode: false;
+    };
+    readonly execute: (input: unknown, context: ToolCallContextLike) => Promise<ToolResultLike>;
+};
+export type ToolEditorLike = {
+    add(tool: ToolInfoLike): void;
+};
+export declare function adaptTool(name: string, definition: ToolDefinition, projectRoot: string): ToolInfoLike;
+export declare function litToolsForProject(projectRoot: string): readonly ToolInfoLike[];
+export declare function addLitTools(editor: ToolEditorLike, tools: readonly ToolInfoLike[]): void;

package/dist/v2/tools.js

@@ -0,0 +1,49 @@
+// LitOpenCode's five tools on OpenCode 2. The tool bodies are the OpenCode 1 ones; this adapter gives
+// each a closed JSON Schema input, validates the call before it runs, hands the body an OpenCode 1
+// style context whose directory is the plugin's project, and returns `{ content, metadata }`. Each tool
+// sits on the model's own tool list (`codemode: false`), as it did on OpenCode 1, so lit-plan, which has
+// no Code Mode `execute`, still has them.
+import { z } from "zod";
+import { litOpenCodeTools } from "../tools.js";
+function resultToV2(result) {
+    if (typeof result === "string")
+        return { content: result };
+    return {
+        content: result.output,
+        metadata: { ...(result.metadata ?? {}), ...(result.title === undefined ? {} : { title: result.title }) }
+    };
+}
+export function adaptTool(name, definition, projectRoot) {
+    const schema = z.strictObject(definition.args);
+    const { $schema: _dialect, ...input } = z.toJSONSchema(schema, { io: "input" });
+    return {
+        name,
+        description: definition.description,
+        input,
+        options: { codemode: false },
+        async execute(raw, context) {
+            const args = schema.parse(raw ?? {});
+            const v1Context = {
+                sessionID: context.sessionID,
+                messageID: context.messageID,
+                agent: context.agent,
+                directory: projectRoot,
+                worktree: projectRoot,
+                abort: context.signal,
+                metadata: () => undefined,
+                // No tool body asks today; a future one must not be approved without the user seeing a prompt.
+                ask: async () => {
+                    throw new Error(`${name}: asking for permission from inside a tool is not supported on OpenCode 2`);
+                }
+            };
+            return resultToV2(await definition.execute(args, v1Context));
+        }
+    };
+}
+export function litToolsForProject(projectRoot) {
+    return Object.entries(litOpenCodeTools).map(([name, definition]) => adaptTool(name, definition, projectRoot));
+}
+export function addLitTools(editor, tools) {
+    for (const tool of tools)
+        editor.add(tool);
+}

package/dist/v2/tui.d.ts

@@ -0,0 +1,63 @@
+import { type MissionDataV2 } from "../tui/mission-source-v2.ts";
+import { type MissionPalette } from "../tui/mission-text.ts";
+export type TuiRuntime = {
+    readonly jsx: (type: string, props?: Record<string, unknown>) => unknown;
+    readonly createSignal: <T>(value: T) => readonly [() => T, (value: T) => T];
+    readonly createEffect: (fn: () => void) => void;
+    readonly createRoot: <T>(fn: (dispose: () => void) => T) => T;
+};
+type PromptFooterInput = {
+    readonly sessionID?: string;
+    readonly mode: "normal" | "shell";
+    readonly showDetails: boolean;
+};
+export type SlotClaimLike = {
+    readonly append: "sidebar.content";
+    readonly render: (input: {
+        readonly sessionID: string;
+    }) => unknown;
+} | {
+    readonly append: "prompt.footer.status";
+    readonly render: (input: PromptFooterInput) => unknown;
+};
+export type TuiContextLike = {
+    readonly location: {
+        readonly directory: string;
+    } | undefined;
+    readonly theme: unknown;
+    readonly themeMode: "dark" | "light";
+    readonly ui: {
+        readonly slot: (claim: SlotClaimLike) => () => void;
+        readonly toast: {
+            readonly show: (options: {
+                readonly title?: string;
+                readonly message: string;
+                readonly variant?: "info" | "success" | "warning" | "error";
+                readonly duration?: number;
+                readonly sessionID?: string;
+            }) => void;
+        };
+    };
+    readonly storage: {
+        readonly store: <Value extends object>(key: string, options: {
+            readonly initial: Value;
+        }) => readonly [Value, unknown];
+    };
+    readonly data: MissionDataV2 & {
+        readonly listen: (handler: (event: {
+            readonly details: {
+                readonly type: string;
+            };
+        }) => void) => () => void;
+        readonly location: {
+            default(): {
+                readonly directory: string;
+            };
+        };
+    };
+};
+/** OpenCode 2 theme tokens under the names the mission palette reads. */
+export declare function paletteFromV2Theme(theme: unknown, mode: "dark" | "light"): MissionPalette;
+export declare function ignitionLine(name: string): string;
+export declare function setupLitOpenCodeTui(context: TuiContextLike, runtime?: TuiRuntime): Promise<() => Promise<void>>;
+export {};