@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/layout/yoga.js

@@ -0,0 +1,249 @@
+import Yoga, { Align, Direction, Display, Edge, FlexDirection, Gutter, Justify, MeasureMode, Overflow, PositionType, Wrap, } from '../../native-ts/yoga-layout/index.js';
+import { LayoutDisplay, LayoutMeasureMode, } from './node.js';
+// --
+// Edge/Gutter mapping
+const EDGE_MAP = {
+    all: Edge.All,
+    horizontal: Edge.Horizontal,
+    vertical: Edge.Vertical,
+    left: Edge.Left,
+    right: Edge.Right,
+    top: Edge.Top,
+    bottom: Edge.Bottom,
+    start: Edge.Start,
+    end: Edge.End,
+};
+const GUTTER_MAP = {
+    all: Gutter.All,
+    column: Gutter.Column,
+    row: Gutter.Row,
+};
+// --
+// Yoga adapter
+/**
+ * Yoga-backed implementation of `LayoutNode`.
+ *
+ * Wraps a yoga-layout node, mapping layout enums to their Yoga counterparts
+ * and translating measure-mode values across the adapter boundary. The
+ * underlying Yoga instance is synchronous and available at import time.
+ */
+export class YogaLayoutNode {
+    /** The underlying Yoga node this adapter wraps. */
+    yoga;
+    constructor(yoga) {
+        this.yoga = yoga;
+    }
+    // Tree
+    insertChild(child, index) {
+        this.yoga.insertChild(child.yoga, index);
+    }
+    removeChild(child) {
+        this.yoga.removeChild(child.yoga);
+    }
+    getChildCount() {
+        return this.yoga.getChildCount();
+    }
+    getParent() {
+        const p = this.yoga.getParent();
+        return p ? new YogaLayoutNode(p) : null;
+    }
+    // Layout
+    calculateLayout(width, _height) {
+        this.yoga.calculateLayout(width, undefined, Direction.LTR);
+    }
+    setMeasureFunc(fn) {
+        this.yoga.setMeasureFunc((w, wMode) => {
+            const mode = wMode === MeasureMode.Exactly
+                ? LayoutMeasureMode.Exactly
+                : wMode === MeasureMode.AtMost
+                    ? LayoutMeasureMode.AtMost
+                    : LayoutMeasureMode.Undefined;
+            return fn(w, mode);
+        });
+    }
+    unsetMeasureFunc() {
+        this.yoga.unsetMeasureFunc();
+    }
+    markDirty() {
+        this.yoga.markDirty();
+    }
+    // Computed layout
+    getComputedLeft() {
+        return this.yoga.getComputedLeft();
+    }
+    getComputedTop() {
+        return this.yoga.getComputedTop();
+    }
+    getComputedWidth() {
+        return this.yoga.getComputedWidth();
+    }
+    getComputedHeight() {
+        return this.yoga.getComputedHeight();
+    }
+    getComputedBorder(edge) {
+        return this.yoga.getComputedBorder(EDGE_MAP[edge]);
+    }
+    getComputedPadding(edge) {
+        return this.yoga.getComputedPadding(EDGE_MAP[edge]);
+    }
+    // Style setters
+    setWidth(value) {
+        this.yoga.setWidth(value);
+    }
+    setWidthPercent(value) {
+        this.yoga.setWidthPercent(value);
+    }
+    setWidthAuto() {
+        this.yoga.setWidthAuto();
+    }
+    setHeight(value) {
+        this.yoga.setHeight(value);
+    }
+    setHeightPercent(value) {
+        this.yoga.setHeightPercent(value);
+    }
+    setHeightAuto() {
+        this.yoga.setHeightAuto();
+    }
+    setMinWidth(value) {
+        this.yoga.setMinWidth(value);
+    }
+    setMinWidthPercent(value) {
+        this.yoga.setMinWidthPercent(value);
+    }
+    setMinHeight(value) {
+        this.yoga.setMinHeight(value);
+    }
+    setMinHeightPercent(value) {
+        this.yoga.setMinHeightPercent(value);
+    }
+    setMaxWidth(value) {
+        this.yoga.setMaxWidth(value);
+    }
+    setMaxWidthPercent(value) {
+        this.yoga.setMaxWidthPercent(value);
+    }
+    setMaxHeight(value) {
+        this.yoga.setMaxHeight(value);
+    }
+    setMaxHeightPercent(value) {
+        this.yoga.setMaxHeightPercent(value);
+    }
+    setFlexDirection(dir) {
+        const map = {
+            row: FlexDirection.Row,
+            'row-reverse': FlexDirection.RowReverse,
+            column: FlexDirection.Column,
+            'column-reverse': FlexDirection.ColumnReverse,
+        };
+        this.yoga.setFlexDirection(map[dir]);
+    }
+    setFlexGrow(value) {
+        this.yoga.setFlexGrow(value);
+    }
+    setFlexShrink(value) {
+        this.yoga.setFlexShrink(value);
+    }
+    setFlexBasis(value) {
+        this.yoga.setFlexBasis(value);
+    }
+    setFlexBasisPercent(value) {
+        this.yoga.setFlexBasisPercent(value);
+    }
+    setFlexWrap(wrap) {
+        const map = {
+            nowrap: Wrap.NoWrap,
+            wrap: Wrap.Wrap,
+            'wrap-reverse': Wrap.WrapReverse,
+        };
+        this.yoga.setFlexWrap(map[wrap]);
+    }
+    setAlignItems(align) {
+        const map = {
+            auto: Align.Auto,
+            stretch: Align.Stretch,
+            'flex-start': Align.FlexStart,
+            center: Align.Center,
+            'flex-end': Align.FlexEnd,
+        };
+        this.yoga.setAlignItems(map[align]);
+    }
+    setAlignSelf(align) {
+        const map = {
+            auto: Align.Auto,
+            stretch: Align.Stretch,
+            'flex-start': Align.FlexStart,
+            center: Align.Center,
+            'flex-end': Align.FlexEnd,
+        };
+        this.yoga.setAlignSelf(map[align]);
+    }
+    setJustifyContent(justify) {
+        const map = {
+            'flex-start': Justify.FlexStart,
+            center: Justify.Center,
+            'flex-end': Justify.FlexEnd,
+            'space-between': Justify.SpaceBetween,
+            'space-around': Justify.SpaceAround,
+            'space-evenly': Justify.SpaceEvenly,
+        };
+        this.yoga.setJustifyContent(map[justify]);
+    }
+    setDisplay(display) {
+        this.yoga.setDisplay(display === 'flex' ? Display.Flex : Display.None);
+    }
+    getDisplay() {
+        return this.yoga.getDisplay() === Display.None
+            ? LayoutDisplay.None
+            : LayoutDisplay.Flex;
+    }
+    setPositionType(type) {
+        this.yoga.setPositionType(type === 'absolute' ? PositionType.Absolute : PositionType.Relative);
+    }
+    setPosition(edge, value) {
+        this.yoga.setPosition(EDGE_MAP[edge], value);
+    }
+    setPositionPercent(edge, value) {
+        this.yoga.setPositionPercent(EDGE_MAP[edge], value);
+    }
+    setOverflow(overflow) {
+        const map = {
+            visible: Overflow.Visible,
+            hidden: Overflow.Hidden,
+            scroll: Overflow.Scroll,
+        };
+        this.yoga.setOverflow(map[overflow]);
+    }
+    setMargin(edge, value) {
+        this.yoga.setMargin(EDGE_MAP[edge], value);
+    }
+    setPadding(edge, value) {
+        this.yoga.setPadding(EDGE_MAP[edge], value);
+    }
+    setBorder(edge, value) {
+        this.yoga.setBorder(EDGE_MAP[edge], value);
+    }
+    setGap(gutter, value) {
+        this.yoga.setGap(GUTTER_MAP[gutter], value);
+    }
+    // Lifecycle
+    free() {
+        this.yoga.free();
+    }
+    freeRecursive() {
+        this.yoga.freeRecursive();
+    }
+}
+// --
+// Instance management
+//
+// The TS yoga-layout port is synchronous — no WASM loading, no linear memory
+// growth, so no preload/swap/reset machinery is needed. The Yoga instance is
+// just a plain JS object available at import time.
+/**
+ * Create a new layout node backed by a fresh Yoga node.
+ * @returns a `YogaLayoutNode` with no children, styles, or measure function.
+ */
+export function createYogaLayoutNode() {
+    return new YogaLayoutNode(Yoga.Node.create());
+}

package/lib/types/ink/line-width-cache.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Measure the display width of a line, cached per line across calls.
+ * Completed lines are immutable during streaming, so caching avoids
+ * re-measuring hundreds of unchanged lines on every token.
+ * @param line - the line to measure.
+ * @returns the display width in terminal cells.
+ */
+export declare function lineWidth(line: string): number;
+//# sourceMappingURL=line-width-cache.d.ts.map

package/lib/types/ink/line-width-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-width-cache.d.ts","sourceRoot":"","sources":["../../../src/ink/line-width-cache.ts"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB9C"}

package/lib/types/ink/line-width-cache.js

@@ -0,0 +1,45 @@
+import { stringWidth } from './stringWidth.js';
+// During streaming, text grows but completed lines are immutable.
+// Caching stringWidth per-line avoids re-measuring hundreds of
+// unchanged lines on every token (~50x reduction in stringWidth calls).
+const cache = new Map();
+const MAX_CACHE_SIZE = 4096;
+const MAX_CACHE_CHARS = 100_000;
+// Lines longer than this are never cached: the cache key would retain the
+// whole line, and during streaming the growing last line changes every
+// frame (zero reuse for the cost of a full copy per frame).
+const MAX_CACHEABLE_LINE = 500;
+let cacheChars = 0;
+/**
+ * Copy a string into a fresh flat string with no parent references.
+ * A line substring'd out of a large streaming buffer is a V8 SlicedString
+ * that pins the entire parent (the full message text); using it directly
+ * as a cache key retains the parent for the lifetime of the entry.
+ */
+function detachString(s) {
+    return Buffer.from(s, 'utf8').toString('utf8');
+}
+/**
+ * Measure the display width of a line, cached per line across calls.
+ * Completed lines are immutable during streaming, so caching avoids
+ * re-measuring hundreds of unchanged lines on every token.
+ * @param line - the line to measure.
+ * @returns the display width in terminal cells.
+ */
+export function lineWidth(line) {
+    const cached = cache.get(line);
+    if (cached !== undefined)
+        return cached;
+    const width = stringWidth(line);
+    if (line.length > MAX_CACHEABLE_LINE)
+        return width;
+    // Evict when cache grows too large (e.g. after many different responses).
+    // Simple full-clear is fine — the cache repopulates in one frame.
+    if (cache.size >= MAX_CACHE_SIZE || cacheChars + line.length > MAX_CACHE_CHARS) {
+        cache.clear();
+        cacheChars = 0;
+    }
+    cache.set(detachString(line), width);
+    cacheChars += line.length;
+    return width;
+}

package/lib/types/ink/log-update.d.ts

@@ -0,0 +1,57 @@
+import type { Diff, Frame } from './frame.js';
+import { type StylePool } from './screen.js';
+type Options = {
+    isTTY: boolean;
+    stylePool: StylePool;
+};
+/**
+ * Converts frame diffs into terminal write patches. Holds per-instance
+ * state (previous output, style pool, TTY mode) across frames.
+ */
+export declare class LogUpdate {
+    private readonly options;
+    private state;
+    constructor(options: Options);
+    /**
+     * Request a one-shot viewport re-anchor on the next main-screen frame.
+     *
+     * The main-screen diff engine addresses rows purely relative to where it
+     * left the cursor — it has no absolute anchor and no way to notice when a
+     * third party moved it. A subprocess writing directly to the tty (an MCP
+     * server's stderr, a stray native log line — issue #17) advances the
+     * cursor and scrolls the terminal; every subsequent diff then lands N
+     * rows off, garbling the UI (missing labels, shifted rows — issue #16)
+     * until some full repaint happens to run. There is nothing to detect
+     * after the fact (a newline-terminated write parks the cursor back at
+     * the bottom column 0, exactly where the engine expects it), so the
+     * recovery is a blind idempotent repaint: rebuild the viewport from the
+     * physical cursor position, which re-syncs the virtual↔physical mapping
+     * no matter how far they had drifted. Wired to the stdin-gap reassert
+     * (>5s idle then a keypress) — the same trigger that re-asserts DEC
+     * modes after tmux attach / ssh reconnect.
+     */
+    requestViewportReanchor(): void;
+    /**
+     * Render the terminal state for a finished run, for streams that no
+     * longer support string output.
+     * @param prevFrame - the previously rendered frame.
+     * @returns the patches that restore the terminal to the previous frame's state.
+     */
+    renderPreviousOutput_DEPRECATED(prevFrame: Frame): Diff;
+    /** Drop the previous-output state after the process resumes from suspension (SIGCONT) so terminal content is not clobbered. */
+    reset(): void;
+    private renderFullFrame;
+    private getRenderOpsForDone;
+    /**
+     * Diff the previous and next frames and produce the patches that update
+     * the terminal from one to the other.
+     * @param prev - the previously rendered frame.
+     * @param next - the frame to render.
+     * @param altScreen - whether the frame renders to the alternate screen.
+     * @param decstbmSafe - whether the DECSTBM scroll sequence can be made atomic (DEC 2026 / BSU/ESU).
+     * @returns the terminal write patches.
+     */
+    render(prev: Frame, next: Frame, altScreen?: boolean, decstbmSafe?: boolean): Diff;
+}
+export {};
+//# sourceMappingURL=log-update.d.ts.map

package/lib/types/ink/log-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-update.d.ts","sourceRoot":"","sources":["../../../src/ink/log-update.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAiB,KAAK,EAAE,MAAM,YAAY,CAAA;AAE5D,OAAO,EASL,KAAK,SAAS,EAGf,MAAM,aAAa,CAAA;AAqBpB,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,SAAS,CAAA;CACrB,CAAA;AAKD;;;GAGG;AACH,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,KAAK,CAAO;gBAES,OAAO,EAAE,OAAO;IAO7C;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAAuB,IAAI,IAAI;IAI/B;;;;;OAKG;IACH,+BAA+B,CAAC,SAAS,EAAE,KAAK,GAAG,IAAI;IASvD,+HAA+H;IAC/H,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,eAAe;IAiDvB,OAAO,CAAC,mBAAmB;IAS3B;;;;;;;;OAQG;IACH,MAAM,CACJ,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,KAAK,EACX,SAAS,UAAQ,EACjB,WAAW,UAAO,GACjB,IAAI;CA6XR"}