terminal-pilot 0.0.30 → 0.0.32

package/node_modules/toolcraft-design/dist/dashboard/dashboard.js

@@ -0,0 +1,167 @@
+import { createLogger } from "../components/logger.js";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { ScreenBuffer, diff } from "./buffer.js";
+import { renderBorder } from "./components/border.js";
+import { defaultHints, renderFooter } from "./components/footer.js";
+import { renderOutputPane } from "./components/output-pane.js";
+import { renderStatsPane } from "./components/stats-pane.js";
+import { createKeymap } from "./keymap.js";
+import { computeDashboardLayout } from "./layout.js";
+import { createStore } from "./store.js";
+import { createTerminalDriver } from "./terminal.js";
+const DEFAULT_TITLE = "Output";
+const DEFAULT_STATS_TITLE = "Stats";
+const DEFAULT_RIGHT_PANE_WIDTH = 25;
+export function createDashboard(opts = {}) {
+    const stdin = opts.stdin ?? process.stdin;
+    const stdout = opts.stdout ?? process.stdout;
+    const resolveCommand = createKeymap(opts.keymap);
+    const footerHints = opts.hints ?? defaultHints();
+    const title = opts.title ?? DEFAULT_TITLE;
+    const statsTitle = opts.statsTitle ?? DEFAULT_STATS_TITLE;
+    const rightPaneWidth = opts.rightPaneWidth ?? DEFAULT_RIGHT_PANE_WIDTH;
+    const commandHandlers = new Set();
+    const fallbackLogger = createLogger((message) => {
+        stdout.write(`${message}\n`);
+    });
+    let driver;
+    let store;
+    let previousBuffer = new ScreenBuffer(0, 0);
+    let unsubscribeStore;
+    let unsubscribeKeypress;
+    let unsubscribeResize;
+    let started = false;
+    let destroyed = false;
+    function appendOutput(item) {
+        if (destroyed) {
+            return;
+        }
+        if (!isTerminalMode()) {
+            writeFallbackOutput(item);
+            return;
+        }
+        getStore().appendOutput(item);
+    }
+    function updateStats(stats) {
+        if (destroyed || !isTerminalMode()) {
+            return;
+        }
+        getStore().updateStats(stats);
+    }
+    function start() {
+        if (destroyed || started || !isTerminalMode()) {
+            return;
+        }
+        driver = createTerminalDriver({ stdin, stdout });
+        started = true;
+        previousBuffer = new ScreenBuffer(0, 0);
+        driver.enterRawMode();
+        driver.enterAltScreen();
+        driver.disableLineWrap();
+        driver.hideCursor();
+        render();
+        const activeStore = getStore();
+        unsubscribeStore = activeStore.onChange(() => {
+            render();
+        });
+        unsubscribeKeypress = driver.onKeypress((event) => {
+            const command = resolveCommand(event);
+            if (command === undefined) {
+                return;
+            }
+            emitCommand(command);
+        });
+        unsubscribeResize = driver.onResize(() => {
+            render();
+        });
+    }
+    function stop() {
+        unsubscribeStore?.();
+        unsubscribeKeypress?.();
+        unsubscribeResize?.();
+        unsubscribeStore = undefined;
+        unsubscribeKeypress = undefined;
+        unsubscribeResize = undefined;
+        if (driver === undefined) {
+            started = false;
+            return;
+        }
+        driver.destroy();
+        driver = undefined;
+        previousBuffer = new ScreenBuffer(0, 0);
+        started = false;
+    }
+    function onCommand(handler) {
+        if (destroyed) {
+            return;
+        }
+        commandHandlers.add(handler);
+    }
+    function destroy() {
+        if (destroyed) {
+            return;
+        }
+        stop();
+        commandHandlers.clear();
+        store = undefined;
+        destroyed = true;
+    }
+    function getStore() {
+        store ??= createStore();
+        return store;
+    }
+    function render() {
+        if (driver === undefined) {
+            return;
+        }
+        const { cols, rows } = driver.getSize();
+        const layout = computeDashboardLayout({
+            totalWidth: cols,
+            totalHeight: rows,
+            rightPaneWidth
+        });
+        const nextBuffer = new ScreenBuffer(cols, rows);
+        const state = getStore().getState();
+        renderBorder(nextBuffer, layout, {
+            leftTitle: title,
+            rightTitle: statsTitle,
+            style: { dim: true }
+        });
+        renderOutputPane(nextBuffer, layout.leftPane, state.output);
+        renderStatsPane(nextBuffer, layout.rightPane, state.stats);
+        renderFooter(nextBuffer, layout.footer, footerHints);
+        driver.flush(diff(previousBuffer, nextBuffer));
+        previousBuffer = nextBuffer;
+    }
+    function emitCommand(command) {
+        for (const handler of commandHandlers) {
+            handler(command);
+        }
+    }
+    function writeFallbackOutput(item) {
+        if (item.kind === "success") {
+            fallbackLogger.success(item.text);
+            return;
+        }
+        if (item.kind === "error") {
+            fallbackLogger.error(item.text);
+            return;
+        }
+        if (item.kind === "tool") {
+            fallbackLogger.message(item.text);
+            return;
+        }
+        fallbackLogger.info(item.text);
+    }
+    return {
+        start,
+        stop,
+        appendOutput,
+        updateStats,
+        onCommand,
+        destroy
+    };
+}
+function isTerminalMode() {
+    return resolveOutputFormat() === "terminal";
+}

package/node_modules/toolcraft-design/dist/dashboard/demo.d.ts

@@ -0,0 +1,13 @@
+import type { Dashboard } from "./dashboard.js";
+type DemoDashboard = Pick<Dashboard, "appendOutput" | "updateStats">;
+type DemoRuntime = {
+    setInterval: typeof globalThis.setInterval;
+    clearInterval: typeof globalThis.clearInterval;
+    setTimeout: typeof globalThis.setTimeout;
+    clearTimeout: typeof globalThis.clearTimeout;
+    now: () => number;
+    random: () => number;
+};
+export declare function startDashboardDemo(dashboard: DemoDashboard, runtime?: Partial<DemoRuntime>): () => void;
+export declare function main(): Promise<void>;
+export {};

package/node_modules/toolcraft-design/dist/dashboard/demo.js

@@ -0,0 +1,145 @@
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { createDashboard } from "./dashboard.js";
+const OUTPUT_INTERVAL_MS = 500;
+const STATS_INTERVAL_MS = 1_000;
+const DEMO_DURATION_MS = 30_000;
+const TOKENS_IN_PER_ITERATION = 137;
+const TOKENS_OUT_PER_ITERATION = 89;
+const OUTPUT_KINDS = ["info", "success", "error", "tool", "status"];
+const OUTPUT_MESSAGES = {
+    info: [
+        "Analyzing repository state",
+        "Inspecting agent configuration",
+        "Collecting recent command output"
+    ],
+    success: [
+        "Generated provider config",
+        "Updated dashboard layout",
+        "Saved session checkpoint"
+    ],
+    error: [
+        "Retrying transient network request",
+        "Tool execution returned a non-zero exit code",
+        "Encountered a recoverable validation error"
+    ],
+    tool: [
+        "Running npm test -- --runInBand",
+        "Executing npm run lint:types",
+        "Opening task plan documentation"
+    ],
+    status: [
+        "Waiting for follow-up task",
+        "Streaming model response",
+        "Syncing derived metrics"
+    ]
+};
+const RUNNING_ACTIONS = [
+    "Planning next step",
+    "Executing tool call",
+    "Reviewing tool results",
+    "Updating working memory",
+    "Preparing final response"
+];
+const INITIAL_ACTION = "Connecting to provider";
+const COMPLETED_ACTION = "Completed";
+export function startDashboardDemo(dashboard, runtime = {}) {
+    const setIntervalFn = runtime.setInterval ?? globalThis.setInterval.bind(globalThis);
+    const clearIntervalFn = runtime.clearInterval ?? globalThis.clearInterval.bind(globalThis);
+    const setTimeoutFn = runtime.setTimeout ?? globalThis.setTimeout.bind(globalThis);
+    const clearTimeoutFn = runtime.clearTimeout ?? globalThis.clearTimeout.bind(globalThis);
+    const now = runtime.now ?? Date.now;
+    const random = runtime.random ?? Math.random;
+    let outputCount = 0;
+    let iterations = 0;
+    let cleanedUp = false;
+    dashboard.updateStats({
+        status: "running",
+        currentAction: INITIAL_ACTION
+    });
+    const outputTimer = setIntervalFn(() => {
+        const kind = OUTPUT_KINDS[outputCount % OUTPUT_KINDS.length] ?? "info";
+        dashboard.appendOutput({
+            kind,
+            text: pickOutputMessage(kind, random),
+            ts: now()
+        });
+        outputCount += 1;
+    }, OUTPUT_INTERVAL_MS);
+    const statsTimer = setIntervalFn(() => {
+        iterations += 1;
+        dashboard.updateStats({
+            status: "running",
+            iterations,
+            tokensIn: iterations * TOKENS_IN_PER_ITERATION,
+            tokensOut: iterations * TOKENS_OUT_PER_ITERATION,
+            elapsedMs: iterations * STATS_INTERVAL_MS,
+            currentAction: RUNNING_ACTIONS[(iterations - 1) % RUNNING_ACTIONS.length] ?? INITIAL_ACTION
+        });
+    }, STATS_INTERVAL_MS);
+    const finishTimeout = setTimeoutFn(() => {
+        cleanup();
+        dashboard.updateStats({
+            status: "done",
+            iterations,
+            tokensIn: iterations * TOKENS_IN_PER_ITERATION,
+            tokensOut: iterations * TOKENS_OUT_PER_ITERATION,
+            elapsedMs: DEMO_DURATION_MS,
+            currentAction: COMPLETED_ACTION
+        });
+    }, DEMO_DURATION_MS);
+    function cleanup() {
+        if (cleanedUp) {
+            return;
+        }
+        cleanedUp = true;
+        clearTimeoutFn(finishTimeout);
+        clearIntervalFn(outputTimer);
+        clearIntervalFn(statsTimer);
+    }
+    return cleanup;
+}
+function pickOutputMessage(kind, random) {
+    const options = OUTPUT_MESSAGES[kind];
+    const cappedRandom = Math.max(0, Math.min(0.999_999, random()));
+    const index = Math.floor(cappedRandom * options.length);
+    return options[index] ?? options[0] ?? kind;
+}
+export async function main() {
+    const dashboard = createDashboard({ title: "Agent Output", statsTitle: "Stats" });
+    const stopDemo = startDashboardDemo(dashboard);
+    let shutDown = false;
+    const shutdown = (exitCode) => {
+        if (shutDown) {
+            return;
+        }
+        shutDown = true;
+        stopDemo();
+        dashboard.destroy();
+        if (exitCode !== undefined) {
+            process.exit(exitCode);
+        }
+    };
+    dashboard.onCommand((command) => {
+        if (command === "quit") {
+            shutdown(0);
+        }
+    });
+    process.once("SIGINT", () => {
+        shutdown(0);
+    });
+    process.once("SIGTERM", () => {
+        shutdown(0);
+    });
+    dashboard.start();
+}
+const entry = process.argv[1];
+const isMain = typeof entry === "string" && path.resolve(entry) === fileURLToPath(import.meta.url);
+if (isMain) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    });
+}

package/node_modules/toolcraft-design/dist/dashboard/index.d.ts

@@ -0,0 +1,8 @@
+export { createDashboard } from "./dashboard.js";
+export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
+export type { Dashboard, DashboardOptions } from "./dashboard.js";
+export { renderDashboardSnapshot } from "./snapshot.js";
+export type { SnapshotOptions } from "./snapshot.js";
+export type { OutputItem, OutputItemKind, DashboardStats, Command, DashboardState } from "./types.js";
+export { defaultHints } from "./components/footer.js";
+export type { FooterHint } from "./components/footer.js";

package/node_modules/toolcraft-design/dist/dashboard/index.js

@@ -0,0 +1,4 @@
+export { createDashboard } from "./dashboard.js";
+export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
+export { renderDashboardSnapshot } from "./snapshot.js";
+export { defaultHints } from "./components/footer.js";

package/node_modules/toolcraft-design/dist/dashboard/keymap.d.ts

@@ -0,0 +1,8 @@
+import type { KeypressEvent } from "./terminal.js";
+import type { Command } from "./types.js";
+export declare function createKeymap(overrides?: Partial<Record<Command, string[]>>): (event: KeypressEvent) => Command | undefined;
+export declare function createKeymap<TCommand extends string>(overrides: Partial<Record<TCommand, string[]>> | undefined, options: {
+    commands: readonly TCommand[];
+    defaultBindings: Record<TCommand, readonly string[]>;
+}): (event: KeypressEvent) => TCommand | undefined;
+export declare function canonicalizeBinding(binding: string): string | undefined;

package/node_modules/toolcraft-design/dist/dashboard/keymap.js

@@ -0,0 +1,233 @@
+const commands = ["forceQuit", "quit", "edit", "pause", "retry", "view-log"];
+const defaultBindings = {
+    forceQuit: ["Ctrl+C"],
+    quit: ["q"],
+    edit: ["e"],
+    pause: ["p"],
+    retry: ["r"],
+    "view-log": ["l"]
+};
+export function createKeymap(overrides, options) {
+    const resolvedCommands = options?.commands ?? commands;
+    const resolvedDefaults = options?.defaultBindings ?? defaultBindings;
+    const bindings = new Map();
+    const sequences = new Set();
+    let pendingSequence = "";
+    for (const command of resolvedCommands) {
+        const keys = overrides?.[command] ?? resolvedDefaults[command];
+        const commandBindings = keys
+            .map(parseBinding)
+            .filter((binding) => binding !== undefined);
+        for (const binding of commandBindings) {
+            if (binding.sequence !== undefined) {
+                sequences.add(binding.sequence);
+            }
+        }
+        bindings.set(command, commandBindings);
+    }
+    return (event) => {
+        for (const command of resolvedCommands) {
+            const commandBindings = bindings.get(command);
+            if (commandBindings?.some((binding) => matchesSingleKey(binding, event))) {
+                pendingSequence = "";
+                return command;
+            }
+        }
+        const sequenceCommand = resolveSequence(event);
+        if (sequenceCommand !== undefined) {
+            return sequenceCommand;
+        }
+        return undefined;
+    };
+    function resolveSequence(event) {
+        const token = eventToSequenceToken(event);
+        if (token === undefined) {
+            pendingSequence = "";
+            return undefined;
+        }
+        pendingSequence = `${pendingSequence}${token}`;
+        for (const command of resolvedCommands) {
+            const commandBindings = bindings.get(command);
+            if (commandBindings?.some((binding) => binding.sequence === pendingSequence)) {
+                pendingSequence = "";
+                return command;
+            }
+        }
+        if (hasSequencePrefix(sequences, pendingSequence)) {
+            return undefined;
+        }
+        pendingSequence = token;
+        if (hasSequencePrefix(sequences, pendingSequence)) {
+            return undefined;
+        }
+        pendingSequence = "";
+        return undefined;
+    }
+}
+export function canonicalizeBinding(binding) {
+    const parsed = parseBinding(binding);
+    if (parsed === undefined) {
+        return undefined;
+    }
+    const modifiers = [
+        parsed.ctrl ? "ctrl" : undefined,
+        parsed.meta ? "meta" : undefined,
+        parsed.shift ? "shift" : undefined
+    ].filter((modifier) => modifier !== undefined);
+    const key = parsed.name ?? parsed.ch;
+    if (parsed.sequence !== undefined) {
+        return parsed.sequence.toLowerCase();
+    }
+    return key === undefined ? undefined : [...modifiers, key.toLowerCase()].join("+");
+}
+function parseBinding(binding) {
+    const value = binding.trim();
+    if (value.length === 0) {
+        return undefined;
+    }
+    const parts = value.split("+").map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0) {
+        return undefined;
+    }
+    let ctrl = false;
+    let meta = false;
+    let shift = false;
+    const key = parts.at(-1);
+    if (key === undefined) {
+        return undefined;
+    }
+    for (const modifier of parts.slice(0, -1)) {
+        const normalized = modifier.toLowerCase();
+        if (normalized === "ctrl" || normalized === "control") {
+            ctrl = true;
+            continue;
+        }
+        if (normalized === "meta" || normalized === "alt") {
+            meta = true;
+            continue;
+        }
+        if (normalized === "shift") {
+            shift = true;
+            continue;
+        }
+    }
+    const normalizedKey = normalizeKeyName(key);
+    if (parts.length === 1 && isShiftedCharacter(normalizedKey)) {
+        shift = true;
+    }
+    if (normalizedKey.length === 1) {
+        return {
+            ch: normalizeBindingCharacter(normalizedKey, shift),
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    if (!ctrl &&
+        !meta &&
+        !shift &&
+        !isNamedKey(normalizedKey) &&
+        isPrintableSequence(normalizedKey)) {
+        return {
+            sequence: normalizedKey,
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    return {
+        name: normalizedKey.toLowerCase(),
+        ctrl,
+        meta,
+        shift
+    };
+}
+function matchesSingleKey(binding, event) {
+    if (binding.sequence !== undefined) {
+        return false;
+    }
+    if (binding.ctrl !== event.ctrl ||
+        binding.meta !== event.meta ||
+        binding.shift !== event.shift) {
+        return false;
+    }
+    if (binding.ch !== undefined) {
+        return event.ch === binding.ch || event.name === binding.ch.toLowerCase();
+    }
+    if (binding.name !== undefined) {
+        return event.name === binding.name;
+    }
+    return false;
+}
+function eventToSequenceToken(event) {
+    if (event.ctrl || event.meta || event.ch === undefined) {
+        return undefined;
+    }
+    return event.ch;
+}
+function hasSequencePrefix(sequences, prefix) {
+    for (const sequence of sequences) {
+        if (sequence.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isShiftedCharacter(value) {
+    return value.length === 1 && value.toLowerCase() !== value && value.toUpperCase() === value;
+}
+function normalizeBindingCharacter(value, shift) {
+    if (!shift || value.toLowerCase() === value.toUpperCase()) {
+        return value;
+    }
+    return value.toUpperCase();
+}
+function normalizeKeyName(value) {
+    if (value.toLowerCase() === "space") {
+        return " ";
+    }
+    if (value === "↑") {
+        return "up";
+    }
+    if (value === "↓") {
+        return "down";
+    }
+    if (value === "←") {
+        return "left";
+    }
+    if (value === "→") {
+        return "right";
+    }
+    return value;
+}
+function isNamedKey(value) {
+    return namedKeys.has(value.toLowerCase());
+}
+function isPrintableSequence(value) {
+    if (Array.from(value).length <= 1) {
+        return false;
+    }
+    for (const char of value) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint === undefined || codePoint < 0x20 || codePoint === 0x7f) {
+            return false;
+        }
+    }
+    return true;
+}
+const namedKeys = new Set([
+    "backspace",
+    "delete",
+    "down",
+    "end",
+    "enter",
+    "escape",
+    "home",
+    "left",
+    "pagedown",
+    "pageup",
+    "return",
+    "right",
+    "tab",
+    "up"
+]);

package/node_modules/toolcraft-design/dist/dashboard/layout.d.ts

@@ -0,0 +1,25 @@
+import type { Rect } from "./types.js";
+export type LayoutOptions = {
+    totalWidth: number;
+    totalHeight: number;
+    rightPaneWidth?: number;
+    footerHeight?: number;
+    borderWidth?: number;
+};
+export type DashboardLayout = {
+    outerBorder: Rect;
+    leftPane: Rect;
+    rightPane: Rect;
+    divider: {
+        x: number;
+        top: number;
+        bottom: number;
+    };
+    footer: Rect;
+    footerDivider: {
+        y: number;
+        left: number;
+        right: number;
+    };
+};
+export declare function computeDashboardLayout(opts: LayoutOptions): DashboardLayout;

package/node_modules/toolcraft-design/dist/dashboard/layout.js

@@ -0,0 +1,79 @@
+const DEFAULT_RIGHT_PANE_WIDTH = 25;
+const DEFAULT_FOOTER_HEIGHT = 1;
+const DEFAULT_BORDER_WIDTH = 1;
+const MIN_LEFT_PANE_WIDTH = 20;
+export function computeDashboardLayout(opts) {
+    const totalWidth = normalizeSize(opts.totalWidth);
+    const totalHeight = normalizeSize(opts.totalHeight);
+    const borderWidth = normalizeSize(opts.borderWidth ?? DEFAULT_BORDER_WIDTH);
+    const footerHeight = normalizeSize(opts.footerHeight ?? DEFAULT_FOOTER_HEIGHT);
+    const requestedRightPaneWidth = normalizeSize(opts.rightPaneWidth ?? DEFAULT_RIGHT_PANE_WIDTH);
+    const maxX = Math.max(0, totalWidth - 1);
+    const maxY = Math.max(0, totalHeight - 1);
+    const outerBorder = { x: 0, y: 0, width: totalWidth, height: totalHeight };
+    const innerWidth = Math.max(0, totalWidth - (borderWidth * 2));
+    const innerHeight = Math.max(0, totalHeight - (borderWidth * 2));
+    const innerX = clampCoordinate(borderWidth, maxX);
+    const innerY = clampCoordinate(borderWidth, maxY);
+    const dividerWidth = innerWidth > 0 ? 1 : 0;
+    const availablePaneWidth = Math.max(0, innerWidth - dividerWidth);
+    const leftPaneWidth = computeLeftPaneWidth(availablePaneWidth, requestedRightPaneWidth);
+    const rightPaneWidth = Math.max(0, availablePaneWidth - leftPaneWidth);
+    const actualFooterHeight = Math.min(footerHeight, innerHeight);
+    const footerDividerHeight = innerHeight > actualFooterHeight ? 1 : 0;
+    const contentHeight = Math.max(0, innerHeight - actualFooterHeight - footerDividerHeight);
+    const leftPane = {
+        x: innerX,
+        y: innerY,
+        width: leftPaneWidth,
+        height: contentHeight
+    };
+    const dividerX = clampCoordinate(leftPane.x + leftPane.width, maxX);
+    const rightPane = {
+        x: clampCoordinate(dividerX + dividerWidth, maxX),
+        y: innerY,
+        width: rightPaneWidth,
+        height: contentHeight
+    };
+    const dividerTop = innerY;
+    const dividerBottom = clampCoordinate(dividerTop + Math.max(contentHeight - 1, 0), maxY);
+    const footerDividerY = clampCoordinate(innerY + contentHeight, maxY);
+    const footerY = clampCoordinate(footerDividerY + footerDividerHeight, maxY);
+    const footerDividerLeft = innerX;
+    const footerDividerRight = clampCoordinate(Math.max(innerX, totalWidth - borderWidth - 1), maxX);
+    return {
+        outerBorder,
+        leftPane,
+        rightPane,
+        divider: {
+            x: dividerX,
+            top: dividerTop,
+            bottom: dividerBottom
+        },
+        footer: {
+            x: innerX,
+            y: footerY,
+            width: innerWidth,
+            height: actualFooterHeight
+        },
+        footerDivider: {
+            y: footerDividerY,
+            left: footerDividerLeft,
+            right: footerDividerRight
+        }
+    };
+}
+function computeLeftPaneWidth(availablePaneWidth, requestedRightPaneWidth) {
+    if (availablePaneWidth <= 0) {
+        return 0;
+    }
+    const maxRightPaneWidth = Math.max(0, availablePaneWidth - MIN_LEFT_PANE_WIDTH);
+    const rightPaneWidth = Math.min(requestedRightPaneWidth, maxRightPaneWidth);
+    return Math.max(0, availablePaneWidth - rightPaneWidth);
+}
+function normalizeSize(value) {
+    return Math.max(0, Math.floor(value));
+}
+function clampCoordinate(value, max) {
+    return Math.max(0, Math.min(value, max));
+}

package/node_modules/toolcraft-design/dist/dashboard/should-use-dashboard.d.ts

@@ -0,0 +1,10 @@
+type DashboardIo = {
+    stdin: {
+        isTTY?: boolean | undefined;
+    };
+    stdout: {
+        isTTY?: boolean | undefined;
+    };
+};
+export declare function shouldUseInteractiveDashboard(enabled: boolean | undefined, io?: DashboardIo): boolean;
+export {};