synabun 2.1.0 → 2.2.1

package/neural-interface/public/shared/agy/agy-copy.js

@@ -0,0 +1,326 @@
+// ═══════════════════════════════════════════
+// SynaBun — Antigravity panel: every sentence it says (no DOM)
+// ═══════════════════════════════════════════
+//
+// The English text lives here, once; `antigravityPanel.*` in i18n/en.json must equal it and
+// i18n/pt-BR.json must have the same keys and placeholders (tests/antigravity-panel-tabs.test.mjs,
+// tests/antigravity-panel-copy.test.mjs). A detached window or a test renders before the locale bundle
+// is ready: the English is the fallback.
+
+export const AGY_COPY = Object.freeze({
+  title: 'Antigravity',
+  toolbar: 'Antigravity side panel',
+  transcript: 'Antigravity conversation',
+  newSession: 'New session',
+  newTab: 'New tab',
+  closeTab: 'Close tab',
+  minimize: 'Minimize to pill',
+  rename: 'Rename session',
+  sessions: 'Sessions',
+  sessionsEmpty: 'No Antigravity conversations in this project yet.',
+  sessionsLoading: 'Loading conversations…',
+  sessionsFailed: 'Could not list conversations: {error}',
+  sessionsSearch: 'Search conversations',
+  sessionsMore: 'Load more',
+  delete: 'Delete',
+  deleteConfirm: 'Delete "{title}"?',
+  cancel: 'Cancel',
+  fork: 'Fork',
+  forkTitle: 'Fork of {title}',
+  project: 'Project',
+  chooseProject: 'Choose a project',
+  branch: 'Branch',
+  branchStopFirst: 'Stop the running turn before switching branches.',
+  branchSwitched: 'Switched the working tree to {branch}.',
+  branchConfirm: 'Switch from {from} to {to} with {count} uncommitted changes? Git keeps them when it can.',
+  branchFailed: 'Could not switch branches: {error}',
+  noProject: 'Choose a project folder to start.',
+  folderAdd: 'Add a folder to this session',
+  folderHelp: 'Antigravity can also read and edit these registered projects in this session.',
+  folderNone: 'Every registered project is already in this session.',
+  folderRemove: 'Remove {name} from this session',
+  foldersApplied: 'The session now includes the folders you chose.',
+  foldersNext: 'The folders apply when the next session starts.',
+  placeholder: 'Ask Antigravity…',
+  placeholderQueue: 'Queue a follow-up…',
+  placeholderAutomation: 'A dispatched run is using this tab.',
+  send: 'Send',
+  stop: 'Stop',
+  attach: 'Attach files',
+  attachmentRemove: 'Remove {name}',
+  attachmentTooMany: 'At most {count} attachments per message.',
+  attachmentTooLarge: '{name} is larger than {size} MB.',
+  attachmentType: '{name} is a file type Antigravity cannot take.',
+  mic: 'Record a voice message',
+  micFailed: 'The microphone could not start: {error}',
+  model: 'Model',
+  thinking: 'Thinking',
+  mode: 'Mode',
+  permissions: 'Permissions',
+  permDefault: 'Default',
+  permDefaultHint: 'Ask before each tool Antigravity wants approved',
+  permBypass: 'Bypass',
+  permBypassHint: 'Run everything without asking',
+  permBypassRestart: 'Bypass needs the SynaBun server restart: until then choosing it here does nothing.',
+  permBypassWaiting: 'Bypass · unavailable: this tab\'s Bypass pick waits for the SynaBun server restart, and until then Antigravity asks as usual.',
+  permBypassOnTitle: 'Bypass: every tool runs without asking in this tab, until you pick another mode. SynaBun still refuses browsers other than its own and its protected folders.',
+  permBypassStrip: 'Bypass is on: Antigravity runs every tool in this tab without asking.',
+  permBypassConfirmTitle: 'Turn on Bypass for this tab?',
+  permBypassConfirmBody: 'Antigravity will edit files, run commands and call tools without asking, until you pick Default again. SynaBun still refuses other browsers than its own and anything in its protected folders (credentials, SynaBun\'s data, the runtimes\' settings).',
+  permBypassConfirmYes: 'Turn on Bypass',
+  permBypassFailed: 'Could not change Bypass: {error}',
+  permAutoAllowed: 'Bypass allowed: {tool}',
+  permAutoRefused: 'Bypass refused {tool}: {reason}',
+  permTool: 'a tool',
+  modelDefault: 'Default',
+  working: 'Working…',
+  workingFor: 'Working… {seconds}s',
+  needsYou: 'Waiting for you',
+  thought: 'Thinking',
+  thoughtFor: 'Thought for {duration}',
+  thinkingNow: 'Thinking…',
+  plan: 'Plan',
+  planProgress: '{done} of {total} done',
+  planDone: 'Done',
+  priorityHigh: 'High',
+  toolPending: 'Waiting',
+  toolRunning: 'Running',
+  toolDone: 'Done',
+  toolFailed: 'Failed',
+  kind_read: 'Read',
+  kind_edit: 'Edit',
+  kind_delete: 'Delete',
+  kind_move: 'Move',
+  kind_search: 'Search',
+  kind_execute: 'Command',
+  kind_think: 'Think',
+  kind_fetch: 'Fetch',
+  kind_switch_mode: 'Mode switch',
+  kind_other: 'Tool',
+  rawInput: 'Input',
+  rawOutput: 'Output',
+  diffFor: 'Changes to {path}',
+  diffAdded: 'New file',
+  diffModified: 'Modified',
+  diffDeleted: 'Deleted',
+  diffIdentical: 'No changes in the text.',
+  diffTooLarge: 'Too many changes to compare line by line: the old text is shown removed and the new text added.',
+  diffTruncated: 'The file is longer than the part compared here.',
+  diffShowAll: 'Show the whole diff ({count} lines)',
+  copyPatch: 'Copy patch',
+  terminalWaiting: 'Waiting for output…',
+  terminalRunning: 'Running',
+  terminalExit: 'Exit code {code}',
+  terminalSignal: 'Stopped by {signal}',
+  terminalTruncated: 'Earlier output was cut.',
+  compaction: 'Conversation summary',
+  compactionRunning: 'Summarizing',
+  compactionDone: 'Summarized',
+  compactionFailed: 'Failed',
+  compactionCancelled: 'Cancelled',
+  compact: 'Compact',
+  subagent: 'Subagent',
+  subagentRunning: 'Running',
+  subagentIdle: 'Idle',
+  subagentNeedsYou: 'Needs you',
+  subagentUnknown: 'Unknown',
+  relayedMessage: 'Message between sessions',
+  usage_in: '{value} in',
+  usage_out: '{value} out',
+  usage_thinking: '{value} thinking',
+  usage_cached: '{value} cached',
+  copy: 'Copy',
+  copied: 'Copied',
+  copyAnswer: 'Copy answer',
+  copyCommand: 'Copy the command',
+  retry: 'Retry',
+  permissionTitle: 'Antigravity wants to {verb}',
+  verb_read: 'read a file',
+  verb_edit: 'edit a file',
+  verb_delete: 'delete a file',
+  verb_move: 'move a file',
+  verb_search: 'search',
+  verb_execute: 'run a command',
+  verb_think: 'think',
+  verb_fetch: 'fetch from the web',
+  verb_switch_mode: 'switch mode',
+  verb_other: 'use a tool',
+  permissionDeny: 'Deny',
+  permissionAnswered: 'Answered',
+  permissionCancelled: 'No longer needed',
+  permissionSending: 'Sending…',
+  permissionKeys: 'Enter allows once · Esc denies',
+  elicitTitle: 'Antigravity asks',
+  elicitSubmit: 'Send',
+  elicitDecline: 'Decline',
+  elicitCancel: 'Cancel',
+  elicitOpen: 'Open the link',
+  elicitDone: 'Done',
+  elicitAnswered: 'Answered',
+  elicitDeclined: 'Declined',
+  elicitBadUrl: 'The link is not an address the panel opens (https only).',
+  elicitUnsupported: 'This field cannot be answered here.',
+  elicitUnsupportedMode: 'The panel cannot show this kind of question.',
+  elicitRequired: 'Required.',
+  elicitNumber: 'Enter a number.',
+  elicitRange: 'The number is out of range.',
+  elicitLength: 'The length is out of range.',
+  elicitEmail: 'Enter an email address.',
+  elicitUrl: 'Enter an address.',
+  elicitChoices: 'Pick a different number of options.',
+  signIn: 'Sign in',
+  signInTitle: 'Sign in to Antigravity',
+  signInBody: 'Antigravity needs your Google sign-in before it can start a session.',
+  signInTerminal: 'Sign in from a terminal',
+  signInTerminalBody: 'Finish signing in in the terminal that opened, then check again.',
+  signInCheck: 'Check again',
+  signInWaiting: 'Finish signing in in the browser window that opened…',
+  signInFailed: 'Sign-in did not finish: {error}',
+  signOut: 'Sign out',
+  setupMissingTitle: 'Antigravity CLI is not installed',
+  setupMissingBody: 'Install Google\'s Antigravity CLI to use it here. SynaBun runs the official installer, then signs you in.',
+  setupMissingBodyBrew: 'Install Google\'s Antigravity CLI to use it here. SynaBun installs it with Homebrew, then signs you in.',
+  setupMissingManual: 'Install it with this command, then check again.',
+  setupMissingGuide: 'Follow the install guide, then check again.',
+  setupInstallingTitle: 'Installing Antigravity…',
+  setupStep_check: 'Checking this computer…',
+  setupStep_install: 'Installing the Antigravity CLI…',
+  setupStep_verify: 'Checking that agy starts…',
+  setupBrewRunning: 'Homebrew is installing antigravity-cli…',
+  setupFailedTitle: 'Antigravity could not be installed',
+  setupBrokenTitle: 'Antigravity CLI failed to start',
+  setupUpdateTitle: 'Update the Antigravity CLI',
+  setupUpdateBody: 'This version of agy has no ACP server (agy acp), which the panel needs. Update it with this command (or brew upgrade --cask antigravity-cli), then check again.',
+  setupConnectingTitle: 'Starting Antigravity…',
+  setupConnectingBody: 'The CLI is installed. SynaBun is starting it.',
+  setupReadyTitle: 'Antigravity is ready',
+  setupReadyBody: 'Ask anything about this project to start.',
+  setupPathTitle: 'Use agy in your other terminals',
+  setupInstall: 'Install Antigravity',
+  setupRetry: 'Try again',
+  setupRecheck: 'Check again',
+  setupChecking: 'Checking…',
+  setupDismiss: 'Dismiss',
+  setupLog: 'Installer output',
+  setupStepsLabel: 'Setup steps',
+  step_check: 'Checking',
+  step_install: 'Installing',
+  step_verify: 'Verifying',
+  step_signin: 'Sign in',
+  stepState_todo: 'not started',
+  stepState_active: 'in progress',
+  stepState_done: 'done',
+  stepState_failed: 'failed',
+  addToPath: 'Add to PATH',
+  installGuide: 'Install guide',
+  cliReference: 'Antigravity CLI reference',
+  blockedMissing: 'Install Antigravity first',
+  blockedInstalling: 'Antigravity is being installed',
+  blockedBroken: 'Antigravity failed to start',
+  blockedSignIn: 'Sign in first',
+  blockedConnecting: 'Antigravity is starting',
+  blockedConnection: 'Not connected to SynaBun',
+  agentStopped: 'Antigravity stopped{detail}. Send again to start it.',
+  disconnected: 'The connection to SynaBun dropped. Reconnecting…',
+  connOffline: 'SynaBun is not answering. Retrying…',
+  connRetryNow: 'Reconnect now',
+  connRetry: 'Try again',
+  connAutomation: 'SynaBun\'s automation browser cannot open the Antigravity panel. Open it from your own browser or the SynaBun app.',
+  connGuest: 'The Antigravity panel is for the owner of this SynaBun.',
+  connRefused: 'SynaBun refused this window\'s connection to the Antigravity panel. If your browser reaches SynaBun through a proxy, add localhost to its bypass list.',
+  connRestart: 'This SynaBun server started before the Antigravity panel existed. Restart SynaBun to use it.',
+  errorPrefix: 'Error: {message}',
+  stopped: 'Stopped.',
+  refusal: 'The model declined to continue.',
+  maxTokens: 'The reply reached the model\'s output limit.',
+  maxTurns: 'The turn reached its request limit.',
+  context: 'Context {label}',
+  contextUnknown: 'Not reported yet',
+  automation: 'Dispatched run',
+  automationBanner: 'A dispatched run of the Assistant is working in this tab.',
+  automationEnded: 'This run has ended. Send a message to continue here.',
+  commands: 'Commands and files',
+  hintsPanel: 'Panel',
+  hintsAgent: 'Antigravity',
+  mentionLoading: 'Looking for files…',
+  queueTitle: 'Queue',
+  queueAdd: 'Add to queue',
+  queuePause: 'Pause the queue',
+  queueResume: 'Resume the queue',
+  queueClear: 'Clear the queue',
+  queueEdit: 'Edit',
+  queueRemove: 'Remove',
+  queueFull: 'The queue holds at most {count} messages.',
+  jumpLatest: 'Latest',
+  emptyTitle: 'Antigravity',
+  emptyBody: 'Google\'s coding agent, with SynaBun\'s memory. Ask about this project, or paste a picture.',
+  emptyKeyCommands: 'commands',
+  emptyKeyFiles: 'files',
+  loadingHistory: 'Loading the conversation…',
+  historyFailed: 'Could not load this conversation: {error}',
+  runHomePruned: 'This dispatched run\'s conversation folder was already cleaned up, so the conversation can no longer be continued here. Start a new tab instead.',
+  cmdNew: 'Start a new session',
+  cmdSessions: 'Open the session list',
+  cmdRename: 'Rename this session',
+  cmdFork: 'Fork this session into a new tab',
+  cmdRetry: 'Send the last message again',
+  cmdCopy: 'Copy the last answer',
+  cmdModel: 'Choose the model',
+  cmdMode: 'Choose the mode',
+  cmdThinking: 'Choose the thinking level',
+  cmdDetail: 'Change how much of each turn is shown',
+  cmdSettings: 'Open Session settings',
+  cmdLogin: 'Sign in to Antigravity',
+  cmdLogout: 'Sign out of Antigravity',
+  cmdHelp: 'List commands and keys',
+  helpPanel: 'Panel commands:',
+  helpAgent: 'Antigravity commands:',
+  helpKeys: 'Keys: Enter sends · Shift+Enter adds a line · ↑ recalls the last message · Esc stops a running turn · @ attaches a file',
+  settingsTitle: 'Session settings',
+  settingsContext: 'Context',
+  settingsTokens: 'Tokens in context',
+  settingsSession: 'Session',
+  settingsSessionId: 'Session id',
+  settingsNoSession: 'Not started',
+  settingsFolders: 'Extra folders',
+  settingsTurns: 'Turns',
+  settingsOptions: 'Session options',
+  settingsNoOptions: 'Antigravity offers no options for this session.',
+  settingsStartSession: 'The options appear once the session starts.',
+  settingsPanel: 'Panel',
+  settingsDetail: 'Detail',
+  detail_compact: 'Compact',
+  detail_standard: 'Standard',
+  detail_verbose: 'Verbose',
+  detailHelp_compact: 'Answers only: thoughts hidden, every tool call closed.',
+  detailHelp_standard: 'Thoughts folded; file changes open, other tool calls closed.',
+  detailHelp_verbose: 'Everything open, with each tool call\'s raw input and output.',
+  settingsClientFs: 'Files through SynaBun',
+  settingsClientFsHelp: 'Antigravity reads and writes files through SynaBun. Applies when the agent restarts, which this switch does.',
+  settingsClientTerminal: 'Commands in SynaBun',
+  settingsClientTerminalHelp: 'Antigravity runs its commands through SynaBun, with their output live in the tool card. Applies when the agent restarts.',
+  settingsNeedsRestart: 'Needs a restart of the SynaBun server.',
+  settingsAccount: 'Account',
+  settingsSignIn: 'Sign-in',
+  settingsSignedIn: 'Signed in',
+  settingsSignedOut: 'Signed out',
+  settingsAgentOff: 'Antigravity is not running',
+  settingsMethods: 'Methods',
+  settingsAbout: 'About',
+  settingsAgent: 'Agent',
+  settingsProtocol: 'Protocol',
+  settingsLinks: 'Docs',
+});
+
+let translate = null;
+export function setAntigravityTranslator(fn) { translate = typeof fn === 'function' ? fn : null; }
+
+/** The sentence for `key`, translated when the locale has it, else the English, with {name} placeholders filled. */
+export function agyText(key, params) {
+  const path = `antigravityPanel.${key}`;
+  let value = path;
+  try { value = translate?.(path, params) || path; } catch { value = path; }
+  if (value !== path) return value;
+  const english = Object.hasOwn(AGY_COPY, key) ? AGY_COPY[key] : key;
+  return english.replace(/\{(\w+)\}/g, (_, name) => (params?.[name] ?? `{${name}}`));
+}

package/neural-interface/public/shared/agy/agy-diff.js

@@ -0,0 +1,161 @@
+// ═══════════════════════════════════════════
+// SynaBun — Antigravity panel: a file change as unified diff rows (no DOM)
+// ═══════════════════════════════════════════
+//
+// An ACP tool call reports a change as `{ type: 'diff', path, oldText, newText }`
+// (oldText null for a new file). This module turns one into the rows the panel
+// draws: hunks with three lines of context, each row with its old and new line
+// number, a sign and its text, plus the counts. Myers' algorithm on the lines
+// between the common head and tail; a change too large to diff within the
+// bounds is shown as the old text removed and the new text added, and says so.
+// Imported by the page and by `node --test`.
+
+export const DIFF_LIMITS = Object.freeze({
+  maxChars: 200_000,   // per side; more is shown truncated
+  maxLines: 2000,      // per side
+  maxEdits: 1000,      // Myers' D: beyond it the change is "replace everything"
+  context: 3,
+  previewRows: 60,     // rows drawn before "Show the whole diff"
+});
+
+const splitLines = (text) => {
+  const value = String(text ?? '');
+  if (!value) return [];
+  const lines = value.split(/\r?\n/);
+  if (lines.length && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+};
+
+/**
+ * Myers' O(ND) diff of two line arrays. Returns the edit script as
+ * [{ op: 'equal' | 'delete' | 'insert', a, b }] (a / b: indexes into the
+ * arrays), or null when it needs more than `maxEdits` edits.
+ */
+export function myersDiff(a, b, maxEdits = DIFF_LIMITS.maxEdits) {
+  const n = a.length;
+  const m = b.length;
+  const max = n + m;
+  if (max === 0) return [];
+  const limit = Math.min(max, maxEdits);
+  const offset = limit + 1;
+  let v = new Int32Array(2 * limit + 3);
+  const trace = [];
+  let found = -1;
+  for (let d = 0; d <= limit; d += 1) {
+    trace.push(v.slice(offset - d - 1 < 0 ? 0 : offset - d - 1, offset + d + 2));
+    for (let k = -d; k <= d; k += 2) {
+      let x;
+      if (k === -d || (k !== d && v[offset + k - 1] < v[offset + k + 1])) x = v[offset + k + 1];
+      else x = v[offset + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && a[x] === b[y]) { x += 1; y += 1; }
+      v[offset + k] = x;
+      if (x >= n && y >= m) { found = d; break; }
+    }
+    if (found >= 0) break;
+  }
+  if (found < 0) return null;
+  // Walk the trace back from (n, m).
+  const script = [];
+  let x = n;
+  let y = m;
+  for (let d = found; d > 0; d -= 1) {
+    const prev = trace[d];
+    const base = offset - d - 1 < 0 ? 0 : offset - d - 1;
+    const at = (k) => prev[offset + k - base];
+    const k = x - y;
+    const prevK = (k === -d || (k !== d && at(k - 1) < at(k + 1))) ? k + 1 : k - 1;
+    const prevX = at(prevK);
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) { x -= 1; y -= 1; script.push({ op: 'equal', a: x, b: y }); }
+    if (x === prevX) { y -= 1; script.push({ op: 'insert', a: x, b: y }); }
+    else { x -= 1; script.push({ op: 'delete', a: x, b: y }); }
+  }
+  while (x > 0 && y > 0) { x -= 1; y -= 1; script.push({ op: 'equal', a: x, b: y }); }
+  return script.reverse();
+}
+
+function clip(text, maxChars) {
+  const value = String(text ?? '');
+  return value.length > maxChars ? { text: value.slice(0, maxChars), clipped: true } : { text: value, clipped: false };
+}
+
+/**
+ * One ACP diff as rows:
+ * { path, status: 'added' | 'modified' | 'deleted', added, removed, rows: [{ kind: 'hunk' | 'context' | 'add' |
+ *   'delete' | 'note', old, new, text }], truncated, fallback, identical }
+ */
+export function diffView(item, limits = DIFF_LIMITS) {
+  const path = String(item?.path || '');
+  const oldRaw = item?.oldText;
+  const isNew = oldRaw === null || oldRaw === undefined;
+  const oldClip = clip(isNew ? '' : oldRaw, limits.maxChars);
+  const newClip = clip(item?.newText ?? '', limits.maxChars);
+  let oldLines = splitLines(oldClip.text);
+  let newLines = splitLines(newClip.text);
+  let truncated = oldClip.clipped || newClip.clipped;
+  if (oldLines.length > limits.maxLines) { oldLines = oldLines.slice(0, limits.maxLines); truncated = true; }
+  if (newLines.length > limits.maxLines) { newLines = newLines.slice(0, limits.maxLines); truncated = true; }
+  const status = isNew ? 'added' : (!newLines.length && oldLines.length ? 'deleted' : 'modified');
+
+  // The common head and tail never take part in the edit search.
+  let head = 0;
+  while (head < oldLines.length && head < newLines.length && oldLines[head] === newLines[head]) head += 1;
+  let tail = 0;
+  while (tail < oldLines.length - head && tail < newLines.length - head
+    && oldLines[oldLines.length - 1 - tail] === newLines[newLines.length - 1 - tail]) tail += 1;
+  const midA = oldLines.slice(head, oldLines.length - tail);
+  const midB = newLines.slice(head, newLines.length - tail);
+  let middle = myersDiff(midA, midB, limits.maxEdits);
+  const fallback = middle === null;
+  if (fallback) middle = [...midA.map((_, a) => ({ op: 'delete', a, b: 0 })), ...midB.map((_, b) => ({ op: 'insert', a: midA.length, b }))];
+  const ops = [];
+  for (let i = 0; i < head; i += 1) ops.push({ op: 'equal', a: i, b: i });
+  for (const step of middle) ops.push({ op: step.op, a: step.a + head, b: step.b + head });
+  for (let i = 0; i < tail; i += 1) ops.push({ op: 'equal', a: oldLines.length - tail + i, b: newLines.length - tail + i });
+
+  let added = 0;
+  let removed = 0;
+  for (const step of ops) { if (step.op === 'insert') added += 1; else if (step.op === 'delete') removed += 1; }
+  const identical = added === 0 && removed === 0;
+
+  // Hunks: every change with `context` equal lines around it; runs closer than twice that merge.
+  const rows = [];
+  const changeAt = ops.map((step) => step.op !== 'equal');
+  const keep = new Array(ops.length).fill(false);
+  for (let i = 0; i < ops.length; i += 1) {
+    if (!changeAt[i]) continue;
+    for (let j = Math.max(0, i - limits.context); j <= Math.min(ops.length - 1, i + limits.context); j += 1) keep[j] = true;
+  }
+  let i = 0;
+  while (i < ops.length) {
+    if (!keep[i]) { i += 1; continue; }
+    let end = i;
+    while (end + 1 < ops.length && keep[end + 1]) end += 1;
+    const first = ops[i];
+    let oldStart = first.op === 'insert' ? first.a : first.a;
+    let newStart = first.op === 'delete' ? first.b : first.b;
+    let oldCount = 0;
+    let newCount = 0;
+    for (let j = i; j <= end; j += 1) {
+      if (ops[j].op !== 'insert') oldCount += 1;
+      if (ops[j].op !== 'delete') newCount += 1;
+    }
+    rows.push({ kind: 'hunk', old: null, new: null, text: `@@ -${oldCount ? oldStart + 1 : oldStart},${oldCount} +${newCount ? newStart + 1 : newStart},${newCount} @@` });
+    for (let j = i; j <= end; j += 1) {
+      const step = ops[j];
+      if (step.op === 'equal') rows.push({ kind: 'context', old: step.a + 1, new: step.b + 1, text: oldLines[step.a] });
+      else if (step.op === 'delete') rows.push({ kind: 'delete', old: step.a + 1, new: null, text: oldLines[step.a] });
+      else rows.push({ kind: 'add', old: null, new: step.b + 1, text: newLines[step.b] });
+    }
+    i = end + 1;
+  }
+  if (truncated) rows.push({ kind: 'note', old: null, new: null, text: 'truncated' });
+  return { path, status, added, removed, rows, truncated, fallback, identical };
+}
+
+/** Counts over several diffs: { files, added, removed }. */
+export function diffTotals(views) {
+  const list = Array.isArray(views) ? views : [];
+  return list.reduce((sum, view) => ({ files: sum.files + 1, added: sum.added + (view?.added || 0), removed: sum.removed + (view?.removed || 0) }), { files: 0, added: 0, removed: 0 });
+}