poe-code 3.0.178 → 3.0.180

package/packages/design-system/dist/dashboard/dashboard.js

@@ -0,0 +1,187 @@
+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 currentLayout = computeDashboardLayout({
+        totalWidth: 0,
+        totalHeight: 0,
+        rightPaneWidth
+    });
+    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.hideCursor();
+        render();
+        const activeStore = getStore();
+        unsubscribeStore = activeStore.onChange(() => {
+            render();
+        });
+        unsubscribeKeypress = driver.onKeypress((event) => {
+            const command = resolveCommand(event);
+            if (command === undefined) {
+                return;
+            }
+            if (isScrollCommand(command)) {
+                activeStore.dispatch(command, currentLayout.leftPane.height);
+                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();
+        currentLayout = computeDashboardLayout({
+            totalWidth: cols,
+            totalHeight: rows,
+            rightPaneWidth
+        });
+        const nextBuffer = new ScreenBuffer(cols, rows);
+        const state = getStore().getState();
+        renderBorder(nextBuffer, currentLayout, {
+            leftTitle: title,
+            rightTitle: statsTitle,
+            style: { dim: true }
+        });
+        renderOutputPane(nextBuffer, currentLayout.leftPane, {
+            items: state.output,
+            scrollOffset: state.outputScroll,
+            autoFollow: state.autoFollow
+        });
+        renderStatsPane(nextBuffer, currentLayout.rightPane, state.stats);
+        renderFooter(nextBuffer, currentLayout.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";
+}
+function isScrollCommand(command) {
+    return command === "scrollUp"
+        || command === "scrollDown"
+        || command === "pageUp"
+        || command === "pageDown"
+        || command === "scrollToTop"
+        || command === "scrollToBottom";
+}

package/packages/design-system/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/packages/design-system/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/packages/design-system/dist/dashboard/index.d.ts

@@ -0,0 +1,7 @@
+export { createDashboard } from "./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/packages/design-system/dist/dashboard/index.js

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

package/packages/design-system/dist/dashboard/keymap.d.ts

@@ -0,0 +1,3 @@
+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;

package/packages/design-system/dist/dashboard/keymap.js

@@ -0,0 +1,114 @@
+const commands = [
+    "quit",
+    "edit",
+    "pause",
+    "retry",
+    "scrollUp",
+    "scrollDown",
+    "pageUp",
+    "pageDown",
+    "scrollToTop",
+    "scrollToBottom"
+];
+const defaultBindings = {
+    quit: ["q", "Ctrl+C"],
+    edit: ["e"],
+    pause: ["p"],
+    retry: ["r"],
+    scrollUp: ["up", "k"],
+    scrollDown: ["down", "j"],
+    pageUp: ["pageup"],
+    pageDown: ["pagedown"],
+    scrollToTop: ["home", "g"],
+    scrollToBottom: ["end", "G", "f", "F"]
+};
+export function createKeymap(overrides) {
+    const bindings = new Map();
+    for (const command of commands) {
+        const keys = overrides?.[command] ?? defaultBindings[command];
+        bindings.set(command, keys
+            .map(parseBinding)
+            .filter((binding) => binding !== undefined));
+    }
+    return (event) => {
+        for (const command of commands) {
+            const commandBindings = bindings.get(command);
+            if (commandBindings?.some((binding) => matches(binding, event))) {
+                return command;
+            }
+        }
+        return undefined;
+    };
+}
+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;
+        }
+    }
+    if (parts.length === 1 && isShiftedCharacter(key)) {
+        shift = true;
+    }
+    if (key.length === 1) {
+        return {
+            ch: normalizeBindingCharacter(key, shift),
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    return {
+        name: key.toLowerCase(),
+        ctrl,
+        meta,
+        shift
+    };
+}
+function matches(binding, event) {
+    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 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();
+}

package/packages/design-system/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/packages/design-system/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/packages/design-system/dist/dashboard/snapshot.d.ts

@@ -0,0 +1,10 @@
+import type { DashboardStats, OutputItem } from "./types.js";
+export type SnapshotOptions = {
+    width?: number;
+    height?: number;
+    title?: string;
+    statsTitle?: string;
+    items?: OutputItem[];
+    stats?: DashboardStats;
+};
+export declare function renderDashboardSnapshot(opts?: SnapshotOptions): string;

package/packages/design-system/dist/dashboard/snapshot.js

@@ -0,0 +1,72 @@
+import { ScreenBuffer, cellToAnsi } 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 { computeDashboardLayout } from "./layout.js";
+const SNAPSHOT_WIDTH = 80;
+const SNAPSHOT_HEIGHT = 20;
+const RIGHT_PANE_WIDTH = 25;
+export function renderDashboardSnapshot(opts = {}) {
+    const width = opts.width ?? SNAPSHOT_WIDTH;
+    const height = opts.height ?? SNAPSHOT_HEIGHT;
+    const title = opts.title ?? "Agent Output";
+    const statsTitle = opts.statsTitle ?? "Stats";
+    const items = opts.items ?? defaultItems();
+    const stats = opts.stats ?? defaultStats();
+    const layout = computeDashboardLayout({
+        totalWidth: width,
+        totalHeight: height,
+        rightPaneWidth: RIGHT_PANE_WIDTH
+    });
+    const buffer = new ScreenBuffer(width, height);
+    renderBorder(buffer, layout, {
+        leftTitle: title,
+        rightTitle: statsTitle,
+        style: { dim: true }
+    });
+    renderOutputPane(buffer, layout.leftPane, {
+        items,
+        scrollOffset: 0,
+        autoFollow: true
+    });
+    renderStatsPane(buffer, layout.rightPane, stats);
+    renderFooter(buffer, layout.footer, defaultHints());
+    return bufferToAnsi(buffer);
+}
+function bufferToAnsi(buffer) {
+    const lines = [];
+    for (let y = 0; y < buffer.height; y += 1) {
+        let line = "";
+        for (let x = 0; x < buffer.width; x += 1) {
+            line += cellToAnsi(buffer.get(x, y));
+        }
+        lines.push(line);
+    }
+    return lines.join("\n");
+}
+function defaultItems() {
+    const now = Date.now();
+    return [
+        { kind: "info", text: "Analyzing repository state", ts: now },
+        { kind: "tool", text: "Running npm test -- --runInBand", ts: now + 500 },
+        { kind: "success", text: "Generated provider config", ts: now + 1000 },
+        { kind: "status", text: "Streaming model response", ts: now + 1500 },
+        { kind: "info", text: "Inspecting agent configuration", ts: now + 2000 },
+        { kind: "tool", text: "Executing npm run lint:types", ts: now + 2500 },
+        { kind: "error", text: "Retrying transient network request", ts: now + 3000 },
+        { kind: "success", text: "Updated dashboard layout", ts: now + 3500 },
+        { kind: "info", text: "Collecting recent command output", ts: now + 4000 },
+        { kind: "status", text: "Waiting for follow-up task", ts: now + 4500 }
+    ];
+}
+function defaultStats() {
+    return {
+        status: "running",
+        iterations: 5,
+        tokensIn: 685,
+        tokensOut: 445,
+        elapsedMs: 5000,
+        currentAction: "Executing tool call"
+    };
+}

package/packages/design-system/dist/dashboard/store.d.ts

@@ -0,0 +1,9 @@
+import type { Command, DashboardState, DashboardStats, OutputItem } from "./types.js";
+export type DashboardStore = {
+    getState(): DashboardState;
+    appendOutput(item: OutputItem): void;
+    updateStats(partial: Partial<DashboardStats>): void;
+    dispatch(command: Command, paneHeight: number): void;
+    onChange(handler: () => void): () => void;
+};
+export declare function createStore(): DashboardStore;