agy-powerline 1.2.0 → 1.4.0

package/src/lib/layouts/pills.js

@@ -7,11 +7,15 @@ const {
   bgDefault,
   fg,
   BOLD,
+  DIM,
   NORMAL,
   BLINK,
   BLINK_OFF,
   getActiveDepth,
+  gradientColors,
+  readableText,
 } = require("../colors");
+const { gradientStops } = require("../themes");
 const { pickGlyph, glyphChar } = require("../powerline");
 const {
   quotaColor,
@@ -23,7 +27,11 @@ const {
   formatContextTokens,
   shortModelName,
   formatTokenSplit,
+  formatUsage,
   formatGitSync,
+  formatGitOperation,
+  gitChangeParts,
+  gitFileParts,
   formatTasks,
   formatMode,
   clipText,
@@ -35,12 +43,15 @@ const {
   paceIndex,
   paceGlyph,
 } = require("../formatters");
-const { execWidgetOutput } = require("../exec");
+const { execWidgetOutput, restoreAfterReset } = require("../exec");
 const {
+  resolveColor,
   widgetColors,
   widgetTag,
   isRaw,
   isPaced,
+  METER_STYLES,
+  meterStyle,
   hasNoData,
   RAM_CAUTION,
   RAM_DANGER,
@@ -56,6 +67,14 @@ function fillMeter(pct, width, fillColor, emptyColor, segmentColor, pace = {}) {
   const ratio = Math.max(0, Math.min(100, Number(pct))) / 100;
   const used = Math.round(ratio * width);
   const marker = paceIndex(pace.elapsedPct, width);
+  // pips, the default, needs a Unicode font: ASCII mode keeps the cells.
+  const pips = pace.style === "pips";
+  if (pips && !pace.ascii && getActiveDepth() !== "none") {
+    return pipMeter(used, marker, width, fillColor, emptyColor) + bg(segmentColor);
+  }
+  if (METER_STYLES[pace.style] && !(pips && pace.ascii)) {
+    return glyphMeter(used, marker, width, METER_STYLES[pace.style], pace);
+  }
   // The fill is a background color; without color it is drawn with glyphs.
   const plain = getActiveDepth() === "none";
   const glyph = (filled) => (!plain ? " " : pace.ascii ? (filled ? "#" : "-") : filled ? "█" : "░");
@@ -73,6 +92,51 @@ function fillMeter(pct, width, fillColor, emptyColor, segmentColor, pace = {}) {
   return meter + bg(segmentColor);
 }
 
+// Small dots on the pill's own color: the filled ones in the light fill color,
+// the rest in the dark track color, the same pair cells use. The pace marker
+// is a larger dot in the other color, so nothing in the meter is a line.
+function pipMeter(used, marker, width, fillColor, emptyColor) {
+  let meter = "";
+  let color = null;
+
+  for (let i = 0; i < width; i++) {
+    const filled = i < used;
+    const next = i === marker ? (filled ? emptyColor : fillColor) : filled ? fillColor : emptyColor;
+    if (next !== color) {
+      meter += fg(next);
+      color = next;
+    }
+    meter += i === marker ? METER_STYLES.pips[2] : METER_STYLES.pips[0];
+  }
+
+  return meter;
+}
+
+// A glyph style draws on the pill's own color, with no cells: filled glyphs in
+// the pill's text color (readable on the pill, gradients included), empty
+// ones in the same color dimmed. ASCII mode keeps # and -.
+function glyphMeter(used, marker, width, [full, empty, pace], { ascii, textColor }) {
+  let meter = fg(textColor);
+  let dim = false;
+
+  for (let i = 0; i < width; i++) {
+    const blank = i !== marker && i >= used;
+    if (blank !== dim) {
+      meter += blank ? DIM : NORMAL;
+      dim = blank;
+    }
+    if (i === marker) {
+      meter += (!ascii && pace) || paceGlyph(ascii);
+    } else if (ascii) {
+      meter += blank ? "-" : "#";
+    } else {
+      meter += blank ? empty : full;
+    }
+  }
+
+  return dim ? meter + NORMAL : meter;
+}
+
 function meterSegment(
   color,
   pct,
@@ -437,14 +501,52 @@ function buildSegment(id, session, colors, emojis, ascii = false, widget = {}, c
         return null;
       }
       const mark = session.git.dirty ? `${ascii ? "* " : "● "}` : "";
+      const opStr = widget.operation === false ? "" : formatGitOperation(session.git.operation);
+      const opPart = opStr ? `|${opStr}` : "";
       const syncStr = formatGitSync(session.git.ahead, session.git.behind, ascii);
       const syncPart = syncStr ? ` ${syncStr}` : "";
       return pill(
         session.git.dirty ? colors.gitDirty : colors.git,
-        lbl(`${mark}${session.git.branch}${syncPart}`)
+        lbl(`${mark}${session.git.branch}${opPart}${syncPart}`)
       );
     }
 
+    case "gitChanges": {
+      const parts = gitChangeParts(session.gitDetails?.changes, ascii);
+      if (!parts.length) {
+        return null;
+      }
+      return pill(colors.git, lbl(parts.map((part) => part.text).join(" ")));
+    }
+
+    case "gitFiles": {
+      const files = session.gitDetails?.files;
+      const parts = gitFileParts(files, ascii);
+      if (!parts.length) {
+        return null;
+      }
+      const color = files.conflicts > 0 ? colors.gitDirty : colors.git;
+      return pill(color, lbl(parts.map((part) => part.text).join(" ")));
+    }
+
+    case "gitSha":
+      if (!session.gitDetails?.sha) {
+        return null;
+      }
+      return pill(colors.git, lbl(session.gitDetails.sha));
+
+    case "gitStash":
+      if (!(session.gitDetails?.stash > 0)) {
+        return null;
+      }
+      return pill(colors.git, lbl(String(session.gitDetails.stash)));
+
+    case "gitWorktree":
+      if (!session.gitDetails?.worktree) {
+        return null;
+      }
+      return pill(colors.git, lbl(session.gitDetails.worktree));
+
     case "plan":
       if (!session.plan) {
         return null;
@@ -547,6 +649,32 @@ function buildSegment(id, session, colors, emojis, ascii = false, widget = {}, c
         )
       );
 
+    case "tokensToday":
+    case "tokensWeek": {
+      const usage = formatUsage(
+        session.usage?.[id === "tokensToday" ? "today" : "week"],
+        widget,
+        ascii
+      );
+      if (!usage) {
+        return null;
+      }
+      if (usage.pct === null) {
+        return pill(colors.meta, lbl(usage.text));
+      }
+      // A budget alerts like the context widgets: caution, then danger.
+      const thresh = resolveContextThresholds(widget, config);
+      const level =
+        usage.pct >= thresh.crit ? "crit" : usage.pct >= thresh.warn ? "warn" : "normal";
+      const color = contextColor(usage.pct, colors.meta, false, {
+        crit: thresh.crit,
+        warn: thresh.warn,
+        critColor: colors.warn,
+        warnColor: colors.caution,
+      });
+      return pill(color, lbl(usage.text), !ascii && shouldBlink(level, thresh.blink));
+    }
+
     case "customText": {
       if (!widget?.text) {
         return null;
@@ -573,11 +701,57 @@ function buildSegment(id, session, colors, emojis, ascii = false, widget = {}, c
   }
 }
 
+// Pill text on a gradient color that the theme's text doesn't read on.
+const READABLE_TEXT = [[22, 22, 28], WHITE, [0, 0, 0]];
+
 function buildRows(session, config, colors) {
   const rows = [];
   let groups = [];
   let current = [];
-  const splitEveryWidget = !config.powerline.enabled;
+  // The widgets shown in the current row, so a gradient can be spread over
+  // exactly those once the row is complete.
+  let placed = [];
+  const gradient = gradientStops(config.gradient);
+
+  function styledSegment(widget, ownColors) {
+    const segment = buildSegment(
+      widget.id,
+      session,
+      ownColors,
+      config.emojis,
+      config.ascii === true,
+      widget,
+      config
+    );
+    if (segment) {
+      segment.textColor = ownColors.text;
+      segment.bold = widget.bold !== false;
+      if (segment.meter) {
+        segment.style = meterStyle(widget, config, "pills");
+      }
+    }
+    return segment;
+  }
+
+  // Each widget takes its step of the gradient in place of its identity
+  // color; alert colors and a widget's own color stay as they are.
+  function applyGradient() {
+    const shades = gradientColors(gradient, placed.length);
+    placed.forEach(({ widget, group, index }, i) => {
+      if (resolveColor(widget.color, colors)) {
+        return;
+      }
+      const ownColors = widgetColors({ ...widget, color: shades[i] }, colors);
+      const segment = styledSegment(widget, ownColors);
+      if (!segment) {
+        return;
+      }
+      if (!resolveColor(widget.textColor, colors)) {
+        segment.textColor = readableText(segment.color, ownColors.text, READABLE_TEXT);
+      }
+      group[index] = segment;
+    });
+  }
 
   function flushGroup() {
     if (current.length) {
@@ -589,6 +763,11 @@ function buildRows(session, config, colors) {
   function flushRow() {
     flushGroup();
 
+    if (gradient && placed.length) {
+      applyGradient();
+    }
+    placed = [];
+
     if (groups.length) {
       rows.push(groups);
       groups = [];
@@ -606,29 +785,14 @@ function buildRows(session, config, colors) {
       continue;
     }
 
-    const ownColors = widgetColors(widget, colors);
-    const segment = buildSegment(
-      widget.id,
-      session,
-      ownColors,
-      config.emojis,
-      config.ascii === true,
-      widget,
-      config
-    );
+    const segment = styledSegment(widget, widgetColors(widget, colors));
 
     if (!segment) {
       continue;
     }
 
-    segment.textColor = ownColors.text;
-    segment.bold = widget.bold !== false;
-
-    if (splitEveryWidget) {
-      groups.push([segment]);
-    } else {
-      current.push(segment);
-    }
+    placed.push({ widget, group: current, index: current.length });
+    current.push(segment);
   }
 
   flushRow();
@@ -649,20 +813,36 @@ function rightCap(color, terminal, glyph) {
   return glyph ? fg(color) + capBackground(terminal) + glyph : "";
 }
 
+// Compared as the terminal will draw them: at 256 colors two different colors
+// can land on the same code, and without color everything is the same.
 function sameColor(a, b) {
-  return String(a) === String(b);
+  return bg(a) === bg(b);
+}
+
+// Each solid Powerline glyph (U+E0B0 to U+E0BE, even code points) has a thin
+// outline twin at the next code point. The round twins are drawn shorter than
+// the cell in many Nerd Fonts, so round joins use a box-drawing line, which
+// spans the full height.
+function thinGlyph(glyph) {
+  const code = glyph.codePointAt(0);
+  if (glyph.length !== 1 || code < 0xe0b0 || code > 0xe0be || code % 2 !== 0) {
+    return glyph;
+  }
+  return code === 0xe0b4 || code === 0xe0b6 ? "│" : String.fromCodePoint(code + 1);
 }
 
 // A separator between two widgets of the same color would vanish, so it is
-// drawn in the text color instead. Inverted separators (meant for
+// drawn as its thin outline in the text color instead, the way Powerline
+// divides one color. ASCII joins are characters, not shapes, so they take the
+// text color too, which reads on any pill. Inverted separators (meant for
 // left-pointing glyphs) take the next widget's color on the previous one's.
-function joinSegments(previous, next, glyph, invert, textColor) {
+function joinSegments(previous, next, glyph, invert, textColor, ascii = false) {
   if (!glyph) {
     return "";
   }
 
-  if (sameColor(previous.color, next.color)) {
-    return fg(next.textColor || textColor) + bg(next.color) + glyph;
+  if (ascii || sameColor(previous.color, next.color)) {
+    return fg(next.textColor || textColor) + bg(next.color) + thinGlyph(glyph);
   }
 
   return invert
@@ -674,7 +854,9 @@ function segmentContent(text, color, textColor, blink = false, bold = true) {
   const blinkSeq = blink ? BLINK : "";
   const blinkOff = blink ? BLINK_OFF : "";
   // NORMAL clears bold left over from a previous widget.
-  return bg(color) + fg(textColor) + blinkSeq + (bold ? BOLD : NORMAL) + text + blinkOff;
+  const style = bg(color) + fg(textColor) + blinkSeq + (bold ? BOLD : NORMAL);
+  // Only exec output with "colors": true still holds escapes here.
+  return style + (text.includes("\x1b") ? restoreAfterReset(text, style) : text) + blinkOff;
 }
 
 function renderMeterSegment(segment, colors, ascii = false) {
@@ -685,6 +867,8 @@ function renderMeterSegment(segment, colors, ascii = false) {
   const meter = fillMeter(displayPct, 12, segment.fill, segment.empty, segment.color, {
     elapsedPct: segment.elapsedPct,
     ascii,
+    style: segment.style,
+    textColor,
   });
   const bold = segment.bold !== false;
 
@@ -697,13 +881,19 @@ function renderMeterSegment(segment, colors, ascii = false) {
 
 // Caps cycle per pill and separators per join, counted across the whole
 // statusline, so lists with several glyphs alternate from left to right.
+// Glyphs are drawn without bold, which some fonts draw wider or shifted, and
+// the pill ends on the terminal's background so the padding after it stays
+// clear even without an end cap. Without color, solid caps would be blobs of
+// text color, so only ASCII brackets are kept.
 function renderGroup(group, colors, config, counters = { pill: 0, separator: 0 }) {
   const { powerline } = config;
   const ascii = config.ascii === true;
   const terminal = colors.terminal;
   const pillIndex = counters.pill++;
-  const startCap = glyphChar(pickGlyph(powerline.startCaps, pillIndex), "startCap", ascii);
-  const endCap = glyphChar(pickGlyph(powerline.endCaps, pillIndex), "endCap", ascii);
+  const caps = ascii || getActiveDepth() !== "none";
+  const cap = (list, slot) => (caps ? glyphChar(pickGlyph(list, pillIndex), slot, ascii) : "");
+  const startCap = cap(powerline.startCaps, "startCap");
+  const endCap = cap(powerline.endCaps, "endCap");
 
   let out = leftCap(group[0].color, terminal, startCap);
 
@@ -724,13 +914,22 @@ function renderGroup(group, colors, config, counters = { pill: 0, separator: 0 }
       const slot = counters.separator++;
       const glyph = glyphChar(pickGlyph(powerline.separators, slot), "separator", ascii);
       const invert = powerline.separatorInvert[slot % (powerline.separators.length || 1)];
-      out += joinSegments(segment, group[i + 1], glyph, invert === true, colors.text);
+      out +=
+        NORMAL + joinSegments(segment, group[i + 1], glyph, invert === true, colors.text, ascii);
     }
   }
 
-  out += rightCap(group[group.length - 1].color, terminal, endCap);
+  const last = group[group.length - 1].color;
+  return out + NORMAL + (endCap ? rightCap(last, terminal, endCap) : capBackground(terminal));
+}
 
-  return out;
+// With joins off every widget is a pill of its own, one space from the next;
+// the Flex Separator still decides where the row opens up.
+function renderPills(group, colors, config, counters) {
+  if (config.powerline.enabled) {
+    return renderGroup(group, colors, config, counters);
+  }
+  return group.map((segment) => renderGroup([segment], colors, config, counters)).join(" ");
 }
 
 function joinFlex(parts, terminalWidth) {
@@ -768,7 +967,7 @@ function renderPillRows(rows, session, colors, config) {
   return rows
     .map((row) =>
       joinFlex(
-        row.map((group) => renderGroup(group, colors, config, counters)),
+        row.map((group) => renderPills(group, colors, config, counters)),
         session.terminalWidth
       )
     )

package/src/lib/paths.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
@@ -25,6 +27,7 @@ const RUNTIME_FILES = [
   "fit.js",
   "log.js",
   "payload-dump.js",
+  "usage.js",
   path.join("layouts", "lines.js"),
   path.join("layouts", "pills.js"),
 ];
@@ -34,10 +37,17 @@ const RUNTIME_FILES = [
 // machine can't read them (Windows profile folders are private already).
 const PRIVATE_FILES = [
   "statusline.config.json",
+  // The config before the last import (BACKUP_SUFFIX in cli/import.js).
+  "statusline.config.json.bak",
   ".exec-cache.json",
   "last-payload.json",
   // SYNC_CACHE_NAME in git.js: commit IDs of the repos you work in.
   ".git-sync-cache.json",
+  // STATUS_CACHE_NAME in git.js: repo paths with their file and line counts.
+  ".git-status-cache.json",
+  // USAGE_CACHE_NAME in usage.js: tokens per day, keyed by a hash of each
+  // conversation database's path.
+  ".usage-cache.json",
   // LOG_NAME in log.js, spelled out because log.js requires this file.
   "agy-powerline.log",
 ];
@@ -238,15 +248,54 @@ function settingsBackupPath(file = AGY_SETTINGS) {
   return `${file}.agy-powerline.bak`;
 }
 
-// Backs up the current file, then writes atomically.
-function writeJsonSafely(file, data) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
+function settingsOriginalBackupPath(file = AGY_SETTINGS) {
+  return `${file}.agy-powerline.original.bak`;
+}
 
-  if (fs.existsSync(file)) {
-    fs.copyFileSync(file, settingsBackupPath(file));
+// Two copies before every change: the latest file, replaced each time, and
+// the file as it was before agy-powerline first changed it, written once and
+// never replaced, so running init again can't lose the user's own version.
+// Returns the original backup's path when this call created it.
+function backUpSettings(file) {
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  const original = settingsOriginalBackupPath(file);
+  const created = !fs.existsSync(original);
+  if (created) {
+    fs.copyFileSync(file, original);
   }
+  fs.copyFileSync(file, settingsBackupPath(file));
+  return created ? original : null;
+}
 
+// Backs up the current file, then writes atomically. Returns what
+// backUpSettings() returns.
+function writeJsonSafely(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const originalBackup = backUpSettings(file);
   writeFileAtomic(file, JSON.stringify(data, null, 2) + "\n");
+  return originalBackup;
+}
+
+// Dotfile managers (stow, chezmoi, yadm) link files such as settings.json
+// into place. A write goes through the link to the file it points to, so the
+// link stays a link and the user's real file gets the change; a rename onto
+// the link itself would replace it with a plain file.
+function writeTarget(file) {
+  try {
+    return fs.realpathSync(file);
+  } catch {
+    // Missing file, or a link whose target doesn't exist yet: follow it once.
+    try {
+      if (fs.lstatSync(file).isSymbolicLink()) {
+        return path.resolve(path.dirname(file), fs.readlinkSync(file));
+      }
+    } catch {
+      // Nothing at that path.
+    }
+    return file;
+  }
 }
 
 // Writes via temp file + rename so an interrupted write cannot leave a
@@ -254,9 +303,10 @@ function writeJsonSafely(file, data) {
 // mode the existing file had, so rewriting a file never widens who can read
 // it (the rename would otherwise reset it to the default).
 function writeFileAtomic(file, body, { mode } = {}) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.tmp`;
-  const target = process.platform === "win32" ? undefined : (mode ?? existingMode(file));
+  const dest = writeTarget(file);
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  const tmp = `${dest}.${process.pid}.tmp`;
+  const target = process.platform === "win32" ? undefined : (mode ?? existingMode(dest));
   fs.writeFileSync(tmp, body, { encoding: "utf8", mode: target ?? 0o666 });
   if (target !== undefined) {
     // The mode passed to writeFileSync is reduced by the umask; set it exactly.
@@ -270,10 +320,10 @@ function writeFileAtomic(file, body, { mode } = {}) {
   }
 
   try {
-    fs.renameSync(tmp, file);
+    fs.renameSync(tmp, dest);
   } catch {
     // Windows can refuse to replace a file another process holds open.
-    fs.writeFileSync(file, body, "utf8");
+    fs.writeFileSync(dest, body, "utf8");
     fs.rmSync(tmp, { force: true });
   }
 }
@@ -301,11 +351,20 @@ function restrictPrivateFiles(installDir) {
   }
 }
 
+// Removes a settings.json that would be left empty. A symlinked one is emptied
+// instead: deleting the link would break the user's dotfiles and leave the
+// real file unchanged. Returns "deleted", "emptied" or null (nothing there).
 function removeSettingsFile(file = AGY_SETTINGS) {
-  if (fs.existsSync(file)) {
-    fs.copyFileSync(file, settingsBackupPath(file));
-    fs.rmSync(file, { force: true });
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  backUpSettings(file);
+  if (fs.lstatSync(file).isSymbolicLink()) {
+    writeFileAtomic(file, "{}\n");
+    return "emptied";
   }
+  fs.rmSync(file, { force: true });
+  return "deleted";
 }
 
 // Antigravity runs the Windows launcher through `cmd /c`, which splits the
@@ -368,6 +427,7 @@ module.exports = {
   readAgySettings,
   readSettingsForUpdate,
   settingsBackupPath,
+  settingsOriginalBackupPath,
   writeJsonSafely,
   writeFileAtomic,
   removeSettingsFile,

package/src/lib/prompt.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const readline = require("readline");
 
 function createRl() {
@@ -24,8 +26,36 @@ async function confirm(rl, message, defaultYes) {
   return answer === "y" || answer === "yes";
 }
 
+// Numbered options, answered with a number; Enter keeps the default. Anything
+// else asks again, at most 3 times, then the default stands. No raw mode or
+// arrow keys, so it works in every terminal and in cmd. An option can span
+// several lines (a label and its preview). Returns the chosen index.
+async function choose(rl, message, options, defaultIndex = 0, print = console.log) {
+  print(message);
+  options.forEach((option, i) => {
+    const [first, ...rest] = String(option).split("\n");
+    print(`  ${String(i + 1).padStart(2)}) ${first}`);
+    rest.forEach((line) => print(`      ${line}`));
+  });
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const answer = (
+      await question(rl, `  Choose 1-${options.length} (Enter: ${defaultIndex + 1}) `)
+    ).trim();
+    if (!answer) {
+      return defaultIndex;
+    }
+    const index = /^\d{1,3}$/.test(answer) ? Number(answer) - 1 : -1;
+    if (index >= 0 && index < options.length) {
+      return index;
+    }
+  }
+  return defaultIndex;
+}
+
 module.exports = {
   createRl,
   question,
   confirm,
+  choose,
 };

package/src/lib/run.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const { spawn } = require("child_process");
 
 function spawnCapture(file, args, input, timeoutMs = 15000) {

package/src/lib/session.js

@@ -2,7 +2,8 @@
 
 const os = require("os");
 const { formatReset, resetInSeconds, firstText } = require("./formatters");
-const { resolveGit } = require("./git");
+const { resolveGit, resolveGitDetails } = require("./git");
+const { resolveUsage } = require("./usage");
 
 const FIVE_HOURS = 5 * 3600;
 const SEVEN_DAYS = 7 * 86400;
@@ -144,7 +145,17 @@ function contextUsedPercent(data) {
   return (current * 100) / size;
 }
 
-function extractSession(data, config) {
+// options.readUsage: the statusline itself may read agy's conversation
+// databases; previews only use the usage cache.
+function extractSession(data, config, options = {}) {
+  const git = resolveGit(data, config);
+  const gitDetails = resolveGitDetails(data, config);
+  // Once git status has been read for gitFiles, the branch's dirty marker can
+  // count uncommitted files too, not only an unfinished merge or rebase.
+  const files = gitDetails?.files;
+  if (git && files && gitDetails.branch === git.branch) {
+    git.dirty = git.dirty || files.staged + files.modified + files.conflicts > 0;
+  }
   const contextPct = percent(contextUsedPercent(data));
   const contextSize = count(data.context_window?.context_window_size);
   const current = data.context_window?.current_usage;
@@ -224,7 +235,10 @@ function extractSession(data, config) {
     version: firstText(data.version),
     sandbox: data.sandbox?.enabled === true,
     sandboxNet: data.sandbox?.allow_network === true,
-    git: resolveGit(data, config),
+    git,
+    gitDetails,
+    // Only read when tokensToday or tokensWeek is on the bar.
+    usage: resolveUsage(config, { read: options.readUsage === true }),
     terminalWidth: terminalWidth(data.terminal_width ?? process.stdout.columns ?? 0),
   };
 }