mixdog 1.3.2 → 1.3.4

package/src/tui/dist/index.mjs

@@ -27484,8 +27484,8 @@ function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
 
 // node_modules/string-width/index.js
 var segmenter = new Intl.Segmenter();
-var zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Format}|\\p{Mark}|\\p{Surrogate})+$", "v");
-var leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+", "v");
+var visibleCharacterRegex = new RegExp("[^\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Nonspacing_Mark}\\p{Enclosing_Mark}\\p{Surrogate}]", "v");
+var spacingMarkRegex = new RegExp("\\p{Spacing_Mark}", "v");
 var rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
 var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
 var extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
@@ -27503,10 +27503,8 @@ function isDoubleWidthNonRgiEmojiSequence(segment) {
   return false;
 }
 function baseVisible(segment) {
-  return segment.replace(leadingNonPrintingRegex, "");
-}
-function isZeroWidthCluster(segment) {
-  return zeroWidthClusterRegex.test(segment);
+  const index = segment.search(visibleCharacterRegex);
+  return index === -1 ? void 0 : segment.slice(index);
 }
 function isHangulLeadingJamo(codePoint) {
   return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
@@ -27523,7 +27521,7 @@ function isHangulJamo(codePoint) {
 function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
   const codePoints = [];
   for (const character of visibleSegment) {
-    if (zeroWidthClusterRegex.test(character)) {
+    if (!visibleCharacterRegex.test(character)) {
       continue;
     }
     codePoints.push(character.codePointAt(0));
@@ -27552,7 +27550,7 @@ function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
   }
   return width;
 }
-function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
   let extra = 0;
   let first = true;
   for (const character of visibleSegment) {
@@ -27560,7 +27558,7 @@ function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
       first = false;
       continue;
     }
-    if (character >= "\uFF00" && character <= "\uFFEF") {
+    if (spacingMarkRegex.test(character) || character >= "\uFF00" && character <= "\uFFEF") {
       extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
     }
   }
@@ -27587,14 +27585,14 @@ function stringWidth(input, options = {}) {
   let width = 0;
   const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
   for (const { segment } of segmenter.segment(string)) {
-    if (isZeroWidthCluster(segment)) {
+    const visibleSegment = baseVisible(segment);
+    if (visibleSegment === void 0) {
       continue;
     }
     if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
       width += 2;
       continue;
     }
-    const visibleSegment = baseVisible(segment);
     const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
     if (hangulWidth !== void 0) {
       width += hangulWidth;
@@ -27602,7 +27600,7 @@ function stringWidth(input, options = {}) {
     }
     const codePoint = visibleSegment.codePointAt(0);
     width += eastAsianWidth(codePoint, eastAsianWidthOptions);
-    width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
   }
   return width;
 }
@@ -27795,12 +27793,8 @@ var ansi_styles_default = ansiStyles;
 
 // node_modules/wrap-ansi/index.js
 var ANSI_ESCAPE = "\x1B";
-var ANSI_ESCAPE_CSI = "\x9B";
-var ESCAPES = /* @__PURE__ */ new Set([
-  ANSI_ESCAPE,
-  ANSI_ESCAPE_CSI
-]);
 var ANSI_ESCAPE_BELL = "\x07";
+var C1_CSI = "\x9B";
 var ANSI_CSI = "[";
 var ANSI_OSC = "]";
 var ANSI_SGR_TERMINATOR = "m";
@@ -27811,47 +27805,168 @@ var ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
 var ANSI_SGR_FOREGROUND_EXTENDED = 38;
 var ANSI_SGR_BACKGROUND_EXTENDED = 48;
 var ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
-var ANSI_SGR_COLOR_MODE_256 = 5;
 var ANSI_SGR_COLOR_MODE_RGB = 2;
-var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
-var ANSI_ESCAPE_REGEX = new RegExp(`^\\u001B(?:\\${ANSI_CSI}(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}|${ANSI_ESCAPE_LINK}(?<uri>[^\\u0007\\u001B]*)(?:\\u0007|\\u001B\\\\))`);
-var ANSI_ESCAPE_CSI_REGEX = new RegExp(`^\\u009B(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}`);
+var ANSI_SGR_COLOR_MODE_256 = 5;
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;`;
+var ESCAPES = /* @__PURE__ */ new Set([
+  ANSI_ESCAPE,
+  C1_CSI
+]);
+var ESCAPE_CHARACTERS = [...ESCAPES].join("");
+var CSI_INTRODUCER = `(?:${ANSI_ESCAPE}\\${ANSI_CSI}|${C1_CSI})`;
+var CSI_PARAMETERS = "[0-?]*[ -/]*[@-~]";
+var SGR_PARAMETERS = `(?<sgr>[0-9;:]*)${ANSI_SGR_TERMINATOR}`;
+var OSC_STRING_TERMINATOR = `(?:${ANSI_ESCAPE_BELL}|${ANSI_ESCAPE}\\\\)`;
+var OSC_STRING_PAYLOAD = String.raw`[^\u0000-\u001F\u007F-\u009F]*`;
+var LINK_PARAMETERS = String.raw`8;(?<parameters>[^;\u0000-\u001F\u007F-\u009F]*);(?<uri>${OSC_STRING_PAYLOAD})${OSC_STRING_TERMINATOR}`;
+var OSC_STRING = `${OSC_STRING_PAYLOAD}${OSC_STRING_TERMINATOR}`;
+var ANSI_ESCAPE_REGEX = new RegExp(
+  `${CSI_INTRODUCER}(?:${SGR_PARAMETERS}|${CSI_PARAMETERS})|${ANSI_ESCAPE}\\${ANSI_OSC}(?:${LINK_PARAMETERS}|${OSC_STRING})`,
+  "y"
+);
 var ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(ansi_styles_default.codes.values());
 ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
 var segmenter2 = new Intl.Segmenter();
-var getGraphemes = (string) => Array.from(segmenter2.segment(string), ({ segment }) => segment);
+var getStringWidth = (string) => stringWidth(string, { countAnsiEscapeCodes: true });
 var TAB_SIZE = 8;
+var ESCAPE_INTRODUCER_REGEX = new RegExp(`[${ESCAPE_CHARACTERS}]`, "g");
+var ROW_BOUNDARY_REGEX = new RegExp(`[\\n${ESCAPE_CHARACTERS}]`, "g");
+var ASCII_PRINTABLE_REGEX = /^[ -~]*$/;
 var wrapAnsiCode = (code) => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-var wrapAnsiHyperlink = (url) => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapAnsiHyperlink = (url, parameters = "") => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${parameters};${url}${ANSI_ESCAPE_BELL}`;
+var matchAnsiEscape = (string, index) => {
+  if (!ESCAPES.has(string[index])) {
+    return;
+  }
+  ANSI_ESCAPE_REGEX.lastIndex = index;
+  return ANSI_ESCAPE_REGEX.exec(string) ?? void 0;
+};
+var forEachSegment = (string, onPlainText, onEscape = () => {
+}) => {
+  let plainStart = 0;
+  let index = 0;
+  while (index < string.length) {
+    ESCAPE_INTRODUCER_REGEX.lastIndex = index;
+    const introducer = ESCAPE_INTRODUCER_REGEX.exec(string);
+    if (!introducer) {
+      break;
+    }
+    const escape3 = matchAnsiEscape(string, introducer.index);
+    if (!escape3) {
+      index = introducer.index + 1;
+      continue;
+    }
+    if (introducer.index > plainStart) {
+      onPlainText(string.slice(plainStart, introducer.index));
+    }
+    onEscape(escape3[0]);
+    index = introducer.index + escape3[0].length;
+    plainStart = index;
+  }
+  if (plainStart < string.length) {
+    onPlainText(string.slice(plainStart));
+  }
+};
+var getWidth = (string) => {
+  let plainText = "";
+  forEachSegment(string, (part) => {
+    plainText += part;
+  });
+  return getStringWidth(plainText);
+};
+var getTokens = (string) => {
+  const tokens = [];
+  forEachSegment(string, (plainText) => {
+    if (ASCII_PRINTABLE_REGEX.test(plainText)) {
+      for (const character of plainText) {
+        tokens.push({ value: character, width: 1 });
+      }
+      return;
+    }
+    for (const { segment } of segmenter2.segment(plainText)) {
+      tokens.push({ value: segment, width: getStringWidth(segment) });
+    }
+  }, (escape3) => {
+    tokens.push({ value: escape3, width: 0 });
+  });
+  return tokens;
+};
+var splitWords = (string) => {
+  let currentWord = { value: "", plainText: "" };
+  const words = [currentWord];
+  forEachSegment(string, (plainText) => {
+    const parts = plainText.split(" ");
+    currentWord.value += parts[0];
+    currentWord.plainText += parts[0];
+    for (let index = 1; index < parts.length; index++) {
+      currentWord = { value: parts[index], plainText: parts[index] };
+      words.push(currentWord);
+    }
+  }, (escape3) => {
+    currentWord.value += escape3;
+  });
+  for (const word of words) {
+    word.width = getStringWidth(word.plainText);
+  }
+  return words;
+};
+var getColonColorToken = (parameter) => {
+  const parts = parameter.split(":");
+  const code = Number.parseInt(parts[0], 10);
+  const mode = Number.parseInt(parts[1], 10);
+  if (![ANSI_SGR_FOREGROUND_EXTENDED, ANSI_SGR_BACKGROUND_EXTENDED, ANSI_SGR_UNDERLINE_COLOR_EXTENDED].includes(code)) {
+    return;
+  }
+  if (mode === ANSI_SGR_COLOR_MODE_256 && parts.length === 3 && /^\d+$/.test(parts[2])) {
+    return { code, open: parameter, hasArguments: true };
+  }
+  if (mode !== ANSI_SGR_COLOR_MODE_RGB) {
+    return;
+  }
+  const components = parts.length === 6 ? parts.slice(3) : parts.slice(2);
+  const colorSpace = parts.length === 6 ? parts[2] : void 0;
+  if (components.length === 3 && components.every((component) => /^\d+$/.test(component)) && (colorSpace === void 0 || /^\d*$/.test(colorSpace))) {
+    return { code, open: parameter, hasArguments: true };
+  }
+};
 var getSgrTokens = (sgrParameters) => {
-  const codes = sgrParameters.split(";").map((sgrParameter) => sgrParameter === "" ? ANSI_SGR_RESET : Number.parseInt(sgrParameter, 10));
+  const parameters = sgrParameters.split(";");
   const sgrTokens = [];
-  for (let index = 0; index < codes.length; index++) {
-    const code = codes[index];
+  for (let index = 0; index < parameters.length; index++) {
+    const parameter = parameters[index];
+    if (parameter.includes(":")) {
+      const colonColorToken = getColonColorToken(parameter);
+      if (colonColorToken) {
+        sgrTokens.push(colonColorToken);
+      }
+      continue;
+    }
+    const code = parameter === "" ? ANSI_SGR_RESET : Number.parseInt(parameter, 10);
     if (!Number.isFinite(code)) {
       continue;
     }
     if (code === ANSI_SGR_FOREGROUND_EXTENDED || code === ANSI_SGR_BACKGROUND_EXTENDED || code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED) {
-      if (index + 1 >= codes.length) {
+      if (index + 1 >= parameters.length) {
         break;
       }
-      const mode = codes[index + 1];
-      if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(codes[index + 2])) {
-        sgrTokens.push([code, mode, codes[index + 2]]);
+      const mode = Number.parseInt(parameters[index + 1], 10);
+      const colorIndex = Number.parseInt(parameters[index + 2], 10);
+      if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(colorIndex)) {
+        sgrTokens.push({ code, open: [code, mode, colorIndex].join(";"), hasArguments: true });
         index += 2;
         continue;
       }
-      const red2 = codes[index + 2];
-      const green2 = codes[index + 3];
-      const blue2 = codes[index + 4];
+      const red2 = Number.parseInt(parameters[index + 2], 10);
+      const green2 = Number.parseInt(parameters[index + 3], 10);
+      const blue2 = Number.parseInt(parameters[index + 4], 10);
       if (mode === ANSI_SGR_COLOR_MODE_RGB && Number.isFinite(red2) && Number.isFinite(green2) && Number.isFinite(blue2)) {
-        sgrTokens.push([code, mode, red2, green2, blue2]);
+        sgrTokens.push({ code, open: [code, mode, red2, green2, blue2].join(";"), hasArguments: true });
         index += 4;
         continue;
       }
       break;
     }
-    sgrTokens.push([code]);
+    sgrTokens.push({ code, open: String(code), hasArguments: false });
   }
   return sgrTokens;
 };
@@ -27873,25 +27988,26 @@ var removeModifierStylesByClose = (activeStyles, closeCode) => {
     }
   }
 };
-var getColorStyle = (code, sgrToken) => {
-  if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && sgrToken.length > 1) {
+var getColorStyle = (sgrToken) => {
+  const { code, open, hasArguments } = sgrToken;
+  if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && hasArguments) {
     return {
       family: "foreground",
-      open: sgrToken.join(";"),
+      open,
       close: ANSI_SGR_RESET_FOREGROUND
     };
   }
-  if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && sgrToken.length > 1) {
+  if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && hasArguments) {
     return {
       family: "background",
-      open: sgrToken.join(";"),
+      open,
       close: ANSI_SGR_RESET_BACKGROUND
     };
   }
-  if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && sgrToken.length > 1) {
+  if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && hasArguments) {
     return {
       family: "underlineColor",
-      open: sgrToken.join(";"),
+      open,
       close: ANSI_SGR_RESET_UNDERLINE_COLOR
     };
   }
@@ -27920,11 +28036,11 @@ var applySgrResetCode = (code, activeStyles) => {
   return false;
 };
 var applySgrToken = (sgrToken, activeStyles) => {
-  const [code] = sgrToken;
+  const { code } = sgrToken;
   if (applySgrResetCode(code, activeStyles)) {
     return;
   }
-  const colorStyle = getColorStyle(code, sgrToken);
+  const colorStyle = getColorStyle(sgrToken);
   if (colorStyle) {
     upsertActiveStyle(activeStyles, colorStyle);
     return;
@@ -27933,7 +28049,7 @@ var applySgrToken = (sgrToken, activeStyles) => {
   if (close !== void 0 && close !== ANSI_SGR_RESET) {
     upsertActiveStyle(activeStyles, {
       family: `modifier-${code}`,
-      open: sgrToken.join(";"),
+      open: sgrToken.open,
       close
     });
   }
@@ -27944,71 +28060,37 @@ var applySgrParameters = (sgrParameters, activeStyles) => {
   }
 };
 var applySgrResets = (sgrParameters, activeStyles) => {
-  for (const sgrToken of getSgrTokens(sgrParameters)) {
-    const [code] = sgrToken;
+  for (const { code } of getSgrTokens(sgrParameters)) {
     applySgrResetCode(code, activeStyles);
   }
 };
-var applyLeadingSgrResets = (string, activeStyles) => {
-  let remainder = string;
-  while (remainder.length > 0) {
-    if (remainder.startsWith(ANSI_ESCAPE) && remainder[1] !== "\\") {
-      const match = ANSI_ESCAPE_REGEX.exec(remainder);
-      if (!match) {
-        break;
-      }
-      if (match.groups.sgr !== void 0) {
-        applySgrResets(match.groups.sgr, activeStyles);
-      }
-      remainder = remainder.slice(match[0].length);
-      continue;
+var applyLeadingSgrResets = (string, startIndex, activeStyles) => {
+  let index = startIndex;
+  while (index < string.length) {
+    const match = matchAnsiEscape(string, index);
+    if (!match) {
+      break;
     }
-    if (remainder.startsWith(ANSI_ESCAPE_CSI)) {
-      const match = ANSI_ESCAPE_CSI_REGEX.exec(remainder);
-      if (!match || match.groups.sgr === void 0) {
-        break;
-      }
+    if (match.groups.sgr !== void 0) {
       applySgrResets(match.groups.sgr, activeStyles);
-      remainder = remainder.slice(match[0].length);
-      continue;
     }
-    break;
+    index += match[0].length;
   }
 };
 var getClosingSgrSequence = (activeStyles) => [...activeStyles].reverse().map((activeStyle) => wrapAnsiCode(activeStyle.close)).join("");
 var getOpeningSgrSequence = (activeStyles) => activeStyles.map((activeStyle) => wrapAnsiCode(activeStyle.open)).join("");
-var wordLengths = (string) => string.split(" ").map((word) => stringWidth(word));
-var wrapWord = (rows2, word, columns) => {
-  const characters = getGraphemes(word);
-  let isInsideEscape = false;
-  let isInsideLinkEscape = false;
-  let visible = stringWidth(stripAnsi(rows2.at(-1)));
-  for (const [index, character] of characters.entries()) {
-    const characterLength = stringWidth(character);
-    if (visible + characterLength <= columns) {
-      rows2[rows2.length - 1] += character;
-    } else {
-      rows2.push(character);
+var wrapWord = (rows2, word, columns, rowWidth) => {
+  const tokens = getTokens(word);
+  let visible = rowWidth;
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.width > 0 && visible > 0 && visible + token.width > columns) {
+      rows2.push("");
       visible = 0;
     }
-    if (ESCAPES.has(character) && !(isInsideLinkEscape && character === ANSI_ESCAPE && characters[index + 1] === "\\")) {
-      isInsideEscape = true;
-      const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join("");
-      isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
-    }
-    if (isInsideEscape) {
-      if (isInsideLinkEscape) {
-        if (character === ANSI_ESCAPE_BELL || character === "\\" && index > 0 && characters[index - 1] === ANSI_ESCAPE) {
-          isInsideEscape = false;
-          isInsideLinkEscape = false;
-        }
-      } else if (character === ANSI_SGR_TERMINATOR) {
-        isInsideEscape = false;
-      }
-      continue;
-    }
-    visible += characterLength;
-    if (visible === columns && index < characters.length - 1) {
+    rows2[rows2.length - 1] += token.value;
+    visible += token.width;
+    if (visible === columns && index < tokens.length - 1) {
       rows2.push("");
       visible = 0;
     }
@@ -28016,54 +28098,134 @@ var wrapWord = (rows2, word, columns) => {
   if (!visible && rows2.at(-1).length > 0 && rows2.length > 1) {
     rows2[rows2.length - 2] += rows2.pop();
   }
+  return getWidth(rows2.at(-1));
 };
 var stringVisibleTrimSpacesRight = (string) => {
-  const words = string.split(" ");
-  let last = words.length;
-  while (last > 0) {
-    if (stringWidth(words[last - 1]) > 0) {
+  if (!string.includes(" ")) {
+    return string;
+  }
+  const segments = [];
+  forEachSegment(string, (plainText) => {
+    segments.push({ value: plainText, isEscape: false });
+  }, (escape3) => {
+    segments.push({ value: escape3, isEscape: true });
+  });
+  for (let index = segments.length - 1; index >= 0; index--) {
+    const segment = segments[index];
+    if (segment.isEscape) {
+      continue;
+    }
+    let end = segment.value.length;
+    while (end > 0 && segment.value[end - 1] === " ") {
+      end--;
+    }
+    segment.value = segment.value.slice(0, end);
+    if (getStringWidth(segment.value) > 0) {
       break;
     }
-    last--;
   }
-  if (last === words.length) {
-    return string;
-  }
-  return words.slice(0, last).join(" ") + words.slice(last).join("");
+  return segments.map((segment) => segment.value).join("");
 };
 var expandTabs = (line) => {
   if (!line.includes("	")) {
     return line;
   }
-  const segments = line.split("	");
   let visible = 0;
   let expandedLine = "";
-  for (const [index, segment] of segments.entries()) {
-    expandedLine += segment;
-    visible += stringWidth(segment);
-    if (index < segments.length - 1) {
-      const spaces = TAB_SIZE - visible % TAB_SIZE;
-      expandedLine += " ".repeat(spaces);
-      visible += spaces;
+  let plainTextSinceTab = "";
+  const expandPlainText = (plainText) => {
+    const segments = plainText.split("	");
+    for (const [index, segment] of segments.entries()) {
+      expandedLine += segment;
+      plainTextSinceTab += segment;
+      if (index < segments.length - 1) {
+        visible += getStringWidth(plainTextSinceTab);
+        plainTextSinceTab = "";
+        const spaces = TAB_SIZE - visible % TAB_SIZE;
+        expandedLine += " ".repeat(spaces);
+        visible += spaces;
+      }
     }
-  }
+  };
+  forEachSegment(line, expandPlainText, (escape3) => {
+    expandedLine += escape3;
+  });
   return expandedLine;
 };
+var restoreStylesAcrossRows = (preString) => {
+  let returnValue = "";
+  let activeHyperlink;
+  const activeStyles = [];
+  let index = 0;
+  let copiedIndex = 0;
+  while (index < preString.length) {
+    ROW_BOUNDARY_REGEX.lastIndex = index;
+    const boundary = ROW_BOUNDARY_REGEX.exec(preString);
+    if (!boundary) {
+      break;
+    }
+    index = boundary.index;
+    if (boundary[0] !== "\n") {
+      const escape3 = matchAnsiEscape(preString, index);
+      if (!escape3) {
+        index++;
+        continue;
+      }
+      const { groups } = escape3;
+      if (groups.sgr !== void 0) {
+        applySgrParameters(groups.sgr, activeStyles);
+      } else if (groups.uri !== void 0) {
+        activeHyperlink = groups.uri.length === 0 ? void 0 : { parameters: groups.parameters, uri: groups.uri };
+      }
+      index += escape3[0].length;
+      continue;
+    }
+    returnValue += preString.slice(copiedIndex, index);
+    if (index > copiedIndex) {
+      if (activeHyperlink) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      returnValue += getClosingSgrSequence(activeStyles);
+    }
+    returnValue += "\n";
+    index++;
+    copiedIndex = index;
+    if (index < preString.length && preString[index] !== "\n") {
+      const openingStyles = [...activeStyles];
+      applyLeadingSgrResets(preString, index, openingStyles);
+      returnValue += getOpeningSgrSequence(openingStyles);
+      if (activeHyperlink) {
+        returnValue += wrapAnsiHyperlink(activeHyperlink.uri, activeHyperlink.parameters);
+      }
+    }
+  }
+  return returnValue + preString.slice(copiedIndex);
+};
 var exec = (string, columns, options = {}) => {
   if (options.trim !== false && string.trim() === "") {
     return "";
   }
-  let returnValue = "";
-  let escapeUrl;
-  const activeStyles = [];
-  const lengths = wordLengths(string);
+  const words = splitWords(string);
   let rows2 = [""];
-  for (const [index, word] of string.split(" ").entries()) {
-    if (options.trim !== false) {
-      rows2[rows2.length - 1] = rows2.at(-1).trimStart();
-    }
-    let rowLength = stringWidth(rows2.at(-1));
-    if (index !== 0) {
+  let rowLength = 0;
+  let trimmedRowIndex = -1;
+  let isFirstWord = true;
+  for (const word of words) {
+    const rowIndex = rows2.length - 1;
+    if (options.trim !== false && trimmedRowIndex !== rowIndex) {
+      const row = rows2[rowIndex];
+      const trimmedRow = row.trimStart();
+      if (trimmedRow.length !== row.length) {
+        rows2[rowIndex] = trimmedRow;
+        rowLength = getWidth(trimmedRow);
+      }
+      if (trimmedRow.length > 0) {
+        trimmedRowIndex = rowIndex;
+      }
+    }
+    if (isFirstWord) {
+      isFirstWord = false;
+    } else {
       if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
         rows2.push("");
         rowLength = 0;
@@ -28073,69 +28235,48 @@ var exec = (string, columns, options = {}) => {
         rowLength++;
       }
     }
-    if (options.hard && options.wordWrap !== false && lengths[index] > columns) {
+    if (options.hard && options.wordWrap !== false && word.width > columns) {
       const remainingColumns = columns - rowLength;
-      const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
-      const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+      const breaksStartingThisLine = 1 + Math.floor((word.width - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((word.width - 1) / columns);
       if (breaksStartingNextLine < breaksStartingThisLine) {
         rows2.push("");
+        rowLength = 0;
       }
-      wrapWord(rows2, word, columns);
+      rowLength = wrapWord(rows2, word.value, columns, rowLength);
       continue;
     }
-    if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+    if (rowLength + word.width > columns && rowLength > 0 && word.width > 0) {
       if (options.wordWrap === false && rowLength < columns) {
-        wrapWord(rows2, word, columns);
+        rowLength = wrapWord(rows2, word.value, columns, rowLength);
         continue;
       }
       rows2.push("");
+      rowLength = 0;
     }
-    if (rowLength + lengths[index] > columns && options.wordWrap === false) {
-      wrapWord(rows2, word, columns);
+    if (rowLength + word.width > columns && options.wordWrap === false) {
+      rowLength = wrapWord(rows2, word.value, columns, rowLength);
       continue;
     }
-    rows2[rows2.length - 1] += word;
+    rows2[rows2.length - 1] += word.value;
+    rowLength += word.width;
   }
   if (options.trim !== false) {
     rows2 = rows2.map((row) => stringVisibleTrimSpacesRight(row));
   }
-  const preString = rows2.join("\n");
-  const pre = getGraphemes(preString);
-  let preStringIndex = 0;
-  for (const [index, character] of pre.entries()) {
-    returnValue += character;
-    if (character === ANSI_ESCAPE && pre[index + 1] !== "\\") {
-      const { groups } = ANSI_ESCAPE_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
-      if (groups.sgr !== void 0) {
-        applySgrParameters(groups.sgr, activeStyles);
-      } else if (groups.uri !== void 0) {
-        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
-      }
-    } else if (character === ANSI_ESCAPE_CSI) {
-      const { groups } = ANSI_ESCAPE_CSI_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
-      if (groups.sgr !== void 0) {
-        applySgrParameters(groups.sgr, activeStyles);
-      }
-    }
-    if (pre[index + 1] === "\n") {
-      if (escapeUrl) {
-        returnValue += wrapAnsiHyperlink("");
-      }
-      returnValue += getClosingSgrSequence(activeStyles);
-    } else if (character === "\n") {
-      const openingStyles = [...activeStyles];
-      applyLeadingSgrResets(preString.slice(preStringIndex + 1), openingStyles);
-      returnValue += getOpeningSgrSequence(openingStyles);
-      if (escapeUrl) {
-        returnValue += wrapAnsiHyperlink(escapeUrl);
-      }
-    }
-    preStringIndex += character.length;
-  }
-  return returnValue;
+  return restoreStylesAcrossRows(rows2.join("\n"));
+};
+var normalizeText = (string) => {
+  let normalizedString = "";
+  forEachSegment(string, (plainText) => {
+    normalizedString += plainText.normalize();
+  }, (escape3) => {
+    normalizedString += escape3;
+  });
+  return normalizedString;
 };
 function wrapAnsi(string, columns, options) {
-  return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
+  return normalizeText(String(string)).replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
 }
 
 // node_modules/terminal-size/index.js
@@ -41529,6 +41670,14 @@ function gitStageUnit(a) {
     effect: true
   });
 }
+function gitWorktreeUnit(a) {
+  return unitDescriptor("Git", {
+    active: "Managing",
+    done: "Managed",
+    noun: "worktree",
+    effect: String(a.worktree_action || "").toLowerCase() !== "list"
+  });
+}
 function cwdUnit(a) {
   const action = String(a.action || a.type || "").toLowerCase();
   if (action === "set" || action === "set-project" || !action && a.path) {
@@ -41559,14 +41708,6 @@ function cwdUnit(a) {
     const [active, done] = words;
     return unitDescriptor("Setup", { active, done, noun: "session", effect: true });
   }
-  if (action.endsWith("-worktree") || action.endsWith("-worktrees")) {
-    return unitDescriptor("Setup", {
-      active: "Managing",
-      done: "Managed",
-      noun: "worktree",
-      effect: !action.startsWith("list")
-    });
-  }
   if (action === "status") {
     return unitDescriptor("Setup", { active: "Checking", done: "Checked", noun: "session" });
   }
@@ -41661,7 +41802,7 @@ var TOOL_UNITS = /* @__PURE__ */ new Map([
   ["job_wait", shellUnit],
   [
     "git",
-    (a) => a.action === "stage" ? gitStageUnit(a) : unitDescriptor("Git", { count: queryCount(a, "command", "commands") || 1, noun: "Git command" })
+    (a) => a.action === "stage" ? gitStageUnit(a) : a.action === "worktree" ? gitWorktreeUnit(a) : unitDescriptor("Git", { count: queryCount(a, "command", "commands") || 1, noun: "Git command" })
   ],
   ["github", githubUnit],
   // Preserve the staging work unit when rendering historical transcripts.
@@ -47542,17 +47683,14 @@ async function resizeImageBuffer(buffer, ext, { maxTokens = DEFAULT_IMAGE_MAX_TO
 var TOOL_IMAGE_TARGET_BASE64_SIZE = 256 * 1024;
 
 // src/tui/paste-text-policy.mjs
-var PASTE_TOKEN_MIN_LINES = 10;
-var PASTE_TOKEN_MIN_CHARS = 200;
+var PASTE_TOKEN_MIN_CHARS = 1e3;
 function pastedTextLineCount(text) {
   const value = String(text ?? "").replace(/\r\n?/g, "\n").replace(/\n+$/, "");
   if (!value) return 0;
   return value.split("\n").length;
 }
 function shouldFoldPastedText(text) {
-  const value = String(text ?? "");
-  if (!value) return false;
-  return pastedTextLineCount(value) >= PASTE_TOKEN_MIN_LINES || value.length > PASTE_TOKEN_MIN_CHARS;
+  return String(text ?? "").length > PASTE_TOKEN_MIN_CHARS;
 }
 function formatPastedTextRef(id, text) {
   return `[Pasted text #${id} +${pastedTextLineCount(text)} lines]`;
@@ -59570,6 +59708,15 @@ var loadProviderDisplayNames = async (store) => {
   }
   return names;
 };
+var catalogProviderDisplayNames = (models, setupNames = null) => {
+  const names = {};
+  for (const model of Array.isArray(models) ? models : []) {
+    const provider = String(model?.provider || "").trim();
+    const name = String(model?.providerName || "").trim();
+    if (provider.startsWith("custom-") && name) names[provider] = name;
+  }
+  return { ...names, ...setupNames };
+};
 var loadProviderCatalogFailures = async (store) => {
   let setup = null;
   try {
@@ -59683,9 +59830,9 @@ var routeSpeedLabel = (route) => {
   return route.modelParameters?.serviceTier === "ultrafast" ? "Ultrafast" : "Fast";
 };
 var routeModelDetails = (route) => [routeModelDisplayName(route), route.effort ? effortDisplayLabel(route.effort) : "", routeSpeedLabel(route)].filter(Boolean).join(" \xB7 ");
-var routeLabel = (route) => {
+var routeLabel = (route, providerNames = null) => {
   if (!route?.provider || !route?.model) return "(unset)";
-  return [providerDisplayName(route.provider), routeModelDetails(route)].filter(Boolean).join(" \xB7 ");
+  return [resolveProviderDisplayName(route.provider, providerNames), routeModelDetails(route)].filter(Boolean).join(" \xB7 ");
 };
 var routeModelLabel = (route) => route?.model ? routeModelDetails(route) : "(unset)";
 var agentModelProfile = (route) => route?.model ? routeModelDetails(route) : "";
@@ -61162,7 +61309,7 @@ function createModelPicker({
       return;
     }
     const models = normalizeModelOptions(providerModels);
-    const providerNames = await loadProviderDisplayNames(store);
+    const providerNames = catalogProviderDisplayNames(models, await loadProviderDisplayNames(store));
     const catalogFailures = await loadProviderCatalogFailures(store);
     const activeRoute = options.currentRoute || {
       provider: state.provider,
@@ -61590,7 +61737,8 @@ function createRoutePickers({
           store.pushNotice("Web-search model save is already running.", "warn");
           return;
         }
-        store.pushNotice(`Web-search model set to ${routeLabel2(result)}`, "info");
+        const providerNames = await loadProviderDisplayNames(store);
+        store.pushNotice(`Web-search model set to ${routeLabel2(result, providerNames)}`, "info");
         return result;
       },
       onAfterSelect: null
@@ -61950,8 +62098,16 @@ function copyTree(src, dst, copied) {
   writeFileAtomicSync(dst, readFileSync10(src), { mode: st.mode & 511 });
   copied.push(dst);
 }
+var manifestPath = (scopeDir, name) => join11(scopeDir, name, BACKUP_MANIFEST);
 function pruneBackups(scopeDir, names, own) {
-  for (const name of backupsToPrune(names, own)) {
+  const completed = names.filter((name) => {
+    try {
+      return statSync4(manifestPath(scopeDir, name)).isFile();
+    } catch {
+      return false;
+    }
+  });
+  for (const name of backupsToPrune(completed, own)) {
     try {
       rmSync(join11(scopeDir, name), { recursive: true, force: true });
     } catch {
@@ -62001,16 +62157,24 @@ function backupUserData(dataDir2, reason = "snapshot", { dirs = [] } = {}) {
   const scopeDir = scopeDirFor(dataDir2);
   const { backupDir, names } = reserveBackupDir(scopeDir, reason);
   const copied = [];
-  for (const rel of USER_DATA_FILES) {
-    const src = join11(dataDir2, rel);
-    if (existsSync9(src)) copyTree(src, join11(backupDir, rel), copied);
-  }
-  for (const rel of [...USER_DATA_DIRS, ...dirs]) {
-    const src = join11(dataDir2, rel);
-    if (existsSync9(src)) copyTree(src, join11(backupDir, rel), copied);
+  try {
+    for (const rel of USER_DATA_FILES) {
+      const src = join11(dataDir2, rel);
+      if (existsSync9(src)) copyTree(src, join11(backupDir, rel), copied);
+    }
+    for (const rel of [...USER_DATA_DIRS, ...dirs]) {
+      const src = join11(dataDir2, rel);
+      if (existsSync9(src)) copyTree(src, join11(backupDir, rel), copied);
+    }
+    if (copied.length > 0) finishBackup(dataDir2, backupDir, reason);
+  } catch (error) {
+    try {
+      rmSync(backupDir, { recursive: true, force: true });
+    } catch {
+    }
+    throw error;
   }
   if (copied.length > 0) {
-    finishBackup(dataDir2, backupDir, reason);
     pruneBackups(scopeDir, names, basename5(backupDir));
     if (process.env.MIXDOG_SETUP_QUIET !== "1") {
       process.stderr.write(`[user-data-backup] ${reason}: copied ${copied.length} file(s) to ${backupDir}
@@ -62034,7 +62198,14 @@ async function copyTreeAsync(src, dst, copied) {
   copied.push(dst);
 }
 async function pruneBackupsAsync(scopeDir, names, own) {
-  for (const name of backupsToPrune(names, own)) {
+  const completed = [];
+  for (const name of names) {
+    try {
+      if ((await statP(manifestPath(scopeDir, name))).isFile()) completed.push(name);
+    } catch {
+    }
+  }
+  for (const name of backupsToPrune(completed, own)) {
     try {
       await rmP(join11(scopeDir, name), { recursive: true, force: true });
     } catch {
@@ -62047,16 +62218,24 @@ async function backupUserDataAsync(dataDir2, reason = "snapshot") {
   const scopeDir = scopeDirFor(dataDir2);
   const { backupDir, names } = await reserveBackupDirAsync(scopeDir, reason);
   const copied = [];
-  for (const rel of USER_DATA_FILES) {
-    const src = join11(dataDir2, rel);
-    if (existsSync9(src)) await copyTreeAsync(src, join11(backupDir, rel), copied);
-  }
-  for (const rel of USER_DATA_DIRS) {
-    const src = join11(dataDir2, rel);
-    if (existsSync9(src)) await copyTreeAsync(src, join11(backupDir, rel), copied);
+  try {
+    for (const rel of USER_DATA_FILES) {
+      const src = join11(dataDir2, rel);
+      if (existsSync9(src)) await copyTreeAsync(src, join11(backupDir, rel), copied);
+    }
+    for (const rel of USER_DATA_DIRS) {
+      const src = join11(dataDir2, rel);
+      if (existsSync9(src)) await copyTreeAsync(src, join11(backupDir, rel), copied);
+    }
+    if (copied.length > 0) finishBackup(dataDir2, backupDir, reason);
+  } catch (error) {
+    try {
+      await rmP(backupDir, { recursive: true, force: true });
+    } catch {
+    }
+    throw error;
   }
   if (copied.length > 0) {
-    finishBackup(dataDir2, backupDir, reason);
     await pruneBackupsAsync(scopeDir, names, basename5(backupDir));
     if (process.env.MIXDOG_SETUP_QUIET !== "1") {
       process.stderr.write(`[user-data-backup] ${reason}: copied ${copied.length} file(s) to ${backupDir}
@@ -63969,7 +64148,9 @@ function useMessageSelector({
   setPromptDraftOverride,
   syncPromptLayoutRows,
   showPromptHint,
-  clearPromptHint
+  clearPromptHint,
+  installPastedImages,
+  installPastedTexts
 }) {
   const hasUserMessages = useMemo7(
     () => (Array.isArray(state.items) ? state.items : []).some(
@@ -63985,11 +64166,21 @@ function useMessageSelector({
         return false;
       }
       clearPromptHint();
+      if (restored.pastedImages) installPastedImages?.(restored.pastedImages, { merge: true });
+      if (restored.pastedTexts) installPastedTexts?.(restored.pastedTexts, { merge: true });
       syncPromptLayoutRows(text);
       setPromptDraftOverride({ id: Date.now(), value: text });
+      if (restored.notice) showPromptHint(restored.notice, "error");
       return true;
     },
-    [clearPromptHint, syncPromptLayoutRows, setPromptDraftOverride, showPromptHint]
+    [
+      clearPromptHint,
+      syncPromptLayoutRows,
+      setPromptDraftOverride,
+      showPromptHint,
+      installPastedImages,
+      installPastedTexts
+    ]
   );
   const openMessageSelector = useCallback20(() => {
     const items = store.getState?.().items ?? state.items;
@@ -64009,7 +64200,7 @@ function useMessageSelector({
         own.close();
         let restored;
         try {
-          restored = store.rewindToItem?.(value);
+          restored = store.rewindToItem?.(value, { restoreFiles: false });
         } catch (error) {
           showPromptHint(`rewind failed: ${error?.message || error}`, "error");
           return;
@@ -65920,7 +66111,9 @@ function App2({ store, initialStatusLine = "", forceOnboarding = false, onboardi
     setPromptDraftOverride,
     syncPromptLayoutRows,
     showPromptHint,
-    clearPromptHint
+    clearPromptHint,
+    installPastedImages,
+    installPastedTexts
   });
   const { handlePromptPaste, handlePromptHistoryNavigate, handlePromptEscape, handlePromptInterrupt } = usePromptHandlers({
     store,