toolcraft 0.0.1

package/node_modules/@poe-code/design-system/dist/dashboard/components/stats-pane.js

@@ -0,0 +1,121 @@
+import { getTheme } from "../../internal/theme-detect.js";
+import { light } from "../../tokens/colors.js";
+export function renderStatsPane(buffer, rect, stats) {
+    buffer.clearRect(rect);
+    if (rect.width <= 0 || rect.height <= 0) {
+        return;
+    }
+    const lines = statsToLines(stats, rect.width);
+    for (let row = 0; row < rect.height; row += 1) {
+        const line = lines[row];
+        if (line === undefined) {
+            continue;
+        }
+        if (line.prefix.length > 0) {
+            buffer.putInRect(rect, row, line.prefix, line.prefixStyle);
+        }
+        if (line.text.length === 0) {
+            continue;
+        }
+        const textStart = Math.min(line.prefix.length, rect.width);
+        buffer.putInRect({ x: rect.x + textStart, y: rect.y + row, width: rect.width - textStart, height: 1 }, 0, line.text, line.style);
+    }
+}
+export function formatElapsed(ms) {
+    const safeMs = Number.isFinite(ms) ? ms : 0;
+    const totalSeconds = Math.max(0, Math.floor(safeMs / 1_000));
+    const hours = Math.floor(totalSeconds / 3_600);
+    const minutes = Math.floor((totalSeconds % 3_600) / 60);
+    const seconds = totalSeconds % 60;
+    return [hours, minutes, seconds].map((value) => value.toString().padStart(2, "0")).join(":");
+}
+export function formatNumber(n) {
+    return new Intl.NumberFormat("en-US").format(n);
+}
+export function statsToLines(stats, width) {
+    if (width <= 0) {
+        return [];
+    }
+    const mutedStyle = getToneStyle("muted");
+    const totalTokens = stats.tokensIn + stats.tokensOut;
+    const iterationsLabel = stats.iterationsLabel ?? "Iteration";
+    const lines = [
+        createKeyValueLine("Status", formatStatus(stats.status), width, getStatusStyle(stats.status)),
+        createKeyValueLine(iterationsLabel, formatNumber(stats.iterations), width),
+        createKeyValueLine("Elapsed", formatElapsed(stats.elapsedMs), width),
+        createBlankLine(),
+        createKeyValueLine("Tokens In", formatNumber(stats.tokensIn), width),
+        createKeyValueLine("Tokens Out", formatNumber(stats.tokensOut), width),
+        createKeyValueLine("Total", formatNumber(totalTokens), width)
+    ];
+    if (stats.currentAction !== undefined) {
+        lines.push(createBlankLine(), {
+            prefix: clipText("Current:", width),
+            prefixStyle: {},
+            style: {},
+            text: ""
+        }, {
+            prefix: width > 0 ? clipText("  ", width) : "",
+            prefixStyle: mutedStyle,
+            style: mutedStyle,
+            text: clipText(stats.currentAction, Math.max(width - 2, 0))
+        });
+    }
+    return lines;
+}
+function createBlankLine() {
+    return {
+        prefix: "",
+        prefixStyle: {},
+        style: {},
+        text: ""
+    };
+}
+function createKeyValueLine(label, value, width, valueStyle = {}) {
+    const clippedValue = clipText(value, width);
+    const availableBeforeValue = Math.max(width - clippedValue.length, 0);
+    const clippedLabel = clipText(label, Math.max(availableBeforeValue - 1, 0));
+    return {
+        prefix: clippedLabel + " ".repeat(Math.max(availableBeforeValue - clippedLabel.length, 0)),
+        prefixStyle: {},
+        style: valueStyle,
+        text: clippedValue
+    };
+}
+function clipText(value, width) {
+    return width <= 0 ? "" : value.slice(0, width);
+}
+function formatStatus(status) {
+    return `${status.slice(0, 1).toUpperCase()}${status.slice(1)}`;
+}
+function getStatusStyle(status) {
+    if (status === "running") {
+        return getToneStyle("info");
+    }
+    if (status === "paused") {
+        return getToneStyle("warning");
+    }
+    if (status === "error") {
+        return getToneStyle("error");
+    }
+    if (status === "done") {
+        return getToneStyle("success");
+    }
+    return getToneStyle("muted");
+}
+function getToneStyle(tone) {
+    const isLightTheme = getTheme() === light;
+    if (tone === "muted") {
+        return isLightTheme ? { fg: "#666666" } : { dim: true };
+    }
+    if (tone === "info") {
+        return isLightTheme ? { fg: "#a200ff" } : { fg: "magenta" };
+    }
+    if (tone === "warning") {
+        return isLightTheme ? { fg: "#cc6600" } : { fg: "yellow" };
+    }
+    if (tone === "error") {
+        return isLightTheme ? { fg: "#cc0000" } : { fg: "red" };
+    }
+    return isLightTheme ? { fg: "#008800" } : { fg: "green" };
+}

package/node_modules/@poe-code/design-system/dist/dashboard/dashboard.d.ts

@@ -0,0 +1,20 @@
+import type { FooterHint } from "./components/footer.js";
+import type { Command, DashboardStats, OutputItem } from "./types.js";
+export type DashboardOptions = {
+    title?: string;
+    statsTitle?: string;
+    keymap?: Partial<Record<Command, string[]>>;
+    rightPaneWidth?: number;
+    hints?: FooterHint[];
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+};
+export type Dashboard = {
+    start(): void;
+    stop(): void;
+    appendOutput(item: OutputItem): void;
+    updateStats(stats: Partial<DashboardStats>): void;
+    onCommand(handler: (cmd: Command) => void): void;
+    destroy(): void;
+};
+export declare function createDashboard(opts?: DashboardOptions): Dashboard;

package/node_modules/@poe-code/design-system/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/@poe-code/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/node_modules/@poe-code/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/node_modules/@poe-code/design-system/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/@poe-code/design-system/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/@poe-code/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/node_modules/@poe-code/design-system/dist/dashboard/keymap.js

@@ -0,0 +1,99 @@
+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) {
+    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/node_modules/@poe-code/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/node_modules/@poe-code/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));
+}