4runr-os 2.1.4 → 2.1.5

package/dist/ui/v4/engine/renderFrame.js

@@ -1,653 +0,0 @@
-/**
- * V4 Render Engine - Percentage-Based (neo-blessed optimized)
- *
- * ⚠️ FROZEN: This file is part of V4 TUI which is FROZEN.
- * DO NOT MODIFY. Development moved to V5.
- * See FROZEN.md in v4 directory.
- *
- * Single-pass rendering with atomic teardown + rebuild.
- * Uses percentage-based layout specs (no pixel math).
- *
- * Rules:
- * - No partial renders
- * - Always teardown old widgets before creating new ones
- * - Hard clear terminal buffer before render
- * - Single render() call at end
- * - Always restore focus to command input
- * - Use percentage strings for left/width (neo-blessed handles it)
- */
-import blessed from 'neo-blessed';
-import { getSafeViewport } from './safeViewport.js';
-import { getBorderChars } from './terminalProfile.js';
-const blessedLib = blessed;
-/**
- * Step 1: Debug helper - uses tuiDebug (stderr/file, gated by TUI_DEBUG=1)
- * UI owns stdout. Logs go to stderr or file. No exceptions.
- */
-import { tuiDebug as dbg, tuiError } from '../runtime/logger.js';
-/**
- * Hard clear terminal buffer
- */
-function hardClearTerminal(screen) {
-    // CRITICAL: Don't clear in CloudShell/browser terminals - it causes black screens
-    // Only clear in normal terminals that handle it well
-    const term = process.env.TERM || '';
-    const isBrowserTerminal = /cloudshell|web|browser/i.test(term) ||
-        process.env.SSH_CONNECTION !== undefined ||
-        process.env.AWS_EXECUTION_ENV !== undefined;
-    // Skip clearing for browser terminals - they don't handle it well and cause black screens
-    if (isBrowserTerminal) {
-        return;
-    }
-    const program = screen.program;
-    if (program) {
-        try {
-            if (typeof program.clear === 'function') {
-                program.clear();
-            }
-            if (typeof program.home === 'function') {
-                program.home();
-            }
-            if (typeof program.eraseInDisplay === 'function') {
-                program.eraseInDisplay('all');
-            }
-            if (typeof program.flush === 'function') {
-                program.flush();
-            }
-        }
-        catch {
-            // Ignore clear errors (terminal might not support all operations)
-        }
-    }
-}
-/**
- * Create a panel widget using pixel-based layout
- *
- * Step 1: All panels are children of viewportBox (hard clipping)
- * Step 2: Integer widths only (no percentages for outer edges)
- *
- * @param parent - Parent container (viewportBox or screen)
- */
-function createPanel(parent, name, colSpec, top, height, title, visible = true, useAsciiBorders = false // D) Use ASCII borders in safe mode
-) {
-    if (!visible || colSpec.width === 0) {
-        // Create invisible/collapsed box
-        return blessedLib.box({
-            top: 0,
-            left: -100, // Off-screen
-            width: 1,
-            height: 1,
-            content: '',
-            border: false,
-            focusable: false,
-        });
-    }
-    // Get safe viewport to check bounds (get screen from parent)
-    const screen = parent.screen || parent;
-    const viewport = getSafeViewport(screen);
-    const safeCols = viewport.cols;
-    // Step 2: Integer widths only (already calculated in layout)
-    // Calculate if this is the rightmost panel (right column)
-    // CRITICAL: Rightmost panels have no right border, so we check if right edge is near safeCols
-    // A panel is rightmost if its right edge (without borders) is >= safeCols - 2
-    const rightEdgeWithoutBorder = colSpec.left + colSpec.width;
-    const isRightmost = rightEdgeWithoutBorder >= safeCols - 2; // Account for border padding
-    // D) Get border chars based on safe mode
-    // For rightmost panels, use custom border that excludes right edge
-    const borderChars = useAsciiBorders ? getBorderChars(true) : undefined;
-    const borderConfig = isRightmost
-        ? {
-            type: 'line',
-            right: false, // No right border for rightmost panels
-            ...(borderChars ? { chars: borderChars } : {}),
-        }
-        : {
-            type: 'line',
-            ...(borderChars ? { chars: borderChars } : {}),
-        };
-    // Step 2: Use integer width (no percentages, no right anchoring)
-    // DEBUG: Log panel creation and validate dimensions
-    const debugInfo = `Panel ${name}: x=${colSpec.left} w=${colSpec.width} h=${height} top=${top}`;
-    // CRITICAL: Validate dimensions before creating widget
-    // A) Log to stderr only (never stdout)
-    if (colSpec.width <= 0 || height <= 0) {
-        dbg(`ERROR: Panel ${name} has invalid dimensions: w=${colSpec.width} h=${height}`);
-        // Return invisible panel instead of crashing
-        return blessedLib.box({
-            top: -100,
-            left: -100,
-            width: 1,
-            height: 1,
-            content: '',
-            border: false,
-            focusable: false,
-        });
-    }
-    const box = blessedLib.box({
-        top,
-        left: colSpec.left,
-        width: colSpec.width, // Step 2: Integer width (sum = safeCols exactly)
-        height,
-        border: borderConfig,
-        style: {
-            bg: 'blue', // TEMPORARY: Use blue for visibility debugging
-            fg: 'white', // CRITICAL: Set foreground color
-            border: {
-                fg: 'cyan',
-                bg: 'blue',
-            },
-        },
-        content: ` ${title} `, // Panel title with spaces for visibility
-        tags: true,
-        focusable: false,
-        alwaysScroll: false,
-        scrollable: false,
-        clickable: false,
-        input: false,
-        keys: false,
-        mouse: false,
-    });
-    // CRITICAL: Append to parent AFTER creation (blessed standard way)
-    parent.append(box);
-    // Ensure box has proper dimensions and position
-    box.lpos = {
-        xi: colSpec.left,
-        yi: top,
-        xl: colSpec.left + colSpec.width,
-        yl: top + height,
-    };
-    // Step 1: Append to parent (already set in constructor, but ensure it's attached)
-    if (!box.parent) {
-        parent.append(box);
-    }
-    box.__panelName = name;
-    box.__debugInfo = debugInfo;
-    // CRITICAL: Show the widget immediately
-    try {
-        if (box.show) {
-            box.show();
-        }
-    }
-    catch {
-        // Ignore
-    }
-    // Step 1: Log to stderr for debugging (uses tuiDebug - gated by TUI_DEBUG)
-    if (process.env.DEBUG_V4 === '1' || process.env.TUI_DEBUG) {
-        const rightEdge = colSpec.left + colSpec.width + (isRightmost ? 1 : 2);
-        dbg(`Created ${name}: x=${colSpec.left} w=${colSpec.width} h=${height} rightEdge=${rightEdge} safeCols=${safeCols}`);
-        if (rightEdge >= safeCols) {
-            tuiError(`${name} OVERFLOW: rightEdge=${rightEdge} >= safeCols=${safeCols}`);
-        }
-    }
-    // Note: visible/hidden are read-only computed properties in blessed
-    return box;
-}
-/**
- * Create watermark widget (bottom-right corner, like a footer)
- *
- * Step 1: Child of viewportBox
- */
-/**
- * Create watermark widget (Deliverable 3: Visible proof TUI is alive)
- * Shows "V4 LIVE" at top-left + optional heartbeat counter when TUI_DEBUG=1
- * Uses ONLY ASCII characters to prevent symbol corruption
- */
-function createWatermark(parent, rows, safeCols) {
-    const blessedLib = blessed;
-    // Deliverable 3: Visible proof TUI is alive - "V4 LIVE" watermark at top-left
-    // Use ONLY ASCII characters - no Unicode/box-drawing chars that could corrupt
-    const watermarkText = process.env.TUI_DEBUG === '1' || process.env.DEBUG_V4 === '1'
-        ? 'V4 LIVE [*]' // Show heartbeat indicator in debug mode (ASCII only)
-        : 'V4 LIVE';
-    // Position at top-left (was bottom-right, changed to top-left for visibility)
-    const box = blessedLib.box({
-        parent: parent, // Explicitly set parent
-        top: 0, // Top of screen
-        left: 0, // Left of screen
-        width: watermarkText.length + 2,
-        height: 1,
-        content: watermarkText,
-        style: {
-            fg: 'blue',
-            bg: 'black',
-        },
-        tags: true,
-        focusable: false,
-        border: false,
-    });
-    // Deliverable 3: Heartbeat counter (update every 1s when debug enabled)
-    if (process.env.TUI_DEBUG === '1' || process.env.DEBUG_V4 === '1') {
-        let heartbeatCount = 0;
-        const heartbeatInterval = setInterval(() => {
-            heartbeatCount++;
-            const heartbeatText = `V4 LIVE [${heartbeatCount}]`;
-            try {
-                box.setContent(heartbeatText);
-                // Get screen from parent
-                const screen = parent.screen || parent;
-                if (screen && typeof screen.render === 'function') {
-                    screen.render();
-                }
-            }
-            catch {
-                // Ignore errors (screen might be destroyed)
-                clearInterval(heartbeatInterval);
-            }
-        }, 1000); // Update every 1 second
-        // Store interval on box so it can be cleared on destroy
-        box.__heartbeatInterval = heartbeatInterval;
-    }
-    // Step 1: Append to parent (screen or viewportBox)
-    parent.append(box);
-    box.__panelName = 'watermark';
-    return box;
-}
-/**
- * Create command line widget using pixel-based layout
- *
- * CRITICAL: Use Box instead of Textbox for broken terminals
- * Textbox input encoding is broken in browser terminals (CloudShell/EC2 Instance Connect)
- * We'll handle input manually via screen.key() events
- */
-function createCommandLine(parent, top, height, safeCols, initialValue = '') {
-    const PROMPT = '4runr> ';
-    // HARD INVARIANT: Command line must satisfy x + w + borderPad < safeCols (strictly less)
-    // Command line: x=0, has left border (+1), no right border
-    // So: 0 + width + 1 < safeCols (strictly less to prevent scrollbar)
-    // Therefore: width <= safeCols - 2 (extra -1 to ensure rightEdge < safeCols)
-    const cmdBox = blessedLib.box({
-        top,
-        left: 0,
-        width: safeCols - 2, // Ensures rightEdge = 0 + (safeCols-2) + 1 = safeCols - 1 (strictly within bounds)
-        height,
-        border: {
-            type: 'line',
-            right: false, // NO RIGHT BORDER - prevents overflow
-            fg: 'yellow', // TEMPORARY: Yellow border for visibility
-        },
-        style: {
-            bg: 'blue', // TEMPORARY: Blue background for visibility
-            fg: 'white',
-            border: {
-                fg: 'yellow',
-                bg: 'blue',
-            },
-        },
-        content: PROMPT + initialValue,
-        tags: true,
-        focusable: true, // Can receive focus
-        keys: true, // Can receive key events
-        mouse: false,
-    });
-    // Step 1: Append to parent (screen or viewportBox)
-    parent.append(cmdBox);
-    cmdBox.__panelName = 'COMMAND_LINE';
-    cmdBox.__debugInfo = `CMD: left=0 width=${safeCols - 2} rightEdge=${0 + (safeCols - 2) + 1} safeCols=${safeCols}`;
-    cmdBox.__prompt = PROMPT;
-    cmdBox.__value = initialValue; // Store current input value
-    return cmdBox;
-}
-/**
- * Teardown all widgets from screen
- * Also clears any heartbeat intervals
- */
-function teardownWidgets(screen, widgets) {
-    if (!widgets) {
-        return;
-    }
-    const widgetList = [
-        widgets.posture,
-        widgets.resources,
-        widgets.assets,
-        widgets.operations,
-        widgets.network,
-        widgets.capabilities,
-        widgets.commandLine,
-        widgets.watermark,
-    ];
-    for (const widget of widgetList) {
-        try {
-            if (widget) {
-                const w = widget;
-                // Clear heartbeat intervals if any (Deliverable 3)
-                const heartbeatInterval = w.__heartbeatInterval;
-                if (heartbeatInterval) {
-                    clearInterval(heartbeatInterval);
-                }
-                if (!w.detached) {
-                    if (typeof w.detach === 'function') {
-                        w.detach();
-                    }
-                    if (typeof w.destroy === 'function') {
-                        w.destroy();
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Ignore errors during teardown
-        }
-    }
-}
-/**
- * Create widgets for a given layout spec (extracted for reuse)
- */
-function createWidgetsForSpec(screen, viewportBox, columns, rows, mode, viewport, commandInputValue, useAsciiBorders = false // D) Use ASCII borders in safe mode
-) {
-    const mainHeight = rows.mainBottom - rows.mainTop;
-    if (mode === 'normal') {
-        // Normal mode: 3 columns with stacked panels
-        const leftPanelHeight = Math.floor(mainHeight / 3);
-        const rightPanelHeight = Math.floor(mainHeight / 2);
-        const rightPanelHeight2 = mainHeight - rightPanelHeight;
-        const widgets = {
-            viewport: viewportBox,
-            posture: createPanel(viewportBox, 'posture', columns.left, rows.mainTop, leftPanelHeight, 'POSTURE', true, useAsciiBorders),
-            resources: createPanel(viewportBox, 'resources', columns.left, rows.mainTop + leftPanelHeight, leftPanelHeight, 'RESOURCES', true, useAsciiBorders),
-            assets: createPanel(viewportBox, 'assets', columns.left, rows.mainTop + leftPanelHeight * 2, leftPanelHeight, 'ASSETS', true, useAsciiBorders),
-            operations: createPanel(viewportBox, 'operations', columns.center, rows.mainTop, mainHeight, 'OPERATIONS', true, useAsciiBorders),
-            network: createPanel(viewportBox, 'network', columns.right, rows.mainTop, rightPanelHeight, 'NETWORK', true, useAsciiBorders),
-            capabilities: createPanel(viewportBox, 'capabilities', columns.right, rows.mainTop + rightPanelHeight, rightPanelHeight2, 'CAPABILITIES', true, useAsciiBorders),
-            commandLine: createCommandLine(viewportBox, rows.cmdTop, rows.cmdHeight, viewport.cols, commandInputValue),
-            watermark: createWatermark(viewportBox, viewport.rows, viewport.cols),
-        };
-        // A) Log to stderr only (never stdout)
-        dbg(`Rendering ${mode} mode: ${screen.children.length} children before render`);
-        // CRITICAL: Force all widgets to be visible before render
-        for (const widget of Object.values(widgets)) {
-            if (widget && typeof widget.setContent === 'function') {
-                // Ensure widget has content
-                const currentContent = widget.content || '';
-                if (!currentContent || currentContent.trim() === '') {
-                    widget.setContent(' '); // At least one space
-                }
-            }
-            // Force visibility
-            if (widget) {
-                // Note: visible/hidden are read-only computed properties in blessed
-            }
-        }
-        // CRITICAL: Render once - multiple renders can cause black screens
-        screen.render();
-        // A) Log to stderr only (never stdout)
-        dbg(`Render complete. Screen children: ${screen.children.length}`);
-        // Log widget visibility state
-        for (const [name, widget] of Object.entries(widgets)) {
-            if (widget) {
-                const hidden = widget.hidden;
-                const visible = widget.visible;
-                const content = widget.content || '';
-                dbg(`Widget ${name}: hidden=${hidden} visible=${visible} contentLen=${content.length}`);
-            }
-        }
-        widgets.commandLine.focus();
-        screen.focused = widgets.commandLine;
-        return widgets;
-    }
-    else {
-        // Narrow mode
-        const widgets = {
-            viewport: viewportBox,
-            posture: createPanel(viewportBox, 'posture', columns.left, 0, 1, 'UNAVAILABLE (narrow mode)', false, useAsciiBorders),
-            resources: createPanel(viewportBox, 'resources', columns.left, 0, 1, 'UNAVAILABLE (narrow mode)', false, useAsciiBorders),
-            assets: createPanel(viewportBox, 'assets', columns.left, 0, 1, 'UNAVAILABLE (narrow mode)', false, useAsciiBorders),
-            operations: createPanel(viewportBox, 'operations', columns.center, rows.mainTop, mainHeight, 'OPERATIONS', true, useAsciiBorders),
-            network: createPanel(viewportBox, 'network', columns.right, 0, 1, 'UNAVAILABLE (narrow mode)', false, useAsciiBorders),
-            capabilities: createPanel(viewportBox, 'capabilities', columns.right, 0, 1, 'UNAVAILABLE (narrow mode)', false, useAsciiBorders),
-            commandLine: createCommandLine(viewportBox, rows.cmdTop, rows.cmdHeight, viewport.cols, commandInputValue),
-            watermark: createWatermark(viewportBox, viewport.rows, viewport.cols),
-        };
-        // A) Log to stderr only (never stdout)
-        dbg(`Rendering ${mode} mode: ${screen.children.length} children before render`);
-        // CRITICAL: Force all widgets to be visible before render
-        for (const widget of Object.values(widgets)) {
-            if (widget && typeof widget.setContent === 'function') {
-                // Ensure widget has content
-                const currentContent = widget.content || '';
-                if (!currentContent || currentContent.trim() === '') {
-                    widget.setContent(' '); // At least one space
-                }
-            }
-            // Force visibility
-            if (widget) {
-                // Note: visible/hidden are read-only computed properties in blessed
-            }
-        }
-        // CRITICAL: Render once - multiple renders can cause black screens
-        screen.render();
-        // A) Log to stderr only (never stdout)
-        dbg(`Render complete. Screen children: ${screen.children.length}`);
-        // Log widget visibility state
-        for (const [name, widget] of Object.entries(widgets)) {
-            if (widget) {
-                const hidden = widget.hidden;
-                const visible = widget.visible;
-                const content = widget.content || '';
-                dbg(`Widget ${name}: hidden=${hidden} visible=${visible} contentLen=${content.length}`);
-            }
-        }
-        widgets.commandLine.focus();
-        screen.focused = widgets.commandLine;
-        return widgets;
-    }
-}
-/**
- * Render frame (atomic teardown + rebuild)
- *
- * Step 1: Hard viewport container - all widgets inside viewportBox
- * Step 4: Rebuild on resize - destroy old viewport, recreate with new sizes
- *
- * @param screen - Blessed screen
- * @param spec - Layout spec with integer pixel positions
- * @param oldWidgets - Previous widgets (will be destroyed)
- * @param commandInputValue - Preserve command line input across resizes
- * @param isInitialBoot - Only clear terminal on boot, not resize
- * @returns New widgets
- */
-export function renderFrame(screen, spec, oldWidgets, commandInputValue = '', isInitialBoot = false, // B) Only clear on boot, not resize
-useAsciiBorders = false // D) Use ASCII borders in safe mode
-) {
-    // B) Only clear terminal on boot, not during resize (CloudShell safety)
-    if (isInitialBoot) {
-        hardClearTerminal(screen);
-    }
-    // Step 4: Destroy old viewport container (if exists)
-    if (oldWidgets?.viewport) {
-        try {
-            const vp = oldWidgets.viewport;
-            // Destroy all children first
-            if (vp.children) {
-                for (const child of [...vp.children]) {
-                    try {
-                        if (typeof child.detach === 'function') {
-                            child.detach();
-                        }
-                        if (typeof child.destroy === 'function') {
-                            child.destroy();
-                        }
-                    }
-                    catch {
-                        // Ignore
-                    }
-                }
-            }
-            if (typeof vp.detach === 'function') {
-                vp.detach();
-            }
-            if (typeof vp.destroy === 'function') {
-                vp.destroy();
-            }
-        }
-        catch (error) {
-            // Ignore errors during teardown
-        }
-    }
-    // Contract E: Atomic teardown - destroy all old widgets first (no partial mutation)
-    teardownWidgets(screen, oldWidgets);
-    // Contract B: Clear ALL screen children (only viewportBox should be direct child)
-    while (screen.children.length > 0) {
-        const child = screen.children[0];
-        try {
-            child.detach();
-        }
-        catch (error) {
-            // Continue teardown
-        }
-    }
-    // Contract B: Ensure screen is clean before creating viewportBox
-    // Contract A: Get safe viewport (strict bounds)
-    const viewport = getSafeViewport(screen);
-    // Get program reference for debug logging
-    const program = screen.program;
-    // Contract A: Log viewport (uses tuiDebug - gated by TUI_DEBUG)
-    dbg(`Viewport: ${viewport.cols}x${viewport.rows}, Browser: ${viewport.isBrowserTerminal}, Margins: R=${viewport.rightMargin} B=${viewport.bottomMargin}`);
-    // Contract B: One Root Viewport Container
-    // Rule: only one blessed child attaches to screen: viewportBox.
-    // Everything else is a child of viewportBox.
-    // This guarantees even if blessed thinks it has more space, you're drawing inside a bounded container.
-    const viewportBox = blessedLib.box({
-        top: 0,
-        left: 0,
-        width: viewport.cols, // Contract A: Hard bound to safeCols
-        height: viewport.rows, // Contract A: Hard bound to safeRows
-        border: {
-            type: 'line',
-            fg: 'green', // TEMPORARY: Green border to see if viewportBox renders
-        },
-        style: {
-            bg: 'black',
-            fg: 'white',
-        },
-        content: ' VIEWPORT ', // TEMPORARY: Content to see if viewportBox renders
-        focusable: false,
-        keys: false,
-        mouse: false,
-        tags: true,
-    });
-    // Contract B: Append viewportBox as the ONLY direct child of screen
-    screen.append(viewportBox);
-    // CRITICAL: Force viewportBox to be visible
-    dbg(`Created viewportBox: ${viewport.cols}x${viewport.rows}, screen children: ${screen.children.length}`);
-    // Step 4: Create new widgets from layout spec (ALL as children of viewportBox)
-    const { columns, rows, mode } = spec;
-    const mainHeight = rows.mainBottom - rows.mainTop;
-    // A) Log to stderr only (never stdout)
-    dbg(`Layout mode: ${mode}, mainHeight: ${mainHeight}`);
-    dbg(`Columns: left=${columns.left.width}@${columns.left.left}, center=${columns.center.width}@${columns.center.left}, right=${columns.right.width}@${columns.right.left}`);
-    // CRITICAL: Ensure viewportBox (screen) has no hidden children before creating new widgets
-    // Clear any detached or hidden widgets that might interfere
-    try {
-        for (const child of [...viewportBox.children || []]) {
-            if (child && child.detached) {
-                try {
-                    child.detach();
-                }
-                catch {
-                    // Ignore
-                }
-            }
-        }
-    }
-    catch {
-        // Ignore cleanup errors
-    }
-    // C) Hard validate rects before widget creation
-    // Note: viewport was already calculated above, reuse it
-    const violations = [];
-    // Validate column specs
-    for (const [name, colSpec] of Object.entries(columns)) {
-        if (colSpec.width > 0) {
-            // Check width minimum
-            if (colSpec.width < 4) {
-                violations.push(`${name}: width=${colSpec.width} < 4`);
-            }
-            // Check horizontal bounds
-            if (colSpec.left + colSpec.width > viewport.cols) {
-                violations.push(`${name}: x=${colSpec.left} w=${colSpec.width} exceeds safeCols=${viewport.cols}`);
-            }
-            // Check horizontal position
-            if (colSpec.left < 0) {
-                violations.push(`${name}: x=${colSpec.left} < 0`);
-            }
-        }
-    }
-    // Validate row specs
-    if (mainHeight < 3) {
-        violations.push(`mainHeight=${mainHeight} < 3`);
-    }
-    if (rows.cmdTop < 0 || rows.cmdTop >= viewport.rows) {
-        violations.push(`cmdTop=${rows.cmdTop} out of bounds (rows=${viewport.rows})`);
-    }
-    // A) If violations detected, log to stderr only
-    if (violations.length > 0) {
-        dbg('LAYOUT VIOLATIONS DETECTED:');
-        for (const violation of violations) {
-            dbg(`  ${violation}`);
-        }
-        dbg('Switching to narrow mode...');
-        // Force narrow mode (synchronous import)
-        const { computeLayout: computeLayoutSync } = require('../layout/layoutEngine.js');
-        const narrowSpec = computeLayoutSync(viewport);
-        if (narrowSpec.mode !== 'narrow') {
-            // If still not narrow, create minimal safe layout
-            return createMinimalSafeLayout(screen, viewport, commandInputValue);
-        }
-        // Use narrow spec instead
-        const { columns: narrowColumns, rows: narrowRows } = narrowSpec;
-        return createWidgetsForSpec(screen, viewportBox, narrowColumns, narrowRows, 'narrow', viewport, commandInputValue, useAsciiBorders);
-    }
-    // No violations - use helper function to create widgets
-    return createWidgetsForSpec(screen, viewportBox, columns, rows, mode, viewport, commandInputValue, useAsciiBorders);
-}
-/**
- * Create minimal safe layout (fallback if all else fails)
- */
-function createMinimalSafeLayout(screen, viewport, commandInputValue, useAsciiBorders = false // D) Use ASCII borders in safe mode
-) {
-    // Contract B: Create viewportBox as ONLY direct child of screen (for minimal layout)
-    const viewportBox = blessedLib.box({
-        top: 0,
-        left: 0,
-        width: viewport.cols, // Contract A: Hard bound to safeCols
-        height: viewport.rows, // Contract A: Hard bound to safeRows
-        border: false,
-        style: {
-            bg: 'black',
-        },
-        focusable: false,
-        keys: false,
-        mouse: false,
-        tags: false,
-    });
-    // Contract B: Append viewportBox as the ONLY direct child of screen
-    screen.append(viewportBox);
-    // A) Log to stderr only (never stdout)
-    dbg('Creating MINIMAL SAFE LAYOUT');
-    const cmdHeight = 3;
-    const mainHeight = Math.max(5, viewport.rows - cmdHeight);
-    const opsWidth = Math.max(40, Math.min(viewport.cols - 2, 80)); // Safe width
-    const widgets = {
-        viewport: viewportBox,
-        posture: createPanel(viewportBox, 'posture', { left: 0, width: 0 }, 0, 1, '', false, useAsciiBorders),
-        resources: createPanel(viewportBox, 'resources', { left: 0, width: 0 }, 0, 1, '', false, useAsciiBorders),
-        assets: createPanel(viewportBox, 'assets', { left: 0, width: 0 }, 0, 1, '', false, useAsciiBorders),
-        operations: createPanel(viewportBox, 'operations', { left: 1, width: opsWidth }, // Start at x=1, safe width
-        1, // Start at y=1
-        mainHeight, 'OPERATIONS (MINIMAL MODE)', true, useAsciiBorders),
-        network: createPanel(viewportBox, 'network', { left: 0, width: 0 }, 0, 1, '', false, useAsciiBorders),
-        capabilities: createPanel(viewportBox, 'capabilities', { left: 0, width: 0 }, 0, 1, '', false, useAsciiBorders),
-        commandLine: createCommandLine(viewportBox, mainHeight + 1, cmdHeight, Math.min(viewport.cols - 1, 80), // Safe width
-        commandInputValue),
-        watermark: createWatermark(viewportBox, viewport.rows, viewport.cols),
-    };
-    // A) Log to stderr only (never stdout)
-    dbg(`Minimal layout: ops=${opsWidth}x${mainHeight}@(1,1), cmd@${mainHeight + 1}`);
-    dbg(`Screen children before render: ${screen.children.length}`);
-    screen.render();
-    // A) Log to stderr only (never stdout)
-    dbg(`Screen children after render: ${screen.children.length}`);
-    // Command line focus will be set by attachCommandLineHandlers() in index.ts
-    // Don't focus here - let manual input handler set it up
-    return widgets;
-}
-//# sourceMappingURL=renderFrame.js.map