pi-supernova 0.10.1 → 0.11.0

package/src/fs/commit.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import * as path from 'node:path';
 import {randomUUID} from 'node:crypto';
-import {fileSignature,sameSignature,textSignature} from './file-io.js';
+import {fileSignature,sameSignature,sameFileVersion,textSignature} from './file-io.js';
 
 // realpath() cannot resolve a missing leaf. Canonicalize its nearest existing
 // ancestor so two symlink spellings still share one commit destination.
@@ -20,12 +20,23 @@ async function canonicalNewPath(target) {
   }
 }
 
+export async function resolveFileIdentity(target) {
+  try { return { path: await fs.realpath(target) }; }
+  catch (error) {
+    if (error.code !== "ENOENT") throw error;
+
+    return { path: await canonicalNewPath(target), missing: error };
+  }
+}
+
 async function resolveExistingFile(logicalPath) {
   const target = await fs.realpath(logicalPath);
   const stat = await fs.stat(target);
 
   if (!stat.isFile()) throw new Error("cannot write to a non-file: " + logicalPath);
 
+  if (stat.nlink > 1) throw new Error("cannot replace a hard-linked file without splitting its aliases: " + logicalPath);
+
   return { target, stat };
 }
 
@@ -87,7 +98,52 @@ async function stageReplacement(entry, content, stat, target) {
 function makeStageEntry(logicalPath, target, content, parent, stat) {
   const token = ".supernova-" + randomUUID();
 
-  return { logicalPath, target, content, temporary: path.join(parent, token + ".new"), backup: path.join(parent, token + ".bak"), existed: !!stat, replaced: false };
+  return { logicalPath, target, content, temporary: path.join(parent, token + ".new"), backup: path.join(parent, token + ".bak"), existed: !!stat, observed: stat, replaced: false };
+}
+
+// Windows readers and antivirus can briefly deny replacement. Bound retries and
+// renew the destination/ownership guard after waiting; never replay a stale CAS.
+async function renameWithSharingRetry(from, to, validate) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await fs.rename(from, to);
+
+      return;
+    }
+    catch (error) {
+      if (process.platform !== "win32" || !["EPERM", "EBUSY"].includes(error.code) || attempt >= 2) throw error;
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 10));
+    await validate();
+  }
+}
+
+async function assertPublishedContent(entry) {
+  const expected = textSignature(entry.content);
+  const stat = await fs.stat(entry.target);
+
+  // Recovery must not destroy changes made after our publication. Check
+  // cheap type/size differences before hashing a possibly replaced file.
+  if (!stat.isFile() || stat.size !== expected.size || !sameSignature(await fileSignature(entry.target, undefined, stat), expected)) {
+    throw new Error("destination changed after publication; left unchanged");
+  }
+}
+
+async function assertStageReady(vfs, entry) {
+  vfs.assertCurrent?.();
+  vfs.signal?.throwIfAborted();
+  let current;
+
+  try { current = await fs.stat(entry.target); }
+  catch (error) { if (error.code !== "ENOENT") throw error; }
+
+  if (!current || !sameFileVersion(entry.observed, current)) throw new Error("write conflict: file changed during commit staging: " + entry.logicalPath + "; read it again before retrying");
+
+  // Windows metadata can alias a rewrite while staging releases its handles.
+  if (process.platform === "win32") await assertExpectedSignature(vfs, entry.logicalPath, entry.target, current);
+  vfs.assertCurrent?.();
+  vfs.signal?.throwIfAborted();
 }
 
 async function recoverReplaced(staged) {
@@ -97,12 +153,14 @@ async function recoverReplaced(staged) {
     if (!entry.replaced) continue;
 
     try {
-      if (entry.existed) await fs.rename(entry.backup, entry.target);
+      await assertPublishedContent(entry);
+
+      if (entry.existed) await renameWithSharingRetry(entry.backup, entry.target, () => assertPublishedContent(entry));
       else await fs.unlink(entry.target);
     } catch (err) {
       // Keep the backup if recovery fails; never delete the remaining original.
-      entry.keepBackup = true;
-      recoveryErrors.push(entry.target + ": " + err.message + " (backup: " + entry.backup + ")");
+      entry.keepBackup = entry.existed;
+      recoveryErrors.push(entry.target + ": " + err.message + (entry.existed ? " (backup: " + entry.backup + ")" : ""));
     }
   }
 
@@ -111,9 +169,9 @@ async function recoverReplaced(staged) {
 
 async function cleanupStaged(staged, failed, createdDirs) {
   for (const entry of staged) {
-    // A successful rename consumed the temporary path. These are known
-    // files, so unlink avoids rm's extra type probe; missing files stay benign.
-    if (!entry.replaced) await fs.unlink(entry.temporary).catch(() => {});
+    // Existing-file rename consumes the staging name; new-file linking does
+    // not. Remove only our staging names, never a conflicting destination.
+    if (!entry.replaced || !entry.existed) await fs.unlink(entry.temporary).catch(() => {});
 
     if (entry.existed && !entry.keepBackup) await fs.unlink(entry.backup).catch(() => {});
   }
@@ -122,26 +180,42 @@ async function cleanupStaged(staged, failed, createdDirs) {
 }
 
 async function assertExpectedSignature(vfs, logicalPath, target, stat) {
-  if (!vfs.expected.has(logicalPath)) return;
+  if (!vfs.expected.has(target)) return;
   const current = stat ? await fileSignature(target, vfs.signal) : null;
 
-  if (!sameSignature(current, vfs.expected.get(logicalPath))) {
+  if (!sameSignature(current, vfs.expected.get(target))) {
     throw new Error("write conflict: file changed since it was read: " + logicalPath + "; read it again before retrying");
   }
 }
 
 async function installStaged(vfs, staged) {
   for (const entry of staged) {
-    // Staging and earlier renames await I/O. Recheck before each disk effect;
-    // failCommit restores earlier replacements if ownership changed mid-commit.
+    if (entry.existed) await assertStageReady(vfs, entry);
+
+    // Staging, version checks and earlier publications await I/O. Recheck
+    // ownership immediately before each disk effect; failCommit handles recovery.
     vfs.assertCurrent?.();
     vfs.signal?.throwIfAborted();
-    await fs.rename(entry.temporary, entry.target);
+
+    if (entry.existed) await renameWithSharingRetry(entry.temporary, entry.target, () => assertStageReady(vfs, entry));
+    else {
+      // Let the filesystem enforce absence, including case/Unicode aliases.
+      // A preflight stat followed by rename would still clobber a racing file.
+      try { await fs.link(entry.temporary, entry.target); }
+      catch (error) {
+        if (error.code === "EEXIST") throw new Error("write conflict: destination appeared before publication: " + entry.logicalPath + "; read it again before retrying", {cause:error});
+        throw error;
+      }
+    }
+
     entry.replaced = true;
+    // Record publication first so invalidation during awaited I/O triggers recovery.
+    vfs.assertCurrent?.();
+    vfs.signal?.throwIfAborted();
   }
 
   for (const entry of staged) {
-    vfs.expected.set(entry.logicalPath, textSignature(entry.content));
+    vfs.expected.set(entry.target, textSignature(entry.content));
   }
 
   // Canonical commit destinations must not rewrite established event paths
@@ -164,4 +238,4 @@ async function failCommit(vfs, staged, error) {
   throw error;
 }
 
-export {assertExpectedSignature,collectMissingAncestors,makeStageEntry,stageReplacement,installStaged,failCommit,cleanupStaged};
+export {canonicalNewPath,assertExpectedSignature,collectMissingAncestors,makeStageEntry,stageReplacement,installStaged,failCommit,cleanupStaged};

package/src/fs/diff.js

@@ -1,5 +1,6 @@
 
 import { isString } from "../shared/decode.js";
+import { lineNumberAt } from "./lines.js";
 
 /** Receipts render at most this many matches; totals still cover every match. */
 export const MAX_DIFF_MATCHES = 32;
@@ -38,21 +39,23 @@ export function buildEditDiff(filePath, originalText, oldText, newText) {
 
 export function buildMultiEditDiff(filePath, originalText, replacements) {
   const rendered = replacements.slice(0, MAX_DIFF_MATCHES);
-  const parts = rendered.map(({ oldText, newText }) =>
-    buildEditDiff(filePath, originalText, oldText, newText),
-  );
 
   const lines = [];
   let shift = 0;
 
-  for (const [index, part] of parts.entries()) {
-    for (const line of part.lines) {
-      if (line.type === "context") continue;
-      lines.push(line.type === "add" ? { ...line, lineNum: line.lineNum + shift }
-        : { ...line, newLineNum: Math.max(1, line.lineNum + shift) });
+  // Multi-edit receipts omit context. Do not split the entire original for
+  // each replacement just to build context rows that would be discarded.
+  for (const { oldText, newText } of rendered) {
+    const idx = isString(originalText) ? originalText.indexOf(oldText) : -1;
+    const startLine = idx >= 0 ? lineNumberAt(originalText, idx) : 1;
+    const oldLines = contentLines(oldText);
+
+    for (const [i, text] of oldLines.entries()) {
+      lines.push({ type: "remove", lineNum: startLine + i, text, newLineNum: Math.max(1, startLine + i + shift) });
     }
 
-    shift += rendered[index].newText.split("\n").length - rendered[index].oldText.split("\n").length;
+    appendDiffLines(lines, "add", contentLines(newText), startLine + shift);
+    shift += newText.split("\n").length - oldText.split("\n").length;
   }
 
   return {

package/src/fs/directory.js

@@ -25,6 +25,7 @@ export async function formatLsEntry(dirPath, entry) {
 
   return formatDirectoryEntry(entry.name, typeLabel, size);
 }
+
 function admitEntry(rows, name, dirPath) {
   if (!rows.has(name) && rows.size >= MAX_DIRECTORY_ENTRIES) {
     throw new Error("directory exceeds " + MAX_DIRECTORY_ENTRIES + " entries: " + dirPath + "; read a subdirectory or use bash with a bounded directory parser");
@@ -34,46 +35,55 @@ function admitEntry(rows, name, dirPath) {
 async function formatDirBatch(dirPath, batch, rows, signal) {
   const results = await Promise.all(batch.map(entry=>formatLsEntry(dirPath,entry)));
   signal?.throwIfAborted();
+
   for (let i=0;i<batch.length;i++) rows.set(batch[i].name,results[i]);
 }
 
 export function createDirectoryReader(vfs) {
-  function overlayDirRows(dirPath, rows) {
-    for (const file of vfs.getOverlayPaths()) {
+  async function overlayDirRows(dirPath, rows) {
+    for (const file of await vfs.getOverlayPaths(dirPath)) {
       const relative = path.relative(dirPath,file);
+
       if (!relative || relative === ".." || relative.startsWith(".."+path.sep) || path.isAbsolute(relative)) continue;
       const [name,child] = relative.split(path.sep);
       admitEntry(rows,name,dirPath);
       rows.set(name,child === undefined
-        ? formatDirectoryEntry(name,"file",Buffer.byteLength(vfs.getOverlay(file),"utf8"))
+        ? formatDirectoryEntry(name,"file",Buffer.byteLength(await vfs.getOverlay(file),"utf8"))
         : formatDirectoryEntry(name,"dir"));
     }
   }
 
   async function diskDirRows(dirPath, rows, signal) {
     let directory;
+
     try { directory = await fs.opendir(dirPath,{bufferSize:128}); }
     catch (error) { if (error.code === "ENOENT" && rows.size) return; throw error; }
+
     let batch = [];
+
     // Do not allocate the entire directory first or serialize every stat. Eight
     // metadata operations overlap; directory handles close on success/error/abort.
     for await (const entry of directory) {
       signal?.throwIfAborted();
+
       if (rows.has(entry.name)) continue;
       admitEntry(rows,entry.name,dirPath);
       rows.set(entry.name,undefined);
       batch.push(entry);
+
       if (batch.length === 8) { await formatDirBatch(dirPath,batch,rows,signal); batch = []; }
     }
+
     await formatDirBatch(dirPath,batch,rows,signal);
   }
 
   return async function readDirectory(dirPath, signal) {
     signal?.throwIfAborted();
     const rows = new Map();
-    overlayDirRows(dirPath,rows);
+    await overlayDirRows(dirPath,rows);
     await diskDirRows(dirPath,rows,signal);
     const values = [...rows.values()];
+
     return readResult(values,{path:dirPath,directory:true,count:rows.size},values.slice(0,20).join("\n"),undefined,()=>values.join("\n"));
   };
 }

package/src/fs/file-io.js

@@ -12,8 +12,8 @@ function sameFileVersion(a, b) {
 
 // FileHandle streams with an already-aborted signal can emit a second, unhandled
 // error even after for-await rejects (Node and Bun). Own the bounded reads instead.
-async function* fileChunks(file, signal, maxBytes = Infinity) {
-  const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes));
+async function* fileChunks(file, signal, maxBytes = Infinity, chunkBytes = 64 * 1024) {
+  const buffer = Buffer.allocUnsafe(Math.min(chunkBytes, maxBytes));
   let remaining = maxBytes;
 
   while (remaining > 0) {
@@ -38,13 +38,20 @@ async function fileSignature(target, signal, observed) {
 
     if (observed && !sameFileVersion(observed, actual)) throw new Error("file changed while reading: " + target);
     const hash = createHash("sha256");
+    let size = 0;
+
+    const chunkBytes = Math.min(256 * 1024, Math.max(64 * 1024, actual.size));
+
+    for await (const chunk of fileChunks(file, signal, Infinity, chunkBytes)) {
+      hash.update(chunk);
+      size += chunk.length;
+    }
 
-    for await (const chunk of fileChunks(file, signal)) hash.update(chunk);
     const after = await file.stat();
 
     if (!after.isFile() || !sameFileVersion(actual, after)) throw new Error("file changed while signing: " + target);
 
-    return { size: actual.size, sha256: hash.digest("hex") };
+    return { size, sha256: hash.digest("hex") };
   } finally {
     await file.close();
   }
@@ -73,17 +80,31 @@ function assertReadableFile(stat, target) {
 
 async function readLimitedBytes(file, stat, maxBytes, label, signal, overflow = () => tooLargeRead(label, maxBytes)) {
   if (stat.size > maxBytes) throw overflow();
-  const chunks = [];
+  signal?.throwIfAborted();
+  // Reserve from stat, but read through EOF: files can grow, shrink or report zero size.
+  const buffer = Buffer.allocUnsafe(stat.size + 1);
   let size = 0;
 
-  for await (const chunk of fileChunks(file, signal, maxBytes + 1)) {
+  while (size < buffer.length) {
+    const { bytesRead } = await file.read(buffer, size, buffer.length - size, null);
+    signal?.throwIfAborted();
+
+    if (!bytesRead) return buffer.subarray(0, size);
+    size += bytesRead;
+
+    if (size > maxBytes) throw overflow();
+  }
+
+  const chunks = [buffer];
+
+  for await (const chunk of fileChunks(file, signal, maxBytes + 1 - size)) {
     size += chunk.length;
 
     if (size > maxBytes) throw overflow();
     chunks.push(Buffer.from(chunk));
   }
 
-  return Buffer.concat(chunks);
+  return Buffer.concat(chunks, size);
 }
 
 async function hasFileParent(target) {

package/src/fs/glob.js

@@ -1,11 +1,27 @@
-const REGEX_SPECIAL = /[.+^${}()|\\]/g;
+const REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+
+const utf8Bytes = text => Buffer.from(text, "utf8").toString("latin1");
+
+// Ripgrep glob wildcards and classes consume UTF-8 bytes, not UTF-16 characters.
+class Utf8GlobRegExp extends RegExp {
+  test(filePath) {
+    return super.test(utf8Bytes(filePath));
+  }
+}
 
 /** Translate one glob token at index i → [regexSource, nextIndex]. */
-function globToken(glob, i) {
+function globToken(glob, i, branchStart = false, inGroup = false) {
   const ch = glob[i];
 
+  if (ch === "\\" && i + 1 < glob.length) return [glob[i + 1].replace(REGEX_SPECIAL, "\\$&"), i + 2];
+
   if (ch === "*" && glob[i + 1] === "*") {
     const slashAfter = glob[i + 2] === "/";
+    // Brace endings terminate slash-prefixed recursive suffixes, not bare ** branches.
+    const branchSuffix = inGroup && glob[i - 1] === "/" && (glob[i + 2] === "," || glob[i + 2] === "}");
+    const recursive = (branchStart || i === 0 || glob[i - 1] === "/") && (slashAfter || i + 2 === glob.length || branchSuffix);
+
+    if (!recursive) return ["[^/]*", i + 2];
 
     return [slashAfter ? "(?:.*/)?" : ".*", i + (slashAfter ? 3 : 2)];
   }
@@ -21,14 +37,59 @@ function globToken(glob, i) {
 
 /** {a,b} alternation or [..] class starting at i. */
 function globGroup(glob, i, open) {
-  const close = open === "{" ? "}" : "]";
-  const end = glob.indexOf(close, i);
+  if (open === "{") {
+    const alternatives = [];
+    let source = "", next = i + 1, branchStart = true;
+
+    while (next < glob.length) {
+      if (glob[next] === "}" || glob[next] === ",") {
+        // rg discards empty alternatives; an all-empty group contributes no text.
+        if (source) alternatives.push(source);
+
+        if (glob[next] === "}") return [alternatives.length ? "(?:" + alternatives.join("|") + ")" : "", next + 1];
+        source = "";
+        next++;
+        branchStart = true;
+        continue;
+      }
+
+      // Nested groups and escaped punctuation belong to a single alternative.
+      const [piece, end] = globToken(glob, next, branchStart, true);
+      source += piece;
+      next = end;
+      branchStart = false;
+    }
+
+    throw new SyntaxError("unclosed { in glob");
+  }
+
+  let start = i + 1;
+
+  if (glob[start] === "!" || glob[start] === "^") start++;
 
-  if (end < 0) throw new SyntaxError("unclosed " + open + " in glob");
-  const inner = glob.slice(i + 1, end);
-  const source = open === "{"
-    ? "(?:" + inner.split(",").map(globBody).join("|") + ")"
-    : "[" + (inner.startsWith("!") ? "^" + inner.slice(1) : inner) + "]";
+  // A leading ] after optional negation is a member, not the class terminator.
+  if (glob[start] === "]") start++;
+
+  const end = glob.indexOf("]", start);
+
+  if (end < 0) throw new SyntaxError("unclosed [ in glob");
+  // rg treats class backslashes literally and chained ranges replace the last
+  // range's endpoint: [a-c-e] is a-e, while [a-c-b] is a-b.
+  const negated = glob[i + 1] === "!" || glob[i + 1] === "^";
+  const inner = glob.slice(i + 1 + (negated ? 1 : 0), end);
+  const ranges = [];
+
+  for (let j = 0; j < inner.length; j++) {
+    if (inner[j] === "-" && ranges.length && j + 1 < inner.length) {
+      const range = ranges.at(-1);
+      range[1] = inner[++j];
+
+      if (range[0] > range[1]) throw new SyntaxError("invalid range in glob");
+    } else ranges.push([inner[j], inner[j]]);
+  }
+
+  const escapeByte = byte => "\\][^-".includes(byte) ? "\\" + byte : byte;
+  const source = "[" + (negated ? "^" : "") + ranges.map(([first, last]) => escapeByte(first) + (first === last ? "" : "-" + escapeByte(last))).join("") + "]";
 
   return [source, end + 1];
 }
@@ -48,7 +109,28 @@ function globBody(glob) {
 
 /** gitignore-style glob (rg -g) → RegExp over a "/"-separated relative path. No slash ⇒ basename match anywhere. */
 export function globToRegExp(glob) {
-  const body = globBody(glob);
+  const excluded = glob.startsWith("!");
+
+  if (excluded) glob = glob.slice(1);
+  const rooted = glob.startsWith("/");
+  const directoryOnly = excluded && glob.endsWith("/");
+
+  if (directoryOnly) {
+    glob = glob.slice(0, -1);
+    // Removing an escaped separator must not leave its escape as filename payload.
+    const escapes = /\\+$/.exec(glob)?.[0].length ?? 0;
+
+    if (escapes % 2) glob = glob.slice(0, -1);
+  }
+
+  const anchored = rooted || glob.includes("/");
+
+  if (glob.startsWith("/")) glob = glob.slice(1);
+  const body = globBody(utf8Bytes(glob));
+
+  // An excluded directory prunes its descendants, not only an exact path.
+  // Dot-all keeps CR/LF filename bytes inside recursive and basename prefixes.
+  if (excluded) return new Utf8GlobRegExp("^(?!" + (anchored ? "" : "(?:.*/)?") + body + (directoryOnly ? "/" : "(?:/|$)") + ")[\\s\\S]*$", "s");
 
-  return new RegExp(glob.includes("/") ? "^" + body + "$" : "(?:^|/)" + body + "$");
+  return new Utf8GlobRegExp(anchored ? "^" + body + "$" : "(?:^|/)" + body + "$", "s");
 }

package/src/fs/json-read.js

@@ -5,7 +5,7 @@ export const MAX_JSON_BYTES = 16 * 1024 * 1024;
 const SELECTOR_HELP = 'JSON selector supports .field, .nested[0], .items[0:3], .items.length, .["quoted.key"], or . (whole value); not full jq';
 
 function parseIdentStep(rest, first) {
-  const match = (first ? /^([A-Za-z_$][\w$]*)/ : /^\.([A-Za-z_$][\w$]*)/).exec(rest);
+  const match = (first ? /^([A-Za-z_$][\w$-]*)/ : /^\.([A-Za-z_$][\w$-]*)/).exec(rest);
 
   return match ? { step: { key: match[1] }, match } : null;
 }
@@ -57,7 +57,8 @@ function missingJsonField(value, key) {
   const keys = isObject(value) ? Object.keys(value) : [];
   const preview = keys.length ? "; available keys: " + keys.slice(0, 24).map(key => JSON.stringify(key)).join(", ") + (keys.length > 24 ? ", …" : "") : "";
 
-  return new Error("JSON field not found: " + JSON.stringify(key) + preview);
+  return new Error("JSON field not found: " + JSON.stringify(key) + preview
+    + "; for optional fields, select the parent object (json:true for the root) and apply ?? defaults in guest code");
 }
 
 function selectKey(value, key) {

package/src/fs/json-size.js

@@ -37,7 +37,8 @@ export function jsonStringLength(s) {
   return n;
 }
 
-/** Largest prefix whose JSON.stringify length is <= limit. */
+/** Largest prefix whose JSON.stringify length is <= limit when limit >= 2.
+ * Below 2, returns 0 as a sentinel: even the empty quoted string cannot fit. */
 export function maxJsonStringPrefix(s, limit) {
   let used = 2;
   let i = 0;

package/src/fs/lines.js

@@ -39,6 +39,8 @@ export function sliceLinesRawInfo(text, offset, limit) {
 
 /** Read-window slicing preserves the selected lines' own line ending. */
 export function sliceLinesRaw(text, offset, limit) {
+  if (!isNumber(offset) && !isNumber(limit)) return text;
+
   return sliceLinesRawInfo(text, offset, limit).text;
 }
 
@@ -51,9 +53,25 @@ export function sourceLines(content) {
 }
 
 export function lineNumberAt(content, index) {
-  let line = 1;
+  // Limit the search to the prefix, including offsets inside a surrogate pair.
+  const text = content.slice(0, Math.max(0, Math.ceil(index)));
+  let line = 1, sampleStart = 0, sampled = 0;
+
+  for (let at = text.indexOf("\n"); at >= 0; at = text.indexOf("\n", at + 1)) {
+    line++;
 
-  for (let i = 0; i < index; i++) if (content.charCodeAt(i) === 10) line++;
+    if (++sampled === 64) {
+      // Native search wins on source lines, but repeated calls regress dense text.
+      if (at - sampleStart < 512) {
+        for (let i = at + 1; i < text.length; i++) if (text.charCodeAt(i) === 10) line++;
+
+        return line;
+      }
+
+      sampleStart = at;
+      sampled = 0;
+    }
+  }
 
   return line;
 }
@@ -100,6 +118,7 @@ export function contentLineInfo(text, previewLimit = 0) {
   const preview = [];
   let count = 0;
   let start = 0;
+  let sampleStart = 0, sampled = 0;
 
   do {
     const newline = text.indexOf("\n", start);
@@ -107,8 +126,36 @@ export function contentLineInfo(text, previewLimit = 0) {
 
     if (preview.length < previewLimit) preview.push(text.slice(start, end).replace(/\r$/, ""));
     count++;
+
     if (newline < 0) break;
     start = newline + 1;
+
+    if (++sampled === 64) {
+      // Once the preview is complete, dense text is cheaper to scan by code
+      // unit than to make a native substring search for every short line.
+      if (newline - sampleStart < 512 && preview.length >= previewLimit) {
+        let newlines = count;
+
+        let index = start;
+
+        while (index < text.length) {
+          const end = Math.min(index + 512, text.length);
+          const previous = newlines;
+
+          for (; index < end; index++) if (text.charCodeAt(index) === 10) newlines++;
+
+          // A dense prefix does not justify scanning a large sparse tail.
+          if (index < text.length && newlines - previous < 64) break;
+        }
+
+        if (index === text.length) return { count: newlines + Number(!text.endsWith("\n")), preview, newlines };
+        count = newlines;
+        start = index;
+      }
+
+      sampleStart = start;
+      sampled = 0;
+    }
   } while (start < text.length);
 
   return { count, preview, newlines: count - Number(!text.endsWith("\n")) };