mixdog 0.9.22 → 0.9.23

package/vendor/ink/build/output.js

@@ -97,7 +97,7 @@ export default class Output {
         this.selection = rect;
     }
     write(x, y, text, options) {
-        const { transformers } = options;
+        const { transformers, softWrap } = options;
         if (!text) {
             return;
         }
@@ -107,6 +107,10 @@ export default class Output {
             y,
             text,
             transformers,
+            // [mixdog fork] per-visual-line soft-wrap flags, parallel to
+            // text.split('\n'); softWrap[i]=true means line i is a word-wrap
+            // continuation of line i-1. undefined = producer didn't track it.
+            softWrap,
         });
     }
     clip(clip) {
@@ -135,6 +139,11 @@ export default class Output {
             }
             output.push(row);
         }
+        // [mixdog fork] per-output-row soft-wrap continuation bitmap, filled from
+        // each write op's softWrap flags at the row it lands on. rowSoftWrap[y]
+        // true = row y is a word-wrap continuation of y-1. Left false where the
+        // producer didn't track wrapping (fills, raw ansi, unwrapped text).
+        const rowSoftWrap = new Array(this.height).fill(false);
         const clips = [];
         for (const operation of this.operations) {
             if (operation.type === 'clip') {
@@ -144,9 +153,12 @@ export default class Output {
                 clips.pop();
             }
             if (operation.type === 'write') {
-                const { text, transformers } = operation;
+                const { text, transformers, softWrap } = operation;
                 let { x, y } = operation;
                 let lines = text.split('\n');
+                // Index of the first surviving line after a vertical clip slice,
+                // so softWrap[] (parallel to the UN-clipped lines) stays aligned.
+                let swFrom = 0;
                 // [mixdog fork] Nested overflow:hidden boxes must be clipped to
                 // the INTERSECTION of every active ancestor clip. Using only the
                 // innermost clip lets child components such as ToolExecution /
@@ -190,6 +202,7 @@ export default class Output {
                         const height = lines.length;
                         const to = y + height > clip.y2 ? clip.y2 - y : height;
                         lines = lines.slice(from, to);
+                        swFrom = from;
                         if (y < clip.y1) {
                             y = clip.y1;
                         }
@@ -212,6 +225,13 @@ export default class Output {
                         offsetY++;
                         continue;
                     }
+                    // [mixdog fork] record this VISIBLE row's soft-wrap origin.
+                    // Fail closed: a write WITHOUT softWrap metadata clears any
+                    // prior sw bit on the row, so untracked overlapping content
+                    // (fills, raw ansi, a later plain write) can never inherit a
+                    // stale continuation flag and misjoin. Placed after the
+                    // empty-line guard so clipped-away no-op lines don't clear it.
+                    rowSoftWrap[y + offsetY] = softWrap ? softWrap[swFrom + index] === true : false;
                     const spaceCell = {
                         type: 'char',
                         value: ' ',
@@ -290,12 +310,53 @@ export default class Output {
             // every colored glyph to one color. selectionForeground is now
             // intentionally unused (kept in the setter API for compatibility).
             const selectionBg = rgbStyle(sel.selectionBackground, 'background', [245, 245, 245]);
-            // A style entry sets the background when its opening SGR code begins
-            // with a background parameter: 40-47 (basic), 48 (256/truecolor),
-            // 49 (default), or 100-107 (bright). ansi-tokenize emits one entry
-            // per SGR attribute, so a prefix test on `.code` cleanly isolates the
-            // bg-only entries we want to drop before appending the selection bg.
-            const isBackgroundStyle = (s) => typeof s?.code === 'string' && /^\x1b\[(?:4[0-9]|10[0-7])[;m]/.test(s.code);
+            // Parse each SGR entry's parameter list and remove ONLY the bg and
+            // inverse params, keeping everything else (fg, bold/dim/underline,
+            // etc.) in order, then re-emit the sequence. A prefix test is not
+            // enough: a compound entry like \x1b[31;48;5;42m or
+            // \x1b[1;48;2;r;g;b;37m would keep its old bg and override the
+            // selection color. Background params: 40-49 (basic + default),
+            // 100-107 (bright), 48;5;n (256), 48;2;r;g;b (truecolor). Inverse: 7.
+            // Returns a sanitized style, or null when no params remain (drop).
+            const sanitizeStyle = (s) => {
+                if (typeof s?.code !== 'string')
+                    return s ?? null;
+                const m = /^\x1b\[([\d;]*)m$/.exec(s.code);
+                if (!m)
+                    return s;
+                const params = m[1].length ? m[1].split(';') : [];
+                const kept = [];
+                for (let i = 0; i < params.length; i++) {
+                    const n = Number(params[i]);
+                    if (n === 7) // inverse
+                        continue;
+                    // basic/default/bright bg — 48 is EXCLUDED here: it is the
+                    // extended-bg introducer (48;5;n / 48;2;r;g;b) and must be
+                    // consumed WITH its payload below. Matching it in this range
+                    // check dropped only the lone '48' and left '2;r;g;b' behind,
+                    // which re-parsed as dim(2)+basic colors and grayed out any
+                    // text drawn over a truecolor background (user-message band).
+                    if ((n >= 40 && n <= 47) || n === 49 || (n >= 100 && n <= 107))
+                        continue;
+                    if (n === 48) { // extended bg: 48;5;n or 48;2;r;g;b
+                        const mode = Number(params[i + 1]);
+                        i += mode === 2 ? 4 : mode === 5 ? 2 : 1;
+                        continue;
+                    }
+                    if (n === 38) { // extended fg — keep the whole group
+                        const mode = Number(params[i + 1]);
+                        const span = mode === 2 ? 4 : mode === 5 ? 2 : 1;
+                        for (let j = 0; j <= span && i + j < params.length; j++)
+                            kept.push(params[i + j]);
+                        i += span;
+                        continue;
+                    }
+                    kept.push(params[i]);
+                }
+                if (kept.length === 0)
+                    return null;
+                return { ...s, code: `\x1b[${kept.join(';')}m` };
+            };
             const linear = sel.mode === 'linear';
             const start = linear && (sel.y1 > sel.y2 || (sel.y1 === sel.y2 && sel.x1 > sel.x2))
                 ? { x: sel.x2, y: sel.y2 }
@@ -308,20 +369,21 @@ export default class Output {
             const y1 = Math.max(0, clipY1, linear ? start.y : Math.min(sel.y1, sel.y2));
             const y2 = Math.min(this.height - 1, clipY2, linear ? end.y : Math.max(sel.y1, sel.y2));
             const lineMode = linear && y1 !== y2;
-            const selRows = captureSelectedText ? [] : null;
             // [mixdog fork] selRowObjs is built UNCONDITIONALLY whenever a
             // selection rect exists, independent of captureSelectedText: a
             // capture-disabled drag (rect.captureText === false) still needs a
             // per-row harvest so getSelectionRows() can stitch tall selections.
-            // Only selectedText/selRows honor the captureSelectedText gate.
+            // Each entry also carries sw = rowSoftWrap[y] so the copy join (here
+            // and the app-side stitch) can rejoin word-wrap continuations. Only
+            // selectedText honors the captureSelectedText gate.
             const selRowObjs = [];
             for (let y = y1; y <= y2; y++) {
                 const row = output[y];
+                // [mixdog fork] is THIS row a soft-wrap continuation of the row
+                // above? Drives the logical-line rejoin at copy time.
+                const sw = rowSoftWrap[y] === true;
                 if (!row) {
-                    selRowObjs.push({ y, text: '' });
-                    if (captureSelectedText) {
-                        selRows.push('');
-                    }
+                    selRowObjs.push({ y, text: '', sw });
                     continue;
                 }
                 const rawX1 = linear
@@ -332,49 +394,65 @@ export default class Output {
                     : Math.max(sel.x1, sel.x2);
                 const x1 = Math.max(0, Math.min(rawX1, rawX2));
                 const x2 = Math.min(row.length - 1, Math.max(rawX1, rawX2));
-                let contentStart = -1;
-                let contentEnd = -1;
-                for (let x = x1; x <= x2; x++) {
-                    const value = row[x]?.value ?? '';
-                    if (value && !/^\s$/u.test(value)) {
-                        if (contentStart === -1) {
-                            contentStart = x;
-                        }
-                        contentEnd = x;
-                    }
-                }
                 let rowText = '';
+                // [mixdog fork] running active fg/attr SGR for carry-forward below;
+                // reset per selected row so state never bleeds across rows.
+                let carry = [];
                 for (let x = x1; x <= x2; x++) {
                     const cell = row[x];
-                    if (!cell) {
-                        continue;
-                    }
                     // Collect the visible glyph. Wide-char trailing placeholders
                     // carry value '' and contribute nothing, which is correct.
                     // Always accumulated so the unconditional selRowObjs harvest
                     // has row text even when captureSelectedText is false.
-                    rowText += cell.value ?? '';
-                    if (contentStart === -1 || x < contentStart || x > contentEnd) {
-                        continue;
+                    rowText += cell?.value ?? '';
+                    // [mixdog fork] Match claude-code: EVERY cell in the selected
+                    // span gets ONE uniform selection background — no content-span
+                    // skipping. Empty/whitespace cells (and gaps in the grid) are
+                    // painted as a blank ' ' carrying only the selection bg, so a
+                    // single highlight style covers text and padding alike.
+                    // fg-preserving: keep the cell's own style entries (foreground
+                    // color, bold/dim/underline, link attrs) and swap ONLY the
+                    // background — drop any existing background/inverse entry so
+                    // they don't fight the selection bg, then append it last.
+                    const value = cell?.value ?? ' ';
+                    const baseStyles = Array.isArray(cell?.styles) ? cell.styles : [];
+                    const preserved = baseStyles.map(sanitizeStyle).filter(Boolean);
+                    // [mixdog fork] Carry the row's active fg/attr SGR forward into
+                    // selected cells that carry NO style of their own — grid-padding
+                    // gaps and wide-char trailing placeholders sit at styles=[], so
+                    // styledCharsToString's per-cell diff would emit a bare
+                    // fg/attr RESET (\x1b[39m / 22m / 24m) at each such cell,
+                    // BREAKING the colored run mid-selection and repainting the
+                    // following glyphs from a reset state. Inherit the last active
+                    // fg/attrs so the highlighted span stays ONE uniform SGR run.
+                    // Guard: only blank/whitespace cells inherit — a VISIBLE glyph
+                    // that genuinely has empty styles is intentional default-fg and
+                    // must never be recolored.
+                    if (preserved.length > 0) {
+                        carry = preserved;
                     }
-                    // [mixdog fork] fg-preserving highlight: keep the cell's own
-                    // style entries (foreground color, bold/dim/underline, link
-                    // attrs) and swap ONLY the background. Drop any existing
-                    // background entry so the two bgs don't fight, then append the
-                    // selection bg last so it wins for this cell.
-                    const baseStyles = Array.isArray(cell.styles) ? cell.styles : [];
-                    const preserved = baseStyles.filter(style => !isBackgroundStyle(style));
+                    const effective = preserved.length > 0
+                        ? preserved
+                        : (value.trim() === '' ? carry : preserved);
                     row[x] = {
-                        ...cell,
-                        styles: [...preserved, selectionBg],
+                        ...(cell ?? { value: ' ' }),
+                        value,
+                        styles: [...effective, selectionBg],
                     };
                 }
-                // Trailing spaces in a selected row are padding, not content.
-                const trimmedRowText = rowText.replace(/\s+$/u, '');
-                selRowObjs.push({ y, text: trimmedRowText });
-                if (captureSelectedText) {
-                    selRows.push(trimmedRowText);
-                }
+                // Trailing spaces are padding on a logical-line END, but at a
+                // soft-wrap boundary the break-point whitespace is the word
+                // separator (wrap-ansi keeps it on the head's tail or the
+                // continuation's lead). When the NEXT selected row continues this
+                // one, COLLAPSE the trailing run to a single space rather than
+                // trimming it: this preserves the one word-separator space while
+                // discarding the full-width padding blanks, so "alpha beta " +
+                // "gamma" rejoins as "alpha beta gamma" (not "alpha beta   gamma").
+                // Hard/char-wrap rows have no trailing space, so nothing is added.
+                // Otherwise (logical-line end) trim trailing padding entirely.
+                const nextIsCont = y + 1 <= y2 && rowSoftWrap[y + 1] === true;
+                const rowOut = nextIsCont ? rowText.replace(/\s+$/u, ' ') : rowText.replace(/\s+$/u, '');
+                selRowObjs.push({ y, text: rowOut, sw });
             }
             // [mixdog fork] Outer-trim the per-row harvest (same rule as
             // selectedText below) but UNCONDITIONALLY, keeping the absolute row
@@ -387,31 +465,24 @@ export default class Output {
             }
             selectionRows = selRowObjs;
             if (captureSelectedText) {
-                // Blank edge rows come from selecting through padded alt-screen
-                // space around rendered content. Native terminal selection does
-                // not paste those as leading/trailing empty lines, so trim only
-                // the outer empty rows and preserve intentional blank rows inside.
-                while (selRows.length > 0 && selRows[0].trim() === '') {
-                    selRows.shift();
-                }
-                while (selRows.length > 0 && selRows[selRows.length - 1].trim() === '') {
-                    selRows.pop();
-                }
                 // [mixdog fork] SOFT-WRAP JOIN (claude-code getSelectedText):
-                // claude-code rejoins word-wrapped continuation rows into one
-                // logical line using screen.softWrap, a per-row bitmap set at
-                // wrap time marking a row as a continuation of the one above.
-                // mixdog's rect(linear) render model carries NO softWrap metadata
-                // — the Output grid is a flat array of visual rows with no record
-                // of which line breaks were inserted by wrapping vs. present in
-                // the source. Detecting "this row filled to content width AND the
-                // next continues the same logical block" from cell values alone is
-                // a guess (a source line that legitimately fills the width would be
-                // wrongly glued to the next). Per the correctness-over-cleverness
-                // rule we keep the honest per-visual-row '\n' join rather than
-                // fabricate wrap boundaries. Revisit if the render pipeline starts
-                // emitting a softWrap bit per row.
-                selectedText = selRows.join('\n');
+                // rejoin word-wrap continuation rows (sw = rowSoftWrap[y], set at
+                // render/output build time from the wrapText call) onto their
+                // logical source line WITHOUT a newline; only source/hard line
+                // breaks emit '\n'. selRowObjs is already outer-trimmed above so
+                // intentional interior blank rows (paragraph gaps) survive as
+                // empty logical lines. Trailing whitespace is trimmed once per
+                // logical-line end (mid-line separators kept by the harvest).
+                const logical = [];
+                for (const r of selRowObjs) {
+                    if (r.sw && logical.length > 0) {
+                        logical[logical.length - 1] += r.text;
+                    }
+                    else {
+                        logical.push(r.text);
+                    }
+                }
+                selectedText = logical.map(l => l.replace(/\s+$/u, '')).join('\n');
             }
         }
         // [mixdog fork] Snapshot per-row, column-indexed cell values so the App
@@ -449,7 +520,19 @@ export default class Output {
                 lineWithinWidth.push(item);
                 usedWidth += itemWidth;
             }
-            return styledCharsToString(lineWithinWidth).trimEnd();
+            // [mixdog fork] Per-row SGR reset. styledCharsToString emits sticky
+            // SGR (color/dim/bold) but never a trailing reset, so a row that ends
+            // mid-attribute leaks its state into the NEXT row when log-update's
+            // incremental diff rewrites only changed rows (cursorTo(0)+row). That
+            // makes unrelated text visibly dim/darken during drag-selection
+            // repaints until a full repaint clears it. Terminate every row that
+            // carries any escape with a single explicit reset so each emitted row
+            // is self-contained. Reset ONCE at the row tail (not per cell) to
+            // avoid double-reset flicker; plain rows stay untouched.
+            const serialized = styledCharsToString(lineWithinWidth).trimEnd();
+            if (!serialized.includes('\x1b['))
+                return serialized;
+            return /\x1b\[0?m$/.test(serialized) ? serialized : serialized + '\x1b[0m';
         })
             .join('\n');
         return {

package/vendor/ink/build/render-node-to-output.js

@@ -95,12 +95,54 @@ const renderNodeToOutput = (node, output, options) => {
             if (text.length > 0) {
                 const currentWidth = widestLine(text);
                 const maxWidth = getMaxWidth(yogaNode);
+                // [mixdog fork] soft-wrap continuation metadata, parallel to the
+                // FINAL text.split('\n'). softWrap[i]=true means visual line i is a
+                // word-wrap continuation of line i-1 (the '\n' before it was
+                // inserted by wrapText, not present in the source). This is the
+                // ONLY place both the pre-wrap source AND maxWidth are known, so
+                // the flags originate here and ride the write op to output.js,
+                // where the selection copy uses them to rejoin wrapped rows into
+                // their logical source line. Only 'wrap'/'hard' create
+                // continuations; truncate never does.
+                let softWrap;
                 if (currentWidth > maxWidth) {
                     const textWrap = node.style.textWrap ?? 'wrap';
+                    const sourceLines = text.split('\n');
                     text = wrapText(text, maxWidth, textWrap);
+                    if (textWrap === 'wrap' || textWrap === 'hard') {
+                        // Re-wrap each source logical line independently (wrap-ansi
+                        // treats '\n' as a hard break, so per-line wrapping
+                        // reproduces the whole-text row layout) and mark every
+                        // produced line after the first as a continuation.
+                        const flags = [];
+                        for (const line of sourceLines) {
+                            const parts = wrapText(line, maxWidth, textWrap).split('\n');
+                            for (let i = 0; i < parts.length; i++) {
+                                flags.push(i > 0);
+                            }
+                        }
+                        // Guard: if per-line reflow disagrees with the whole-text
+                        // row count, drop the metadata rather than emit a
+                        // misaligned bitmap (output.js then keeps the honest '\n').
+                        if (flags.length === text.split('\n').length) {
+                            softWrap = flags;
+                        }
+                    }
                 }
-                text = applyPaddingToText(node, text);
-                output.write(x, y, text, { transformers: newTransformers });
+                const padded = applyPaddingToText(node, text);
+                if (softWrap) {
+                    // applyPaddingToText prepends offsetY blank lines (never
+                    // continuations) and indents in place. Shift the flags by the
+                    // number of prepended lines so they stay parallel to `padded`.
+                    const added = padded.split('\n').length - text.split('\n').length;
+                    if (added > 0) {
+                        softWrap = new Array(added).fill(false).concat(softWrap);
+                    }
+                    if (softWrap.length !== padded.split('\n').length) {
+                        softWrap = undefined;
+                    }
+                }
+                output.write(x, y, padded, { transformers: newTransformers, softWrap });
             }
             return;
         }

package/vendor/ink/build/render.js

@@ -50,6 +50,10 @@ const render = (node, options) => {
         // store.getRenderSelectionRows so the app can stitch selections taller
         // than the viewport.
         getSelectionRows: () => instance.getSelectionRows(),
+        // [mixdog fork] one-shot full clear+repaint of the next frame; the app
+        // uses it to dismiss Windows Terminal's persistent NATIVE (shift+drag)
+        // selection overlay before starting an app-owned selection.
+        forceFullRepaint: () => instance.forceFullRepaint(),
     };
 };
 export default render;

package/vendor/ink/build/renderer.js

@@ -42,13 +42,16 @@ const renderer = (node, isScreenReaderEnabled, selection) => {
                 skipStaticElements: false,
             });
         }
-        const { output: generatedOutput, height: outputHeight, cursor, selectedText, plainRows } = output.get();
+        const { output: generatedOutput, height: outputHeight, cursor, selectedText, plainRows, selectionRows } = output.get();
         return {
             output: generatedOutput,
             outputHeight,
             cursor, // [mixdog fork] absolute cursor cell from the anchored input node, or null
             selectedText, // [mixdog fork] text inside the drag-selection, or null
             plainRows, // [mixdog fork] column-indexed cell values per row for word lookup
+            selectionRows, // [mixdog fork] per-row {y,text} selection harvest; ink.js caches
+            // it for getSelectionRows() so the app stitch harvest can reach rows
+            // that scrolled out of the viewport. Was dropped here → always null.
             // Newline at the end is needed, because static output doesn't have one, so
             // interactive output will override last line of static output
             staticOutput: staticOutput ? `${staticOutput.get().output}\n` : '',