latexml/

main_tex.rs

//! Main `.tex` discovery for directory inputs.
//!
//! Equivalent to the binary's `--whatsin=directory` mode: given a
//! source directory, return the path of the file the converter should
//! treat as the top-level entrypoint. Lifted from
//! `bin/latexml_oxide.rs` so embedders (e.g. `ar5iv-editor`,
//! `cortex_worker`) can run the same heuristic without shelling out.
//!
//! Detection order:
//!  1. `00README.json` "sources" entry with `usage == "toplevel"` (modern arXiv format).
//!  2. `00README.XXX` line tagged `toplevelfile` (legacy arXiv). Lines tagged `ignore` exclude the
//!     named file from later heuristic scanning (Perl `Pack.pm::detect_source` `unlink`s them; we
//!     filter the candidate list instead — safer if the directory isn't a sandbox).
//!  3. Pack.pm-derived likelihood scoring across every `.tex` / `.txt` / `.ltx` (and, as a
//!     fallback, every long-extensioned or extension-less file). Files vetoed by `\input` /
//!     `\include` references are excluded; `\documentclass` / `\documentstyle` and Mac-classic
//!     markers boost the score; bibtex / metafont / %auto-ignore / withdrawal sentinels disqualify.
//!
//! Returns the absolute path of the chosen entry as a `PathBuf`. The
//! `Err` arm carries a Perl-canonical `Fatal:invalid:not_tex_source`
//! style message (matching what the binary printed before this lift).

use std::path::{Path, PathBuf};

use once_cell::sync::Lazy;
use regex::Regex;

/// Discover the main `.tex` file inside `dir`, mirroring the binary's
/// `--whatsin=directory` heuristic. The returned path is rooted at
/// `dir`. Errors carry a human-readable diagnostic on `Fatal:` failure
/// modes (PDF mis-named as TeX, only `%auto-ignore` files, no TeX at
/// all).
pub fn find_main_tex(dir: &Path) -> Result<PathBuf, String> {
  // Phase I.1: Check 00README.json (2025 arXiv format)
  // Format: { "sources": [{"filename": "main.tex", "usage": "toplevel"}, ...] }
  if let Some(filename) = parse_readme_json(dir) {
    let main_path = dir.join(&filename);
    if main_path.exists() {
      return Ok(main_path);
    }
  }

  // Phase I.1.2: Check 00README.XXX (legacy arXiv format).
  // Two directive kinds supported (Perl Pack.pm L82-97):
  //   `<name> toplevelfile` → shortcut, return directly.
  //   `<name> ignore`       → exclude `<name>` from heuristic
  //                            candidate scanning below.
  // Perl additionally `unlink`s the ignored path; we instead carry
  // the names through as a Phase-I.2 filter set — safer (no
  // filesystem mutation in case the directory isn't a sandbox).
  let mut ignored_names: rustc_hash::FxHashSet<PathBuf> = rustc_hash::FxHashSet::default();
  let readme_xxx = dir.join("00README.XXX");
  if readme_xxx.exists()
    && let Ok(content) = std::fs::read_to_string(&readme_xxx)
  {
    for line in content.lines() {
      let parts: Vec<&str> = line.split_whitespace().collect();
      if parts.len() < 2 {
        continue;
      }
      match parts[1] {
        "toplevelfile" => {
          let main_path = dir.join(parts[0]);
          if main_path.exists() {
            return Ok(main_path);
          }
        },
        "ignore" => {
          ignored_names.insert(dir.join(parts[0]));
        },
        _ => {},
      }
    }
  }

  // Phase I.2: Heuristic detection (ported from arXiv::FileGuess via Pack.pm)
  let mut tex_files: Vec<PathBuf> = Vec::new();
  collect_tex_files(dir, &mut tex_files, false);
  if !ignored_names.is_empty() {
    tex_files.retain(|p| !ignored_names.contains(p));
  }
  let candidates_before_pdf_filter = tex_files.len();
  tex_files.retain(|p| !is_pdf_magic(p));
  if tex_files.is_empty() && candidates_before_pdf_filter > 0 {
    return Err(s(
      "Fatal:invalid:not_tex_source PDF magic detected in source file (no TeX-format files in archive)",
    ));
  }
  if tex_files.is_empty() {
    collect_tex_files(dir, &mut tex_files, true);
    tex_files.retain(|p| !is_pdf_magic(p));
    if !ignored_names.is_empty() {
      tex_files.retain(|p| !ignored_names.contains(p));
    }
  }
  if tex_files.is_empty() {
    return Err(s("No .tex files found in directory"));
  }

  // Score each file: likelihood 0-3 (Perl: Main_TeX_likelihood)
  let mut likelihood: rustc_hash::FxHashMap<PathBuf, f32> = rustc_hash::FxHashMap::default();
  // (vetoed_path, vetoer_path) — the veto is honored at filtering
  // time only when the vetoer's score >= the vetee's. Prevents a
  // 2-line wrapper file (e.g. `\input{main}`) from removing the
  // documentclass-bearing main.tex. Witness 2307.13586.
  let mut vetoed: Vec<(PathBuf, PathBuf)> = Vec::new();
  let mut had_auto_ignore = false;

  for tex_file in &tex_files {
    if !tex_file.exists() {
      continue;
    }
    let Ok(raw) = std::fs::read(tex_file) else {
      continue;
    };
    let content = String::from_utf8_lossy(&raw);
    let mut maybe_tex = false;
    let mut maybe_tex_priority = false;
    let mut maybe_tex_priority2 = false;
    let mut determined = false;

    for (lineno, raw_line) in content.lines().enumerate() {
      let lineno1 = lineno + 1;
      // Perl L117-120: early-line checks (first 10-12 lines)
      if lineno1 <= 10
        && (RE_AUTOIGNORE.is_match(raw_line)
          || RE_TEXINFO.is_match(raw_line)
          || RE_AUTOINCLUDE.is_match(raw_line))
      {
        likelihood.insert(tex_file.clone(), 0.0);
        if RE_AUTOIGNORE.is_match(raw_line) {
          had_auto_ignore = true;
        }
        determined = true;
        break;
      }
      if lineno1 <= 12
        && let Some(cap) = RE_FORMAT_HINT.captures(raw_line)
      {
        let fmt = &cap[1];
        if fmt == "latex209" || fmt == "biglatex" || fmt == "latex" || fmt == "LaTeX" {
          likelihood.insert(tex_file.clone(), 3.0);
        } else {
          likelihood.insert(tex_file.clone(), 1.0);
        }
        determined = true;
        break;
      }
      // Perl L128: strip ONE `%`-comment up to the next `\r`. `\r`-aware
      // so bare-`\r` line-ended files (read as one big "line" in Perl
      // because `$/=\n`) preserve subsequent `\r\documentclass` chunks.
      let stripped: std::borrow::Cow<str> = RE_STRIP_COMMENT.replacen(raw_line, 1, "");
      let line: &str = &stripped;

      if RE_DOCCLASS.is_match(line) {
        likelihood.insert(tex_file.clone(), 3.0);
        determined = true;
        break;
      }
      if RE_MAYBE_TEX.is_match(line) {
        maybe_tex = true;
      }
      // Perl L133-148: \input/\include → veto the included file
      if let Some(cap) = RE_INPUT_INCLUDE.captures(line) {
        maybe_tex = true;
        let mut vetoed_name = cap[1].to_string();
        if RE_AMSTEX.is_match(&vetoed_name) {
          likelihood.insert(tex_file.clone(), 2.0);
          determined = true;
          break;
        }
        if !vetoed_name.contains('.') {
          vetoed_name = vetoed_name.trim_end().to_string() + ".tex";
        }
        let base_dir = tex_file.parent().unwrap_or(dir);
        vetoed.push((base_dir.join(&vetoed_name), tex_file.clone()));
      }
      if RE_END_BYE.is_match(line) {
        maybe_tex_priority = true;
      }
      if RE_END_BYE2.is_match(line) {
        maybe_tex_priority2 = true;
      }
      if RE_MAC_TEX.is_match(line) {
        likelihood.insert(tex_file.clone(), 1.0);
        determined = true;
        break;
      }
      if RE_METAFONT.is_match(line) {
        likelihood.insert(tex_file.clone(), 0.0);
        determined = true;
        break;
      }
      if RE_BIBTEX.is_match(raw_line) {
        likelihood.insert(tex_file.clone(), 0.0);
        determined = true;
        break;
      }
      if RE_UUENCODE.is_match(raw_line) {
        if maybe_tex_priority {
          likelihood.insert(tex_file.clone(), 2.0);
        } else if maybe_tex {
          likelihood.insert(tex_file.clone(), 1.0);
        } else {
          likelihood.insert(tex_file.clone(), 0.0);
        }
        determined = true;
        break;
      }
      if RE_WITHDRAWN.is_match(line) {
        likelihood.insert(tex_file.clone(), 0.0);
        determined = true;
        break;
      }
    }
    if !determined {
      let score = if maybe_tex_priority {
        2.0
      } else if maybe_tex_priority2 {
        1.5
      } else if maybe_tex {
        1.0
      } else {
        0.0
      };
      likelihood.insert(tex_file.clone(), score);
    }
  }

  for (vetee, vetoer) in &vetoed {
    let vetee_score = likelihood.get(vetee).copied().unwrap_or(0.0);
    let vetoer_score = likelihood.get(vetoer).copied().unwrap_or(0.0);
    if vetoer_score >= vetee_score {
      likelihood.remove(vetee);
    }
  }

  let mut candidates: Vec<PathBuf> = likelihood
    .keys()
    .filter(|f| likelihood[*f] > 0.0)
    .cloned()
    .collect();
  candidates.sort_by(|a, b| likelihood[b].partial_cmp(&likelihood[a]).unwrap());

  if candidates.is_empty() {
    if had_auto_ignore {
      // Perl-faithful: process %auto-ignore sources as normal (the
      // `%` is a comment, the rest is empty → empty XML output, no
      // Fatal). Witness: 2307.10758 (12-byte `%auto-ignore` source) —
      // Perl reports "Conversion complete: No obvious problems"; the
      // old Rust path turned 90 wp4 corpus entries into hard
      // failures. Cortex_worker has a sibling fix; both must stay in
      // sync. Prefer the dirname-matching .tex (arxiv convention
      // `<id>/<id>.tex`), else the first available.
      let dir_name = dir.file_name().and_then(|s| s.to_str()).unwrap_or_default();
      let auto_ignore_main = tex_files
        .iter()
        .find(|p| {
          p.file_stem()
            .and_then(|s| s.to_str())
            .is_some_and(|stem| stem == dir_name)
        })
        .cloned()
        .or_else(|| tex_files.first().cloned());
      if let Some(p) = auto_ignore_main {
        return Ok(p);
      }
    }
    return Err(s("No viable .tex files found in directory"));
  }

  let max_score = likelihood[&candidates[0]];
  candidates.retain(|f| (likelihood[f] - max_score).abs() < f32::EPSILON);

  if candidates.len() > 1 {
    let min_depth = candidates
      .iter()
      .map(|f| f.strip_prefix(dir).unwrap_or(f).components().count())
      .min()
      .unwrap_or(0);
    candidates.retain(|f| f.strip_prefix(dir).unwrap_or(f).components().count() == min_depth);
  }

  // OXIDIZED_DESIGN #132 (surpass-perl): the `.bbl`-sibling heuristic runs
  // BEFORE the pdf-`\includegraphics` heuristic — Perl (Pack.pm L197-204)
  // runs them in the opposite order. arXiv requires the compiled `<main>.bbl`
  // to be bundled (BibTeX is not re-run), so a candidate with a matching
  // `.bbl` is the single strongest fingerprint of the real top-level file.
  // Perl's pdf heuristic, run first, silently eliminates a true main that
  // delegates all its figures to `\input`-ed section files (hence carries no
  // direct `\includegraphics`) whenever a shipped class template / how-to /
  // supplement DOES contain an example `\includegraphics{fig.png}`; the `.bbl`
  // tie-break that would have rescued it never gets to run. Ordering `.bbl`
  // first fixes that class. Witnesses (all SHARED-FAILURE vs production Perl,
  // html_feedback autotex issues): 2407.05010 (#1721, IEEEtran how-to),
  // 2409.06957 (#6100, ICLR template), 2409.02543 (#5867, supp.tex),
  // 2406.08688 (#5476, IEEEtran template), 2310.02368 (#4156, IEEE template),
  // 2505.05625 (#4067, supplementary.tex), 2410.12672 (#2369, ICLR template),
  // 2410.01562 (#2224, ICASSP template), 2401.17263 (#442, ICML example_paper),
  // 2403.17719 (#859, rebuttal.tex). When >1 candidate carries a `.bbl` (e.g.
  // 2506.05564, 2401.07129) the set survives and the later heuristics
  // (pdf-include, common-name, alphabetical) still discriminate as before.
  if candidates.len() > 1 {
    let bbl_candidates: Vec<PathBuf> = candidates
      .iter()
      .filter(|f| f.with_extension("bbl").exists())
      .cloned()
      .collect();
    if !bbl_candidates.is_empty() {
      candidates = bbl_candidates;
    }
  }

  if candidates.len() > 1 {
    let pdf_candidates: Vec<PathBuf> = candidates
      .iter()
      .filter(|f| has_pdftex_marker(f))
      .cloned()
      .collect();
    if !pdf_candidates.is_empty() {
      candidates = pdf_candidates;
    }
  }

  if candidates.len() > 1 {
    let common: Vec<PathBuf> = candidates
      .iter()
      .filter(|f| {
        f.file_name().is_some_and(|n| {
          let n = n.to_str().unwrap_or("");
          n == "main.tex" || n == "ms.tex" || n == "paper.tex"
        })
      })
      .cloned()
      .collect();
    if !common.is_empty() {
      candidates = common;
    }
  }

  candidates.sort();
  Ok(
    candidates
      .into_iter()
      .next()
      .expect("non-empty after filtering"),
  )
}

/// Ordered list of top-level `.tex` files: the main document first, then any
/// **Supplementary-Material** documents that ship alongside it. `find_main_tex`
/// returns element 0 of this list; embedders that want to convert the whole
/// submission (main + supplements, appended in order — arXiv's multi-top-level
/// model, [`submit_legacy_differences`]) drive off the full list.
///
/// Detection is deliberately **precision-first / template-safe**. A supplement
/// is admitted only when it is a `\documentclass` file that (a) ships its own
/// matching `.bbl` — arXiv's canonical `ms.tex`+`ms.bbl` / `supplement.tex`+
/// `supplement.bbl` fingerprint, which bundled class *templates* do not have —
/// and (b) self-identifies as supplementary by `\title` or filename
/// (`supplement`/`supporting`/`supplemental`/`appendix`/`SI`/`SM`). Both gates
/// together keep a messy bundle's template from ever being mistaken for a
/// second document. An explicit `00README` listing two or more top-level files
/// overrides the heuristic (author intent), still ordered main-first.
///
/// Conservative residual: a supplement bundled *without* its own `.bbl`, or one
/// that does not self-identify, is not auto-detected.
///
/// [`submit_legacy_differences`]: https://info.arxiv.org/help/submit_legacy_differences.html
pub fn find_top_level_texs(dir: &Path) -> Result<Vec<PathBuf>, String> {
  // An explicit multi-file 00README designation wins over the heuristic.
  let explicit = explicit_top_levels(dir);
  if explicit.len() >= 2 {
    return Ok(order_main_first(explicit, dir));
  }
  let main = find_main_tex(dir)?;
  // The set of `.bbl`-backed top-level documents at the main's depth — arXiv's
  // multi-top-level fingerprint. Include `main` even if it ships no `.bbl`
  // (inline bibliography) so a `.bbl`-backed supplement can still attach to it.
  let mut set = top_level_bbl_docs(dir, &main);
  if !set.contains(&main) {
    set.push(main.clone());
  }
  // Split into the single true main (the lone non-supplement) and supplements.
  // This is done over the whole set rather than trusting `find_main_tex`'s
  // alphabetical tie-break, which can pick a supplement (e.g. `Appendix.tex`
  // sorts before `Note.tex`) when two `.bbl` documents are otherwise level.
  let (mut supps, mains): (Vec<PathBuf>, Vec<PathBuf>) =
    set.into_iter().partition(|f| is_supplement(f));
  if mains.len() == 1 && !supps.is_empty() {
    supps.sort();
    supps.dedup();
    let mut tops = mains;
    tops.extend(supps);
    return Ok(tops);
  }
  // No clean 1-main + supplements split → single-file (unchanged behavior).
  Ok(vec![main])
}

// ---------------------------------------------------------------------------
// Internal helpers.
// ---------------------------------------------------------------------------

fn s(msg: &str) -> String { msg.to_string() }

/// All files a `00README.json`/`00README.XXX` explicitly marks as top-level, in
/// listed order, restricted to those that exist (main-first ordering applied by
/// the caller). Empty when there is no explicit designation.
fn explicit_top_levels(dir: &Path) -> Vec<PathBuf> {
  let mut out: Vec<PathBuf> = Vec::new();
  for name in parse_readme_json_all(dir) {
    let p = dir.join(&name);
    if p.exists() && !out.contains(&p) {
      out.push(p);
    }
  }
  let readme_xxx = dir.join("00README.XXX");
  if let Ok(content) = std::fs::read_to_string(&readme_xxx) {
    for line in content.lines() {
      let parts: Vec<&str> = line.split_whitespace().collect();
      if parts.len() >= 2 && parts[1] == "toplevelfile" {
        let p = dir.join(parts[0]);
        if p.exists() && !out.contains(&p) {
          out.push(p);
        }
      }
    }
  }
  out
}

/// The set of `.bbl`-backed top-level documents at `main`'s depth: `\document`-
/// class files that carry their own sibling `.bbl` (arXiv's own top-level
/// fingerprint, which bundled templates lack), excluding `%auto-ignore` and
/// `00README` `ignore` files. `main` itself is included when it qualifies.
fn top_level_bbl_docs(dir: &Path, main: &Path) -> Vec<PathBuf> {
  let main_depth = main.strip_prefix(dir).unwrap_or(main).components().count();
  let ignored = readme_ignored(dir);
  let mut tex_files: Vec<PathBuf> = Vec::new();
  collect_tex_files(dir, &mut tex_files, false);
  tex_files
    .into_iter()
    .filter(|f| f.strip_prefix(dir).unwrap_or(f).components().count() == main_depth)
    .filter(|f| !ignored.contains(f))
    .filter(|f| !has_auto_ignore(f))
    .filter(|f| f.with_extension("bbl").exists())
    .filter(|f| file_has_documentclass(f))
    .collect()
}

/// Files a `00README.XXX` marks `ignore` (Perl `Pack.pm` `unlink`s them; we
/// exclude by set — see `find_main_tex`).
fn readme_ignored(dir: &Path) -> rustc_hash::FxHashSet<PathBuf> {
  let mut ignored = rustc_hash::FxHashSet::default();
  if let Ok(content) = std::fs::read_to_string(dir.join("00README.XXX")) {
    for line in content.lines() {
      let parts: Vec<&str> = line.split_whitespace().collect();
      if parts.len() >= 2 && parts[1] == "ignore" {
        ignored.insert(dir.join(parts[0]));
      }
    }
  }
  ignored
}

/// Whether one of the file's first 10 lines carries the `%auto-ignore` marker
/// (arXiv: keep in the bundle, do not process — `submit_legacy_differences`).
fn has_auto_ignore(path: &Path) -> bool {
  let Ok(raw) = std::fs::read(path) else {
    return false;
  };
  String::from_utf8_lossy(&raw)
    .lines()
    .take(10)
    .any(|l| RE_AUTOIGNORE.is_match(l))
}

/// Order a set of top-level files main-first: any file that looks like a
/// supplement goes last (arXiv-alphanumeric within each group); among the
/// non-supplements a `main`/`ms`/`paper` common name is promoted to the front.
fn order_main_first(mut files: Vec<PathBuf>, _dir: &Path) -> Vec<PathBuf> {
  files.sort();
  files.dedup();
  let (supps, mut mains): (Vec<PathBuf>, Vec<PathBuf>) =
    files.into_iter().partition(|f| is_supplement(f));
  if let Some(pos) = mains.iter().position(|f| is_common_main_name(f)) {
    let m = mains.remove(pos);
    mains.insert(0, m);
  }
  mains.extend(supps);
  mains
}

/// Whether the file names itself `main.tex` / `ms.tex` / `paper.tex` (the same
/// common-name set the single-file heuristic prefers).
fn is_common_main_name(path: &Path) -> bool {
  path
    .file_name()
    .and_then(|n| n.to_str())
    .is_some_and(|n| n == "main.tex" || n == "ms.tex" || n == "paper.tex")
}

/// A top-level `.tex` reads as Supplementary Material when its filename or its
/// `\title` announces it (`supplement`/`supporting`/`supplemental`/`appendix`/
/// delimited `SI`/`SM`). Used only among *already* `.bbl`-backed sibling
/// documents, so this classifies main-vs-supplement; it never promotes a
/// template into a document.
fn is_supplement(path: &Path) -> bool {
  if let Some(stem) = path.file_stem().and_then(|s| s.to_str())
    && RE_SUPP_NAME.is_match(stem)
  {
    return true;
  }
  if let Some(title) = first_title(path)
    && RE_SUPP_TITLE.is_match(&title)
  {
    return true;
  }
  false
}

/// True when the file defines a `\documentclass`/`\documentstyle` (i.e. is a
/// top-level document, not an `\input`-ed fragment).
fn file_has_documentclass(path: &Path) -> bool {
  let Ok(raw) = std::fs::read(path) else {
    return false;
  };
  let content = String::from_utf8_lossy(&raw);
  content.lines().any(|l| {
    let stripped = RE_STRIP_COMMENT.replacen(l, 1, "");
    RE_DOCCLASS.is_match(&stripped)
  })
}

/// The text of the first non-commented `\title{…}` / `\icmltitle{…}` in the
/// file (up to ~120 chars), for supplement classification.
fn first_title(path: &Path) -> Option<String> {
  let raw = std::fs::read(path).ok()?;
  let content = String::from_utf8_lossy(&raw);
  // Strip `%`-comments line-by-line so a commented template placeholder title
  // (`%% \title{Title}`) does not count. Witness 2402.13498 (elsarticle).
  let stripped: String = content
    .lines()
    .map(|l| RE_STRIP_COMMENT.replacen(l, 1, "").into_owned())
    .collect::<Vec<_>>()
    .join("\n");
  RE_TITLE_ARG
    .captures(&stripped)
    .map(|c| c[1].chars().take(120).collect())
}

/// Parse `00README.json` and return the filenames of **every** `usage ==
/// "toplevel"` source, in document order. `parse_readme_json` returns only the
/// first; this drives multi-top-level detection.
fn parse_readme_json_all(dir: &Path) -> Vec<String> {
  let mut out = Vec::new();
  let Ok(content) = std::fs::read_to_string(dir.join("00README.json")) else {
    return out;
  };
  let Some(sources_start) = content.find("\"sources\"") else {
    return out;
  };
  let rest = &content[sources_start..];
  let (Some(arr_start), Some(arr_end)) = (rest.find('['), rest.find(']')) else {
    return out;
  };
  let arr = &rest[arr_start + 1..arr_end];
  for obj_str in arr.split('}') {
    if !obj_str.contains("\"toplevel\"") {
      continue;
    }
    if let Some(fn_pos) = obj_str.find("\"filename\"") {
      let after = obj_str[fn_pos + 10..].trim_start();
      if let Some(after) = after.strip_prefix(':') {
        let after = after.trim_start();
        if let Some(after) = after.strip_prefix('"') {
          let name: String = after
            .chars()
            .take_while(|&c| c != '"')
            .filter(|&c| c != '\\')
            .collect();
          if !name.is_empty() {
            out.push(name);
          }
        }
      }
    }
  }
  out
}

// Perl Pack.pm L25 TEX_EXT = qr/\.(?:[tT](:?[eE][xX]|[xX][tT])|ltx|LTX)$/
// → .tex, .txt, .ltx (case-insensitive). The `fallback` arm matches Perl
// Pack/Dir.pm L47: `!/\./ || /\.[^.]{4,}$/` — extension-less or extension
// ≥4 chars, used when nothing TeX-shaped surfaces in the strict pass.
fn collect_tex_files(dir: &Path, files: &mut Vec<PathBuf>, fallback: bool) {
  if let Ok(entries) = std::fs::read_dir(dir) {
    for entry in entries.flatten() {
      let path = entry.path();
      if path.is_dir() {
        collect_tex_files(&path, files, fallback);
      } else if !fallback {
        if path.extension().is_some_and(|e| {
          let e = e.to_ascii_lowercase();
          e == "tex" || e == "txt" || e == "ltx"
        }) {
          files.push(path);
        }
      } else {
        let ext_opt = path.extension().and_then(|e| e.to_str());
        let keep = match ext_opt {
          None => true,
          Some(ext) => ext.len() >= 4,
        };
        if keep {
          files.push(path);
        }
      }
    }
  }
}

// Faithful port of Perl `Pack.pm::heuristic_check_for_pdftex` (L222-241):
// a file counts as a pdf-include candidate only when some line carries
// `\includegraphics{...ext}` with the raster/pdf extension INSIDE the
// argument (`\includegraphics[^%]*\.(?:pdf|png|gif|jpg)\s?\}`, case-insensitive,
// not preceded by a `%`), or a `\pdfoutput=1` marker. Perl's `$pdfoutput_checks`
// counter clamps at 0, so its `>= 0` guard is always true and the `\pdfoutput`
// probe effectively scans every line — we mirror that (no first-N-lines cap).
//
// The earlier Rust port used a loose whole-file
// `contains("\\includegraphics") && contains(".png"|".pdf"|".jpg")`, which
// FALSE-POSITIVES on class templates whose `\includegraphics` examples are
// extensionless (`{icml_numpapers}`) or `.eps` (`{egfigure.eps}`) yet mention
// a raster extension elsewhere (prose/comments). Because the pdf heuristic runs
// before the `.bbl` tie-break, that false positive eliminated the true
// figure-delegating `main.tex`: 2401.17263 (#442, example_paper.tex) and
// 2403.17719 (#859, rebuttal.tex) were mis-picked by Rust though Perl picks
// their `main.tex`. Argument-anchoring restores parity.
fn has_pdftex_marker(path: &Path) -> bool {
  let Ok(raw) = std::fs::read(path) else {
    return false;
  };
  let content = String::from_utf8_lossy(&raw);
  content
    .lines()
    .any(|line| RE_PDF_INCLUDE.is_match(line) || RE_PDFOUTPUT.is_match(line))
}

// Skip files whose magic bytes identify them as PDF (e.g. arXiv source
// archives that contain a PDF mis-named with a `.tex` extension).
pub fn is_pdf_magic(path: &Path) -> bool {
  let mut buf = [0u8; 5];
  if let Ok(mut f) = std::fs::File::open(path) {
    use std::io::Read;
    if f.read(&mut buf).is_ok_and(|n| n == 5) {
      return &buf == b"%PDF-";
    }
  }
  false
}

/// Parse `00README.json` in `dir` and return the "filename" of the
/// toplevel source. Perl Pack.pm L68-80: scans `sources[]` for the
/// entry tagged `usage == "toplevel"`. Minimal hand-rolled JSON
/// scanner — we don't pull a full JSON dep just for this.
fn parse_readme_json(dir: &Path) -> Option<String> { parse_readme_json_all(dir).into_iter().next() }

// ---------------------------------------------------------------------------
// Pre-compiled regexes used by `find_main_tex`. Parking these as module-
// level `Lazy<Regex>` keeps a single instance per process and avoids the
// per-call recompile that nesting them inside the function caused.
// ---------------------------------------------------------------------------

static RE_AUTOIGNORE: Lazy<Regex> = Lazy::new(|| Regex::new(r"%auto-ignore").unwrap());
static RE_TEXINFO: Lazy<Regex> = Lazy::new(|| Regex::new(r"\\input texinfo").unwrap());
static RE_AUTOINCLUDE: Lazy<Regex> = Lazy::new(|| Regex::new(r"%auto-include").unwrap());
static RE_FORMAT_HINT: Lazy<Regex> = Lazy::new(|| Regex::new(r"^\r?%&(\S+)").unwrap());
static RE_DOCCLASS: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"(?:^|\r)\s*\\document(?:style|class)").unwrap());
static RE_MAYBE_TEX: Lazy<Regex> = Lazy::new(|| {
  Regex::new(r"(?:^|\r)\s*\\(?:font|magnification|input|def|special|baselineskip|begin)").unwrap()
});
static RE_INPUT_INCLUDE: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"\\(?:input|include)(?:\s+|\{)([^ \}]+)").unwrap());
static RE_END_BYE: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"(?:^|\r)\s*\\(?:end|bye)(?:\s|$)").unwrap());
static RE_END_BYE2: Lazy<Regex> = Lazy::new(|| Regex::new(r"\\(?:end|bye)(?:\s|$)").unwrap());
static RE_MAC_TEX: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"\\input *(?:harv|lanl)mac|\\input\s+phyzzx").unwrap());
static RE_METAFONT: Lazy<Regex> = Lazy::new(|| Regex::new(r"beginchar\(").unwrap());
static RE_BIBTEX: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"(?i)(?:^|\r)@(?:book|article|inbook|unpublished)\{").unwrap());
static RE_UUENCODE: Lazy<Regex> = Lazy::new(|| Regex::new(r"^begin \d{1,4}\s+\S+\r?$").unwrap());
static RE_WITHDRAWN: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"paper deliberately replaced by what little").unwrap());
static RE_AMSTEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^amstex$").unwrap());
// Perl `heuristic_check_for_pdftex` pdf-include probe: an `\includegraphics`
// whose argument names a raster/pdf image (case-insensitive), not behind a `%`.
static RE_PDF_INCLUDE: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"(?i)^[^%]*\\includegraphics[^%]*\.(?:pdf|png|gif|jpg)\s?\}").unwrap());
// Perl `\pdfoutput(?:\s+)?=(?:\s+)?1` marker, not behind a `%`.
static RE_PDFOUTPUT: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[^%]*\\pdfoutput\s*=\s*1").unwrap());
// Supplementary-Material detection (find_top_level_texs). Filename tokens
// (`paper_SI`, `supplement`, `z_SI_renamed`, `Supplemental_Materials`) — the
// short `si`/`sm` forms only as delimited tokens so they can't match a substring.
static RE_SUPP_NAME: Lazy<Regex> = Lazy::new(|| {
  Regex::new(r"(?i)(^|[_-])(supp(lement(ary|al)?)?|supporting|supplemental|appendix|si|sm)([_-]|$)")
    .unwrap()
});
// Supplement `\title` text ("Supplementary Information for …", "SUPPLEMENTAL
// MATERIALS", "Supporting Information", "Supplemental Materials for:").
static RE_SUPP_TITLE: Lazy<Regex> = Lazy::new(|| {
  Regex::new(r"(?i)(supplement|supporting\s+information|supplemental|appendix)").unwrap()
});
// First braced argument of a `\title`/`\icmltitle` (comments already stripped).
static RE_TITLE_ARG: Lazy<Regex> =
  Lazy::new(|| Regex::new(r"\\(?:icml)?title\s*(?:\[[^\]]*\])?\s*\{([^}]*)").unwrap());
// Strip a single `%`-comment, stopping at the next `\r` so bare-`\r`
// line-ended files (Mac classic) preserve post-comment `\documentclass`.
static RE_STRIP_COMMENT: Lazy<Regex> = Lazy::new(|| Regex::new(r"%[^\r]*").unwrap());

#[cfg(test)]
mod tests {
  use tempfile::tempdir;

  use super::*;

  fn write(dir: &Path, name: &str, body: &str) { std::fs::write(dir.join(name), body).unwrap(); }

  #[test]
  fn picks_documentclass_over_input_only_file() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "main.tex",
      "\\documentclass{article}\n\\begin{document}x\\end{document}",
    );
    write(d.path(), "intro.tex", "\\input{intro_body}\n");
    let pick = find_main_tex(d.path()).unwrap();
    assert_eq!(pick.file_name().unwrap(), "main.tex");
  }

  #[test]
  fn errors_when_directory_has_no_tex() {
    let d = tempdir().unwrap();
    let err = find_main_tex(d.path()).unwrap_err();
    assert!(err.contains("No .tex files"));
  }

  #[test]
  fn prefers_main_over_other_documentclass_files() {
    let d = tempdir().unwrap();
    write(d.path(), "draft.tex", "\\documentclass{article}\n");
    write(d.path(), "main.tex", "\\documentclass{article}\n");
    let pick = find_main_tex(d.path()).unwrap();
    assert_eq!(pick.file_name().unwrap(), "main.tex");
  }

  #[test]
  fn readme_xxx_toplevelfile_directive_short_circuits() {
    let d = tempdir().unwrap();
    // Two candidate documents — main.tex would normally win,
    // but the 00README directive points at draft.tex.
    write(d.path(), "draft.tex", "\\documentclass{article}\n");
    write(d.path(), "main.tex", "\\documentclass{article}\n");
    write(d.path(), "00README.XXX", "draft.tex toplevelfile\n");
    let pick = find_main_tex(d.path()).unwrap();
    assert_eq!(pick.file_name().unwrap(), "draft.tex");
  }

  #[test]
  fn readme_xxx_ignore_directive_excludes_candidate() {
    let d = tempdir().unwrap();
    // Without a directive, `main.tex` would tie with `old.tex`
    // and the "common name" heuristic prefers `main.tex`. With
    // an `ignore` directive on main.tex, the heuristic falls back
    // to `old.tex`.
    write(d.path(), "old.tex", "\\documentclass{article}\n");
    write(d.path(), "main.tex", "\\documentclass{article}\n");
    write(d.path(), "00README.XXX", "main.tex ignore\n");
    let pick = find_main_tex(d.path()).unwrap();
    assert_eq!(pick.file_name().unwrap(), "old.tex");
  }

  #[test]
  fn readme_xxx_mixed_directives() {
    let d = tempdir().unwrap();
    write(d.path(), "intro.tex", "\\documentclass{article}\n");
    write(d.path(), "paper.tex", "\\documentclass{article}\n");
    write(d.path(), "junk.tex", "\\documentclass{article}\n");
    // `paper.tex toplevelfile` short-circuits the heuristic; the
    // ignore line is unreachable in this test but exercises the
    // parser's multi-line/multi-kind handling.
    write(
      d.path(),
      "00README.XXX",
      "junk.tex ignore\npaper.tex toplevelfile\n",
    );
    let pick = find_main_tex(d.path()).unwrap();
    assert_eq!(pick.file_name().unwrap(), "paper.tex");
  }

  // OXIDIZED_DESIGN #132: a matching `.bbl` sibling outranks the pdf-include
  // heuristic. Models the witness class (2407.05010 #1721 et al.): the true
  // main delegates its figures (no direct `\includegraphics`) but ships a
  // `main.bbl`, while a class how-to/template carries an example
  // `\includegraphics{fig.png}`. Perl's pdf-before-bbl order (and our old port)
  // picked the template; bbl-first recovers the real main.
  #[test]
  fn bbl_sibling_outranks_pdf_include_marker() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "main.tex",
      "\\documentclass{IEEEtran}\n\\input{sections/intro}\n\\begin{document}\\title{Real}\\end{document}",
    );
    write(
      d.path(),
      "New_IEEEtran_how-to.tex",
      "\\documentclass{IEEEtran}\n\\includegraphics[width=1in]{fig1.png}\n\\begin{document}How to.\\end{document}",
    );
    write(
      d.path(),
      "main.bbl",
      "\\begin{thebibliography}{1}\\end{thebibliography}\n",
    );
    let pick = find_main_tex(d.path()).unwrap();
    assert_eq!(pick.file_name().unwrap(), "main.tex");
  }

  // Reorder must not swallow the later common-name tie-break: when >1 candidate
  // carries a `.bbl` (2506.05564, 2401.07129), the `.bbl` set survives and
  // main/ms/paper still wins over an alphabetically-earlier sibling.
  #[test]
  fn reorder_preserves_common_name_when_multiple_bbl() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "aaa.tex",
      "\\documentclass{article}\n\\includegraphics{x.png}\n",
    );
    write(
      d.path(),
      "main.tex",
      "\\documentclass{article}\n\\includegraphics{y.png}\n",
    );
    write(d.path(), "aaa.bbl", "");
    write(d.path(), "main.bbl", "");
    let pick = find_main_tex(d.path()).unwrap();
    assert_eq!(pick.file_name().unwrap(), "main.tex");
  }

  // Parity fix (Perl `heuristic_check_for_pdftex`): the extension must sit
  // INSIDE the `\includegraphics{…}` argument. The old loose whole-file
  // `contains` false-positived on templates whose examples are extensionless
  // (2401.17263 #442 `{icml_numpapers}`) or `.eps` (2403.17719 #859
  // `{egfigure.eps}`) yet mention a raster extension elsewhere.
  #[test]
  fn strict_pdf_marker_rejects_extensionless_eps_and_comments() {
    let d = tempdir().unwrap();
    // extensionless arg + an unrelated `.png` mention in prose → not a marker
    write(
      d.path(),
      "example_paper.tex",
      "\\centerline{\\includegraphics[width=\\columnwidth]{icml_numpapers}}\nResults saved as results.png.\n",
    );
    // `.eps` extension is not in the raster/pdf set
    write(
      d.path(),
      "rebuttal.tex",
      "\\includegraphics[width=0.8\\linewidth]{egfigure.eps}\n",
    );
    // commented-out include must not count (behind `%`)
    write(d.path(), "commented.tex", "%\\includegraphics{fig.png}\n");
    assert!(!has_pdftex_marker(&d.path().join("example_paper.tex")));
    assert!(!has_pdftex_marker(&d.path().join("rebuttal.tex")));
    assert!(!has_pdftex_marker(&d.path().join("commented.tex")));
  }

  #[test]
  fn strict_pdf_marker_accepts_arg_extension_and_pdfoutput() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "fig.tex",
      "\\includegraphics[width=2in]{diagram.pdf}\n",
    );
    write(d.path(), "gif.tex", "\\includegraphics{anim.gif}\n"); // Perl includes gif
    write(
      d.path(),
      "pdfout.tex",
      "\\pdfoutput=1\n\\includegraphics{noext}\n",
    );
    assert!(has_pdftex_marker(&d.path().join("fig.tex")));
    assert!(has_pdftex_marker(&d.path().join("gif.tex")));
    assert!(has_pdftex_marker(&d.path().join("pdfout.tex")));
  }

  // Multi-top-level detection (find_top_level_texs). Models the real
  // main+supplement pattern (2408.13687, 2401.07129, …): both documents carry
  // their own `.bbl`; the supplement self-identifies by title/filename.
  #[test]
  fn top_level_texs_appends_supplement() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "main.tex",
      "\\documentclass{article}\n\\title{Quantum error correction}\n",
    );
    write(
      d.path(),
      "supplement.tex",
      "\\documentclass{article}\n\\title{Supplementary Information for Quantum error correction}\n",
    );
    write(d.path(), "main.bbl", "");
    write(d.path(), "supplement.bbl", "");
    let tops = find_top_level_texs(d.path()).unwrap();
    let names: Vec<_> = tops
      .iter()
      .map(|p| p.file_name().unwrap().to_str().unwrap())
      .collect();
    assert_eq!(names, vec!["main.tex", "supplement.tex"]);
    // `find_main_tex` stays the first entry.
    assert_eq!(find_main_tex(d.path()).unwrap(), tops[0]);
  }

  // Main first even when the supplement sorts alphabetically before it
  // (2506.05564: `Note.tex` main + `Appendix.tex` supplement).
  #[test]
  fn top_level_texs_orders_main_first_despite_alpha() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "Note.tex",
      "\\documentclass{article}\n\\title{Bayesian Inference of the Landau Parameter}\n",
    );
    write(
      d.path(),
      "Appendix.tex",
      "\\documentclass{article}\n\\title{SUPPLEMENTAL MATERIALS}\n",
    );
    write(d.path(), "Note.bbl", "");
    write(d.path(), "Appendix.bbl", "");
    let tops = find_top_level_texs(d.path()).unwrap();
    let names: Vec<_> = tops
      .iter()
      .map(|p| p.file_name().unwrap().to_str().unwrap())
      .collect();
    assert_eq!(names, vec!["Note.tex", "Appendix.tex"]);
  }

  // Template safety: a bundled template (no `.bbl`, does not self-identify as a
  // supplement) is never appended, even when it carries example graphics.
  #[test]
  fn top_level_texs_excludes_template_without_bbl() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "main.tex",
      "\\documentclass{IEEEtran}\n\\input{sec}\n\\title{Real Paper}\n",
    );
    write(
      d.path(),
      "New_IEEEtran_how-to.tex",
      "\\documentclass{IEEEtran}\n\\includegraphics{fig1.png}\n\\title{How to Use the IEEEtran Templates}\n",
    );
    write(d.path(), "main.bbl", "");
    let tops = find_top_level_texs(d.path()).unwrap();
    let names: Vec<_> = tops
      .iter()
      .map(|p| p.file_name().unwrap().to_str().unwrap())
      .collect();
    assert_eq!(names, vec!["main.tex"]);
  }

  // Precision: a supplement-titled document WITHOUT its own `.bbl` is not
  // auto-detected (conservative residual).
  #[test]
  fn supplement_without_bbl_is_not_detected() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "main.tex",
      "\\documentclass{article}\n\\title{Real Paper}\n",
    );
    write(
      d.path(),
      "supp.tex",
      "\\documentclass{article}\n\\title{Supplementary Information}\n",
    );
    write(d.path(), "main.bbl", "");
    let tops = find_top_level_texs(d.path()).unwrap();
    assert_eq!(tops.len(), 1);
    assert_eq!(tops[0].file_name().unwrap(), "main.tex");
  }

  // Explicit 00README with two toplevelfile lines → both, main-first even when
  // listed supplement-first.
  #[test]
  fn readme_two_toplevelfiles_ordered_main_first() {
    let d = tempdir().unwrap();
    write(
      d.path(),
      "main.tex",
      "\\documentclass{article}\n\\title{Paper}\n",
    );
    write(
      d.path(),
      "si.tex",
      "\\documentclass{article}\n\\title{Supporting Information}\n",
    );
    write(
      d.path(),
      "00README.XXX",
      "si.tex toplevelfile\nmain.tex toplevelfile\n",
    );
    let tops = find_top_level_texs(d.path()).unwrap();
    let names: Vec<_> = tops
      .iter()
      .map(|p| p.file_name().unwrap().to_str().unwrap())
      .collect();
    assert_eq!(names, vec!["main.tex", "si.tex"]);
  }
}