@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/tui/transcript-view.js

@@ -1,6 +1,7 @@
 // Incremental transcript layout for long-running sessions.
+import { hasColor } from "../ui/render.js";
+import { runningTool } from "./components/tool-motion.js";
 import { render } from "./blocks.js";
-import { TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS, TOOL_ROW_ARRIVAL_MS, TOOL_SETTLE_MS, } from "./motion.js";
 const MAX_LAYOUTS = 2;
 const REFLOW_BLOCKS_PER_FRAME = 128;
 /**
@@ -13,18 +14,17 @@ const REFLOW_BLOCKS_PER_FRAME = 128;
  */
 export function transcriptRenderer(draw = render, clock = Date.now) {
     let layouts = [];
-    const motions = new WeakMap();
-    const activeMotion = new Set();
+    const activeTools = new Set();
     return {
         viewport(blocks, width, height, scroll, palette, state = {}) {
-            const layout = layoutFor(blocks, width, palette);
-            const now = state.now ?? clock();
-            if (state.reducedMotion === true) {
-                discardSuppressedMotion(layout);
-            }
-            else if (scroll === 0) {
-                invalidateMovingEntries(layout, now);
+            if (blocks.length === 0 && layouts.some((layout) => layout.entries.length > 0)) {
+                layouts = [];
+                activeTools.clear();
             }
+            const layout = layoutFor(blocks, width, palette);
+            state = { ...state, now: state.now ?? clock() };
+            if (scroll === 0)
+                invalidateRunningEntries(layout);
             // Reflowing rows below a scroll-locked viewport would move the content
             // being read as estimates become exact. Visible rows still resolve on
             // demand; background work resumes when the user follows the tail again.
@@ -35,15 +35,19 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
                 rows: visibleRows(layout, window, Math.max(0, height)),
                 maxScroll: window.maxScroll,
                 pending: scroll === 0 && layout.pending > 0,
-                animating: scroll === 0 && state.reducedMotion !== true && hasMovingEntry(layout, now),
+                animating: scroll === 0 && state.reducedMotion !== true && hasColor() && hasRunningEntry(layout, window),
             };
         },
         invalidate(block) {
             if (block === undefined) {
                 layouts = [];
+                activeTools.clear();
                 return;
             }
-            observeMotion(block, clock());
+            if (runningTool(block))
+                activeTools.add(block);
+            else
+                activeTools.delete(block);
             for (const layout of layouts) {
                 const index = layout.positions.get(block);
                 if (index === undefined)
@@ -95,6 +99,8 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
             const rowCount = seeded?.block === block ? seeded.rowCount : estimatedRows(block);
             layout.entries.push({ block, rowCount });
             layout.positions.set(block, index);
+            if (runningTool(block))
+                activeTools.add(block);
             layout.pending++;
             total += rowCount;
             layout.ends.push(total);
@@ -138,7 +144,6 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
         entry.rows = draw(entry.block, layout.width, layout.palette, {
             ...state,
             previous: layout.entries[index - 1]?.block,
-            motion: motions.get(entry.block),
         });
         entry.rowCount = entry.rows.length;
         layout.pending--;
@@ -188,115 +193,28 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
         }
         layout.next = Math.max(layout.next, index);
     }
-    function observeMotion(block, now) {
-        if (block.kind !== "tool")
-            return;
-        let motion = motions.get(block);
-        // A settled historical block may be invalidated by Ctrl+O. It should not
-        // replay its original arrival animation after resume.
-        if (motion === undefined) {
-            if (block.tone !== "pending")
-                return;
-            motion = {
-                bornAt: now,
-                rowsAt: (block.body ?? []).map(() => now),
-                rowKeys: (block.body ?? []).map(detailKey),
-                tone: block.tone,
-            };
-            motions.set(block, motion);
-            activeMotion.add(block);
-            return;
-        }
-        if (motion.tone === "pending" && block.tone !== "pending")
-            motion.settledAt = now;
-        motion.tone = block.tone;
-        reconcileRows(motion, block.body ?? [], now);
-        activeMotion.add(block);
-    }
-    function invalidateMovingEntries(layout, now) {
-        for (const block of activeMotion) {
+    function invalidateRunningEntries(layout) {
+        for (const block of activeTools) {
             const index = layout.positions.get(block);
-            if (index === undefined) {
-                activeMotion.delete(block);
-                continue;
-            }
-            const motion = motions.get(block);
-            if (motion === undefined || !moving(block, motion, now)) {
-                // Paint the resting state once before leaving the motion registry;
-                // otherwise the cache could retain the final in-between frame.
-                dirty(layout, index);
-                activeMotion.delete(block);
+            if (index === undefined || !runningTool(block)) {
+                activeTools.delete(block);
+                if (index !== undefined)
+                    dirty(layout, index);
                 continue;
             }
+            // Clock-driven repaints keep elapsed time current even without motion.
             dirty(layout, index);
         }
     }
-    function hasMovingEntry(layout, now) {
-        for (const block of activeMotion) {
-            if (layout.positions.get(block) === undefined)
-                continue;
-            const motion = motions.get(block);
-            if (motion !== undefined && moving(block, motion, now))
+    function hasRunningEntry(layout, window) {
+        for (const block of activeTools) {
+            const index = layout.positions.get(block);
+            if (index !== undefined && index >= window.first && index <= window.last &&
+                runningTool(block) && block.expanded !== true)
                 return true;
         }
         return false;
     }
-    function discardSuppressedMotion(layout) {
-        for (const block of activeMotion) {
-            if (layout.positions.get(block) !== undefined && block.kind === "tool" && block.tone === "pending") {
-                continue;
-            }
-            activeMotion.delete(block);
-            motions.delete(block);
-        }
-    }
-}
-function reconcileRows(motion, details, now) {
-    const available = new Map();
-    for (let index = 0; index < motion.rowKeys.length; index++) {
-        const key = motion.rowKeys[index];
-        if (key === undefined)
-            continue;
-        const bucket = available.get(key) ?? { values: [], next: 0 };
-        bucket.values.push(motion.rowsAt[index] ?? motion.bornAt);
-        available.set(key, bucket);
-    }
-    const rowKeys = details.map(detailKey);
-    const rowsAt = rowKeys.map((key) => {
-        const bucket = available.get(key);
-        if (bucket === undefined || bucket.next >= bucket.values.length)
-            return now;
-        const value = bucket.values[bucket.next] ?? now;
-        bucket.next++;
-        return value;
-    });
-    motion.rowKeys = rowKeys;
-    motion.rowsAt = rowsAt;
-}
-function detailKey(detail) {
-    if (detail.kind === "out" || detail.kind === "gap") {
-        return JSON.stringify([detail.kind, detail.text]);
-    }
-    return JSON.stringify([
-        detail.kind,
-        detail.oldLine ?? "",
-        detail.newLine ?? "",
-        detail.emphasis?.start ?? "",
-        detail.emphasis?.length ?? "",
-        detail.text,
-    ]);
-}
-function moving(block, motion, now) {
-    if (block.kind === "tool" && block.tone === "pending" &&
-        block.startedAt !== undefined && block.right === "running")
-        return true;
-    let until = motion.bornAt + Math.max(TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS);
-    if (motion.settledAt !== undefined)
-        until = Math.max(until, motion.settledAt + TOOL_SETTLE_MS);
-    for (const arrivedAt of motion.rowsAt) {
-        until = Math.max(until, arrivedAt + TOOL_ROW_ARRIVAL_MS);
-    }
-    return now < until;
 }
 function compatible(layout, blocks) {
     return layout.source === blocks &&

package/dist/tui/turn-workflow.js

@@ -0,0 +1,235 @@
+// One model turn, including steering, compaction, durable settlement, and recovery.
+import { runTurn } from "../controller.js";
+import { resolveContextPolicy } from "../context/capacity.js";
+import { contextManager } from "../context/manager.js";
+import { steeringInbox } from "../steering.js";
+import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "../usage.js";
+import { toolSpecs } from "../tools/index.js";
+import { requestIdentityForSession } from "../request-identity.js";
+import { transition } from "./activity.js";
+import { answerAt } from "./approve.js";
+import * as edit from "./editor.js";
+import { controllerOptions, footerInfo, turnFailure } from "./session-view.js";
+import { transcribe } from "./turn.js";
+const WAITING = "Waiting";
+export function turnWorkflow(options, automaticCompaction, inputs) {
+    const { session, state, permissions, feedback } = options;
+    let activeSteering;
+    async function turn(text) {
+        const activity = options.startActivity("turn", WAITING);
+        if (activity === undefined)
+            return;
+        // Settings menus remain live, but every request, compaction, and checkpoint
+        // in this turn must retain the selection with which the turn started.
+        const runtime = { ...session, config: { ...session.config } };
+        const requestIdentity = requestIdentityForSession(session);
+        state.turnFooter = footerInfo(runtime);
+        const inbox = steeringInbox((pending, accepting) => {
+            if (activeSteering !== inbox)
+                return;
+            state.steering = accepting ? pending : undefined;
+            options.render();
+        });
+        activeSteering = inbox;
+        state.steering = 0;
+        const status = (label) => transition(activity, label);
+        const parentId = session.conversation.activeNodeId;
+        const history = session.conversation.history;
+        const modelHistory = session.conversation.contextHistory;
+        const historyStart = history.length;
+        const blockStart = state.blocks.length;
+        const createdAt = new Date().toISOString();
+        const prospectiveNodeId = session.conversation.nodes.length + 1;
+        let nodeId;
+        let context;
+        const unpersistedSteering = [];
+        const turnTools = permissions.availableTools();
+        const specs = toolSpecs(turnTools);
+        let firstPolicy = true;
+        const policy = () => {
+            let visible = firstPolicy;
+            firstPolicy = false;
+            if (visible) {
+                status("Checking context");
+                options.render();
+            }
+            return resolveContextPolicy({
+                provider: runtime.provider,
+                model: runtime.model,
+                compactionPercent: runtime.config.compactionPercent,
+                signal: activity.control.signal,
+                onStatus: (said) => {
+                    visible = true;
+                    status(said);
+                    options.render();
+                },
+            }).finally(() => {
+                if (visible) {
+                    status(WAITING);
+                    options.render();
+                }
+            });
+        };
+        const requestOptions = {
+            ...controllerOptions(session, policy, turnTools, inbox),
+            inputMeter: inputs.forTurn(runtime.provider, requestIdentity.conversationId),
+            toolAllowed: (call) => permissions.allowed(call),
+        };
+        options.emit({ kind: "user", text });
+        const user = { role: "user", content: [{ kind: "text", text }] };
+        history.push(user);
+        modelHistory.push(structuredClone(user));
+        const events = transcribe({
+            emit: options.emit,
+            render: options.render,
+            palette: session.palette,
+            approved: (call) => permissions.approved(call),
+            remember: (call) => permissions.remember(call),
+            ask: (prompt, settle) => {
+                state.approval = { picker: prompt, settle: (index) => settle(answerAt(index)) };
+                options.render();
+            },
+            status: (text) => {
+                status(text);
+            },
+            usage: (usage) => recordUsage(session.usage, usage),
+            requestInput: (inputTokens) => recordRequestInput(session.usage, inputTokens),
+        });
+        const persist = async (checkpoint, settlement, failure) => {
+            const next = session.conversation.commit({
+                ...(nodeId === undefined ? {} : { nodeId }),
+                parentId,
+                createdAt,
+                identity: {
+                    providerId: runtime.provider.id,
+                    model: runtime.model,
+                    effort: runtime.config.effort,
+                },
+                messages: checkpoint.slice(historyStart),
+                blocks: state.blocks.slice(blockStart),
+                ...(context === undefined ? {} : { context }),
+                ...(failure === undefined ? {} : { failure }),
+            }, settlement);
+            await session.persistence?.checkpoint(next);
+            session.conversation = next;
+            nodeId = next.activeNodeId;
+            state.committedNodeId = next.activeNodeId;
+            unpersistedSteering.length = 0;
+        };
+        const manager = contextManager({
+            provider: runtime.provider,
+            model: runtime.model,
+            effort: runtime.config.effort,
+            system: runtime.system,
+            tools: specs,
+            maxOutputTokens: runtime.config.maxTokens,
+            historyStart,
+            nodeId: () => nodeId ?? prospectiveNodeId,
+            gate: automaticCompaction,
+            identity: requestIdentity,
+            signal: activity.control.signal,
+            onStatus(active) {
+                status(active ? "Compacting" : WAITING);
+                options.render();
+            },
+            onUsage: (usage) => recordAuxiliaryUsage(session.usage, usage),
+        });
+        events.onContext = async (checkpoint, projected, request) => {
+            const result = await manager.compact(checkpoint, projected, request);
+            context = manager.anchor;
+            return result;
+        };
+        events.onSteering = (guidance) => {
+            unpersistedSteering.push(guidance);
+            options.emit({ kind: "user", text: guidance });
+            options.render();
+        };
+        events.onCheckpoint = async (checkpoint, settlement) => {
+            await persist(checkpoint, settlement);
+        };
+        let finishReason;
+        let failed;
+        try {
+            await runTurn(history, requestOptions, events, activity.control.signal, modelHistory);
+        }
+        catch (error) {
+            inputs.reset();
+            const interrupted = activity.control.signal.aborted;
+            const completed = nodeId !== undefined && session.conversation.activeNodeId === nodeId &&
+                session.conversation.activeNode?.settlement === "completed";
+            if (completed) {
+                const notice = turnFailure(runtime, error, interrupted);
+                feedback.show({ text: notice.text, tone: notice.tone, timeoutMs: 6_000 });
+            }
+            else {
+                finishReason = interrupted ? "interrupted" : "failed";
+                failed = { error: error, interrupted };
+            }
+        }
+        finally {
+            let pendingSteering = inbox.close();
+            if (activeSteering === inbox)
+                activeSteering = undefined;
+            state.steering = undefined;
+            try {
+                events.finish(finishReason);
+                if (failed !== undefined) {
+                    const notice = turnFailure(runtime, failed.error, failed.interrupted);
+                    const settlement = failed.interrupted ? "interrupted" : "failed";
+                    const failure = {
+                        text: notice.text,
+                        tone: failed.interrupted ? "warn" : "error",
+                    };
+                    options.emit(notice);
+                    try {
+                        await persist(closeFailedTurn(history, settlement), settlement, failure);
+                    }
+                    catch (error) {
+                        // A failed persistence boundary cannot remain visible as if it had
+                        // been saved. Revert to the last durable path and return the input
+                        // to the composer so the user can retry without losing it.
+                        options.replaceTranscript();
+                        state.editor = edit.of([
+                            ...(nodeId === undefined ? [text] : []),
+                            ...unpersistedSteering,
+                            ...pendingSteering,
+                            state.editor.text,
+                        ].filter((part) => part !== "").join("\n\n"));
+                        state.completing = undefined;
+                        pendingSteering = [];
+                        feedback.show({
+                            text: error.message,
+                            tone: "error",
+                            timeoutMs: 6_000,
+                        });
+                    }
+                }
+            }
+            finally {
+                restorePendingSteering(state, pendingSteering);
+                options.finishActivity(activity);
+            }
+        }
+    }
+    function steer(text) {
+        return activeSteering?.offer(text) ?? "unavailable";
+    }
+    return { turn, steer };
+}
+function restorePendingSteering(state, messages) {
+    if (messages.length === 0)
+        return;
+    const pending = messages.join("\n\n");
+    state.editor = edit.of(state.editor.text === "" ? pending : `${pending}\n\n${state.editor.text}`);
+    state.completing = undefined;
+}
+function closeFailedTurn(history, settlement) {
+    const closed = [...history];
+    if (closed.at(-1)?.role === "assistant")
+        return closed;
+    const text = settlement === "interrupted"
+        ? "The previous attempt was interrupted by the user before completion."
+        : "The previous attempt failed before completion.";
+    closed.push({ role: "assistant", content: [{ kind: "text", text }] });
+    return closed;
+}

package/dist/tui/turn.js

@@ -3,17 +3,14 @@
 // The controller speaks in stream events and tool results; the screen speaks in
 // blocks. This is the whole of the translation, kept out of the shell so that
 // neither has to know how the other is built.
-import { graphemes } from "../text-boundary.js";
-import { condense, diff } from "../ui/diff.js";
 import { promptFor } from "./approve.js";
+import { toolTarget, previewDetails, producedDetails, outputDetails } from "./tool-details.js";
 // Semantic activity labels feed the footer's compact state and timer while
 // reasoning and tools keep the detailed work visible in the transcript.
 const WAITING = "Waiting";
 const THINKING = "Thinking";
 const RESPONDING = "Responding";
 const ASKING = "Waiting for you";
-/** Unchanged rows kept either side of a change. */
-const CONTEXT = 2;
 export function transcribe(stage) {
     // The block the stream is currently filling. A change of kind starts a new
     // one, which is what keeps reasoning and answer from running together.
@@ -104,10 +101,10 @@ export function transcribe(stage) {
             const block = {
                 kind: "tool",
                 name: call.name,
-                target: target(call.input),
+                target: toolTarget(call.input),
                 right: "ready",
                 tone: "pending",
-                body: preview(call, look),
+                body: previewDetails(call, look),
             };
             tools.set(call.id, block);
             stage.emit(block);
@@ -117,7 +114,7 @@ export function transcribe(stage) {
             const block = tools.get(call.id);
             if (block === undefined || block.kind !== "tool" || block.tone !== "pending")
                 return;
-            block.body = details(output, "out");
+            block.body = outputDetails(output, "out");
             stage.render(block);
         },
         onToolResult(call, result, summary) {
@@ -138,8 +135,8 @@ export function transcribe(stage) {
             // A failure replaces the preview: what the call was going to do stops
             // being the interesting part the moment it did not do it.
             const outcome = result.isError
-                ? details(result.output, "out")
-                : produced(call, result.output);
+                ? outputDetails(result.output, "out")
+                : producedDetails(call, result.output);
             if (outcome !== undefined)
                 block.body = outcome;
             stage.render(block);
@@ -158,7 +155,7 @@ export function transcribe(stage) {
                 stage.render(block);
             }
             return new Promise((resolve) => {
-                stage.ask(promptFor(call, target(call.input), stage.palette), (answer) => {
+                stage.ask(promptFor(call, toolTarget(call.input), stage.palette), (answer) => {
                     if (answer === "always")
                         stage.remember(call);
                     const approved = answer !== "no";
@@ -204,133 +201,3 @@ function settleDuration(block) {
     }
     block.startedAt = undefined;
 }
-/** The argument worth showing: the thing the call acts on. */
-function target(input) {
-    const { path, command } = input;
-    if (typeof command === "string")
-        return command;
-    if (typeof path === "string")
-        return path;
-    const rest = JSON.stringify(input);
-    return rest === "{}" ? "" : rest;
-}
-/**
- * What the call is about to do, drawn before it is allowed to do it.
- *
- * The tool is asked first, because only it knows what is already on disk: a
- * write against an existing file is a replacement, and showing it as a page of
- * additions hides exactly the part worth approving. The fallback diffs what is
- * in the arguments, which is all there is when a tool has nothing to say.
- */
-function preview(call, look) {
-    if (look !== undefined)
-        return changes(look.before, look.after);
-    const input = call.input;
-    if (call.name === "write_file" && typeof input.content === "string") {
-        return changes("", input.content);
-    }
-    if (call.name === "edit_file" && typeof input.old_text === "string") {
-        return changes(input.old_text, typeof input.new_text === "string" ? input.new_text : "");
-    }
-    return undefined;
-}
-/** Two texts as the rows of their difference, unchanged runs summed up. */
-function changes(before, after) {
-    let oldLine = 1;
-    let newLine = 1;
-    const rows = [];
-    for (const changed of condense(diff(before, after), CONTEXT)) {
-        if (changed.kind === "gap") {
-            rows.push({ kind: "gap", text: `… ${changed.skipped} unchanged` });
-            oldLine += changed.skipped;
-            newLine += changed.skipped;
-            continue;
-        }
-        if (changed.kind === "keep") {
-            rows.push({ kind: "keep", text: tabs(changed.text), oldLine, newLine });
-            oldLine++;
-            newLine++;
-            continue;
-        }
-        if (changed.kind === "del") {
-            rows.push({ kind: "del", text: tabs(changed.text), oldLine });
-            oldLine++;
-            continue;
-        }
-        rows.push({ kind: "add", text: tabs(changed.text), newLine });
-        newLine++;
-    }
-    emphasizePairs(rows);
-    return rows.length === 0 ? undefined : rows;
-}
-function emphasizePairs(rows) {
-    for (let index = 0; index < rows.length - 1; index++) {
-        const removed = rows[index];
-        const added = rows[index + 1];
-        if (removed?.kind !== "del" || added?.kind !== "add")
-            continue;
-        if (rows[index - 1]?.kind === "del" || rows[index + 2]?.kind === "add")
-            continue;
-        const removedClusters = graphemes(removed.text);
-        const addedClusters = graphemes(added.text);
-        let prefix = 0;
-        let start = 0;
-        while (prefix < removedClusters.length &&
-            prefix < addedClusters.length &&
-            removedClusters[prefix] === addedClusters[prefix]) {
-            start += removedClusters[prefix].length;
-            prefix++;
-        }
-        let suffix = 0;
-        let removedSuffix = 0;
-        let addedSuffix = 0;
-        while (suffix < removedClusters.length - prefix &&
-            suffix < addedClusters.length - prefix &&
-            removedClusters[removedClusters.length - 1 - suffix] ===
-                addedClusters[addedClusters.length - 1 - suffix]) {
-            removedSuffix += removedClusters[removedClusters.length - 1 - suffix].length;
-            addedSuffix += addedClusters[addedClusters.length - 1 - suffix].length;
-            suffix++;
-        }
-        while (suffix > 0 &&
-            (!wordBoundary(removed.text, removedSuffix) || !wordBoundary(added.text, addedSuffix))) {
-            removedSuffix -= removedClusters[removedClusters.length - suffix].length;
-            addedSuffix -= addedClusters[addedClusters.length - suffix].length;
-            suffix--;
-        }
-        const removedLength = removed.text.length - start - removedSuffix;
-        const addedLength = added.text.length - start - addedSuffix;
-        if (removedLength > 0)
-            removed.emphasis = { start, length: removedLength };
-        if (addedLength > 0)
-            added.emphasis = { start, length: addedLength };
-    }
-}
-function wordBoundary(text, suffix) {
-    const at = text.length - suffix;
-    if (at <= 0 || at >= text.length)
-        return true;
-    return /\w/.test(text[at - 1]) !== /\w/.test(text[at]);
-}
-/** What the call left behind, for the calls whose output is worth a look. */
-function produced(call, output) {
-    if (call.name === "run_command")
-        return details(output, "out");
-    // A read or a listing is already summed up on the right of its own row, and
-    // the model is about to say what was in it. Printing it twice helps nobody.
-    return undefined;
-}
-function details(text, kind) {
-    const rows = split(text).map((line) => ({ kind, text: tabs(line) }));
-    return rows.length === 0 ? undefined : rows;
-}
-function split(text) {
-    const lines = text.replace(/\r\n?/g, "\n").split("\n");
-    while (lines.length > 0 && lines[lines.length - 1] === "")
-        lines.pop();
-    return lines.map(tabs);
-}
-// A tab is a width the terminal decides and the row measurement cannot see.
-function tabs(line) {
-    return line.replace(/\t/g, "  ");
-}

package/dist/tui/view.js

@@ -39,10 +39,10 @@ export function compose(view, size, transcript = transcriptRenderer()) {
 }
 function dockRows(view, width, height) {
     const status = renderStatus({
-        // A modal already names the interaction in progress. Let command feedback
-        // use the footer while that interaction is open instead of repeating a
-        // generic "Running /…" label beside it.
-        status: view.modal === undefined ? view.status : undefined,
+        // A modal names its command; background model work still needs visible
+        // status. Its interruption/steering keys are suspended while a menu owns input.
+        status: view.modal === undefined || view.turnActive ? view.status : undefined,
+        interruptible: view.modal === undefined,
         steering: view.modal === undefined ? view.steering : undefined,
         feedback: view.feedback,
         readiness: view.readiness,

package/dist/tui/workflow-types.js

@@ -0,0 +1,2 @@
+// Host capabilities shared by foreground command and turn workflows.
+export {};

package/dist/ui/render.js

@@ -45,10 +45,6 @@ export function paint(seg) {
 export function plainLen(segs) {
     return segs.reduce((n, seg) => n + textWidth(terminalText(seg.text)), 0);
 }
-export function columns() {
-    const width = process.stdout.columns;
-    return typeof width === "number" && width >= 40 ? width : 80;
-}
 /**
  * The margin every row keeps from the edges of the terminal: none.
  *