Skip to main content

fallow_core/discover/
entry_points.rs

1use std::path::{Component, Path, PathBuf};
2
3use super::walk::SOURCE_EXTENSIONS;
4use fallow_config::{PackageJson, ResolvedConfig, TsconfigOutputMap, TsconfigOutputResolution};
5use fallow_graph::resolve::{OUTPUT_DIRS, directory_index_entry, output_entry_to_source_path};
6use fallow_types::discover::{DiscoveredFile, EntryPoint, EntryPointSource};
7use rustc_hash::{FxHashMap, FxHashSet};
8
9use crate::plugins::config_parser::lexical_normalize;
10use crate::scripts::{IgnoredCommandEntries, ScriptCatalog, WorkspacePackages};
11
12#[path = "manual_entries.rs"]
13mod manual_entries;
14#[path = "plugin_entries.rs"]
15mod plugin_entries;
16#[path = "wildcard_entries.rs"]
17mod wildcard_entries;
18use manual_entries::{push_manual_entry_matches, push_support_entry_matches};
19#[cfg(test)]
20use plugin_entries::discover_plugin_entry_point_sets;
21pub use plugin_entries::{discover_plugin_entry_point_sets_timed, discover_plugin_entry_points};
22use wildcard_entries::expand_wildcard_entries;
23
24const SKIPPED_ENTRY_WARNING_PREVIEW: usize = 5;
25
26fn format_skipped_entry_warning(skipped_entries: &FxHashMap<String, usize>) -> Option<String> {
27    if skipped_entries.is_empty() {
28        return None;
29    }
30
31    let mut entries = skipped_entries
32        .iter()
33        .map(|(path, count)| (path.as_str(), *count))
34        .collect::<Vec<_>>();
35    entries.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(b.0)));
36
37    let preview = entries
38        .iter()
39        .take(SKIPPED_ENTRY_WARNING_PREVIEW)
40        .map(|(path, count)| {
41            if *count > 1 {
42                format!("{path} ({count}x)")
43            } else {
44                (*path).to_owned()
45            }
46        })
47        .collect::<Vec<_>>();
48
49    let omitted = entries.len().saturating_sub(SKIPPED_ENTRY_WARNING_PREVIEW);
50    let tail = if omitted > 0 {
51        format!(" (and {omitted} more)")
52    } else {
53        String::new()
54    };
55    let total = entries.iter().map(|(_, count)| *count).sum::<usize>();
56    let noun = if total == 1 {
57        "package.json entry point"
58    } else {
59        "package.json entry points"
60    };
61
62    Some(format!(
63        "Skipped {total} {noun} outside project root or containing parent directory traversal: {}{tail}",
64        preview.join(", ")
65    ))
66}
67
68pub fn warn_skipped_entry_summary(skipped_entries: &FxHashMap<String, usize>) {
69    let Some(message) = format_skipped_entry_warning(skipped_entries) else {
70        return;
71    };
72    if should_warn_skipped_entry(&message) {
73        tracing::warn!(target: fallow_types::ANALYSIS_DIAGNOSTIC_LOG_TARGET, "{message}");
74    }
75}
76
77/// Process-wide dedupe for [`warn_skipped_entry_summary`]. Returns `true` when
78/// `message` was newly inserted (caller should emit). On a poisoned mutex
79/// returns `true` so over-warning beats swallowing.
80fn should_warn_skipped_entry(message: &str) -> bool {
81    static WARNED: std::sync::OnceLock<std::sync::Mutex<FxHashSet<String>>> =
82        std::sync::OnceLock::new();
83    let warned = WARNED.get_or_init(|| std::sync::Mutex::new(FxHashSet::default()));
84    warned
85        .lock()
86        .map_or(true, |mut set| set.insert(message.to_owned()))
87}
88
89/// Entry points grouped by reachability role.
90#[derive(Debug, Clone, Default)]
91pub struct CategorizedEntryPoints {
92    pub(crate) all: Vec<EntryPoint>,
93    pub(crate) runtime: Vec<EntryPoint>,
94    pub(crate) test: Vec<EntryPoint>,
95    /// Production mode only: files that only a user `support` entry rule
96    /// matches. They are not entry points and take no part in the analysis,
97    /// like a test file in production mode. `dedup` drops each path that a
98    /// different entry source also seeds.
99    pub(crate) production_excluded: Vec<PathBuf>,
100}
101
102impl CategorizedEntryPoints {
103    fn push_runtime(&mut self, entry: EntryPoint) {
104        self.runtime.push(entry.clone());
105        self.all.push(entry);
106    }
107
108    fn push_test(&mut self, entry: EntryPoint) {
109        self.test.push(entry.clone());
110        self.all.push(entry);
111    }
112
113    fn push_support(&mut self, entry: EntryPoint) {
114        self.all.push(entry);
115    }
116
117    pub(crate) fn extend_runtime<I>(&mut self, entries: I)
118    where
119        I: IntoIterator<Item = EntryPoint>,
120    {
121        for entry in entries {
122            self.push_runtime(entry);
123        }
124    }
125
126    pub(crate) fn extend_support<I>(&mut self, entries: I)
127    where
128        I: IntoIterator<Item = EntryPoint>,
129    {
130        for entry in entries {
131            self.push_support(entry);
132        }
133    }
134
135    /// Add the entry points of the root package. Returns the runtime entry
136    /// paths from a source other than `entry` and the skipped entry counts.
137    pub(crate) fn extend_root(
138        &mut self,
139        root: EntryPointDiscovery,
140    ) -> (FxHashSet<PathBuf>, FxHashMap<String, usize>) {
141        self.extend_runtime(root.entries);
142        self.extend_support(root.support_entries);
143        self.production_excluded.extend(root.production_excluded);
144        (root.non_manual_runtime_paths, root.skipped_entries)
145    }
146
147    pub(crate) fn extend(&mut self, other: Self) {
148        self.all.extend(other.all);
149        self.runtime.extend(other.runtime);
150        self.test.extend(other.test);
151        self.production_excluded.extend(other.production_excluded);
152    }
153
154    #[must_use]
155    pub(crate) fn dedup(mut self) -> Self {
156        dedup_entry_paths(&mut self.all);
157        dedup_entry_paths(&mut self.runtime);
158        dedup_entry_paths(&mut self.test);
159        if !self.production_excluded.is_empty() {
160            let seeded: FxHashSet<&Path> = self.all.iter().map(|ep| ep.path.as_path()).collect();
161            self.production_excluded
162                .retain(|path| !seeded.contains(path.as_path()));
163            self.production_excluded.sort_unstable();
164            self.production_excluded.dedup();
165        }
166        self
167    }
168
169    /// Files that production mode leaves out of the analysis. See
170    /// [`Self::production_excluded`].
171    #[must_use]
172    pub fn production_excluded(&self) -> &[PathBuf] {
173        &self.production_excluded
174    }
175}
176
177fn dedup_entry_paths(entries: &mut Vec<EntryPoint>) {
178    entries.sort_by(|a, b| a.path.cmp(&b.path));
179    entries.dedup_by(|a, b| a.path == b.path);
180}
181
182#[derive(Debug, Default)]
183pub struct EntryPointDiscovery {
184    /// Runtime entry points declared by package metadata or inferred defaults.
185    pub entries: Vec<EntryPoint>,
186    /// Tooling entry points referenced only from non-runtime package scripts.
187    pub support_entries: Vec<EntryPoint>,
188    pub skipped_entries: FxHashMap<String, usize>,
189    /// Runtime entry paths from a source other than `entry`, before the dedup.
190    pub non_manual_runtime_paths: FxHashSet<PathBuf>,
191    /// Production mode only: files that a `supportEntry` glob matches. They
192    /// are not entry points; see [`CategorizedEntryPoints::production_excluded`].
193    pub production_excluded: Vec<PathBuf>,
194}
195
196impl EntryPointDiscovery {
197    fn into_all_entries(mut self) -> Vec<EntryPoint> {
198        self.entries.append(&mut self.support_entries);
199        dedup_entry_paths(&mut self.entries);
200        self.entries
201    }
202}
203
204/// Resolve a path relative to a base directory, with security check and extension fallback.
205///
206/// Returns `Some(EntryPoint)` if the path resolves to an existing file within `canonical_root`,
207/// trying source extensions as fallback when the exact path doesn't exist.
208/// Also handles exports map targets in output directories (e.g., `./dist/utils.js`)
209/// by trying to map back to the source file (e.g., `./src/utils.ts`).
210pub fn resolve_entry_path_with_tracking(
211    base: &Path,
212    entry: &str,
213    canonical_root: &Path,
214    source: EntryPointSource,
215    skipped_entries: Option<&mut FxHashMap<String, usize>>,
216    discovered: Option<IsDiscovered<'_>>,
217) -> Option<EntryPoint> {
218    let output_map = TsconfigOutputMap::from_project(base);
219    resolve_entry_path_with_output_map(
220        base,
221        entry,
222        canonical_root,
223        source,
224        skipped_entries,
225        EntryTargets {
226            output_map: &output_map,
227            discovered,
228        },
229    )
230}
231
232/// Return `true` when a path is part of the analyzed files. A `lib/` package
233/// entry whose file is on disk but not analyzed maps to `src/`.
234pub type IsDiscovered<'a> = &'a (dyn Fn(&Path) -> bool + Sync);
235
236/// The discovered files that a package entry must belong to.
237///
238/// A `lib/` entry whose file is on disk but outside this set (because of
239/// `.gitignore` or `ignorePatterns`) maps to `src/`, the same as a missing
240/// `lib/` entry. The path set is built on first use, so a project without
241/// such an entry does not pay for it.
242pub struct DiscoveredPaths<'a> {
243    files: &'a [DiscoveredFile],
244    /// Indexes into `files`, sorted by path. The index holds no borrow, so
245    /// `DiscoveredPaths` stays covariant in `'a`.
246    by_path: std::sync::OnceLock<Vec<usize>>,
247}
248
249impl<'a> DiscoveredPaths<'a> {
250    /// Wrap the discovered files of a project.
251    #[must_use]
252    pub const fn new(files: &'a [DiscoveredFile]) -> Self {
253        Self {
254            files,
255            by_path: std::sync::OnceLock::new(),
256        }
257    }
258
259    /// Return `true` when `path` is a discovered file. The lookup matches
260    /// the graph entry lookup: the path as given, then its canonical form.
261    #[must_use]
262    pub fn contains(&self, path: &Path) -> bool {
263        let by_path = self.by_path.get_or_init(|| {
264            let mut indexes: Vec<usize> = (0..self.files.len()).collect();
265            indexes.sort_unstable_by(|a, b| self.files[*a].path.cmp(&self.files[*b].path));
266            indexes
267        });
268        let has = |candidate: &Path| {
269            by_path
270                .binary_search_by(|index| self.files[*index].path.as_path().cmp(candidate))
271                .is_ok()
272        };
273        has(path) || dunce::canonicalize(path).is_ok_and(|canonical| has(&canonical))
274    }
275}
276
277/// What a package entry resolves against: the tsconfig output map of the
278/// package and, when known, the discovered files of the project.
279#[derive(Clone, Copy)]
280pub(super) struct EntryTargets<'a> {
281    pub(super) output_map: &'a TsconfigOutputMap,
282    /// `None` keeps the disk check: a `lib/` file on disk stays the entry.
283    pub(super) discovered: Option<IsDiscovered<'a>>,
284}
285
286fn resolve_entry_path_with_output_map(
287    base: &Path,
288    entry: &str,
289    canonical_root: &Path,
290    source: EntryPointSource,
291    mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
292    targets: EntryTargets<'_>,
293) -> Option<EntryPoint> {
294    if entry.contains('*') {
295        return None;
296    }
297
298    if entry_has_parent_dir(entry) {
299        record_or_warn_skipped_entry(
300            skipped_entries.as_deref_mut(),
301            entry,
302            "Skipping entry point containing parent directory traversal",
303        );
304        return None;
305    }
306
307    if let OutputDirEntry::ShortCircuit(result) = resolve_entry_via_output_dir(
308        base,
309        entry,
310        canonical_root,
311        source.clone(),
312        skipped_entries.as_deref_mut(),
313        targets,
314    ) {
315        return result;
316    }
317
318    resolve_entry_via_filesystem_probe(base, entry, canonical_root, source, skipped_entries)
319}
320
321/// Record a skipped entry in the dedup map, or warn when no map is tracking skips.
322fn record_or_warn_skipped_entry(
323    skipped_entries: Option<&mut FxHashMap<String, usize>>,
324    entry: &str,
325    warning: &str,
326) {
327    if let Some(skipped_entries) = skipped_entries {
328        *skipped_entries.entry(entry.to_owned()).or_default() += 1;
329    } else {
330        tracing::warn!(path = %entry, "{warning}");
331    }
332}
333
334/// Outcome of the output-directory mapping step.
335///
336/// `ShortCircuit` means an output-dir branch applied and carries the resolved
337/// entry (which may itself be `None` when validation rejected the candidate);
338/// `Continue` signals that filesystem probing should proceed.
339pub(super) enum OutputDirEntry {
340    ShortCircuit(Option<EntryPoint>),
341    Continue,
342}
343
344/// Map an output-directory entry back to a source file, short-circuiting resolution.
345pub(super) fn resolve_entry_via_output_dir(
346    base: &Path,
347    entry: &str,
348    canonical_root: &Path,
349    source: EntryPointSource,
350    mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
351    targets: EntryTargets<'_>,
352) -> OutputDirEntry {
353    let resolution = targets
354        .output_map
355        .resolve_source_for_entry(entry, SOURCE_EXTENSIONS);
356    match &resolution {
357        TsconfigOutputResolution::Resolved(source_path) => {
358            return OutputDirEntry::ShortCircuit(validated_entry_point(
359                source_path,
360                canonical_root,
361                entry,
362                source,
363                skipped_entries.as_deref_mut(),
364            ));
365        }
366        TsconfigOutputResolution::ConfiguredButUnresolved => return OutputDirEntry::Continue,
367        TsconfigOutputResolution::ConfiguredWithoutSource
368        | TsconfigOutputResolution::Unconfigured => {}
369    }
370
371    let is_discovered = |path: &Path| {
372        targets
373            .discovered
374            .is_none_or(|is_discovered| is_discovered(path))
375    };
376    if matches!(
377        resolution,
378        TsconfigOutputResolution::ConfiguredWithoutSource
379    ) {
380        // The tsconfig claims the output but names no file, so a bundler can
381        // own it. Only an analyzed source file under `src/` counts.
382        return match output_entry_to_source_path(base, entry, SOURCE_EXTENSIONS, is_discovered)
383            .filter(|source_path| is_discovered(source_path))
384        {
385            Some(source_path) => OutputDirEntry::ShortCircuit(validated_entry_point(
386                &source_path,
387                canonical_root,
388                entry,
389                source,
390                skipped_entries,
391            )),
392            None => OutputDirEntry::Continue,
393        };
394    }
395    if let Some(source_path) =
396        output_entry_to_source_path(base, entry, SOURCE_EXTENSIONS, is_discovered)
397    {
398        return OutputDirEntry::ShortCircuit(validated_entry_point(
399            &source_path,
400            canonical_root,
401            entry,
402            source,
403            skipped_entries.as_deref_mut(),
404        ));
405    }
406
407    if is_entry_in_output_dir(entry)
408        && let Some(source_path) = try_source_index_fallback(base)
409    {
410        tracing::info!(
411            entry = %entry,
412            fallback = %source_path.display(),
413            "package.json entry resolves to an ignored output directory; falling back to source index"
414        );
415        return OutputDirEntry::ShortCircuit(validated_entry_point(
416            &source_path,
417            canonical_root,
418            entry,
419            source,
420            skipped_entries,
421        ));
422    }
423
424    OutputDirEntry::Continue
425}
426
427/// Probe the filesystem for the entry: exact file, extension fallback, directory
428/// index, then a package-root source-index fallback.
429fn resolve_entry_via_filesystem_probe(
430    base: &Path,
431    entry: &str,
432    canonical_root: &Path,
433    source: EntryPointSource,
434    mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
435) -> Option<EntryPoint> {
436    let resolved = base.join(entry);
437
438    if resolved.is_file() {
439        return validated_entry_point(
440            &resolved,
441            canonical_root,
442            entry,
443            source,
444            skipped_entries.as_deref_mut(),
445        );
446    }
447
448    for ext in SOURCE_EXTENSIONS {
449        let with_ext = resolved.with_extension(ext);
450        if with_ext.is_file() {
451            return validated_entry_point(
452                &with_ext,
453                canonical_root,
454                entry,
455                source,
456                skipped_entries.as_deref_mut(),
457            );
458        }
459    }
460
461    if let Some(index_entry) = directory_index_entry(&resolved, SOURCE_EXTENSIONS) {
462        return validated_entry_point(
463            &index_entry,
464            canonical_root,
465            entry,
466            source,
467            skipped_entries.as_deref_mut(),
468        );
469    }
470
471    if is_package_root_index_entry(entry)
472        && let Some(source_path) = try_source_index_fallback(base)
473    {
474        tracing::info!(
475            entry = %entry,
476            fallback = %source_path.display(),
477            "package.json root index entry is missing; falling back to source index"
478        );
479        return validated_entry_point(&source_path, canonical_root, entry, source, skipped_entries);
480    }
481    None
482}
483
484pub(super) fn entry_has_parent_dir(entry: &str) -> bool {
485    Path::new(entry)
486        .components()
487        .any(|component| matches!(component, Component::ParentDir))
488}
489
490fn is_package_root_index_entry(entry: &str) -> bool {
491    let mut components = Path::new(entry)
492        .components()
493        .filter(|component| !matches!(component, Component::CurDir));
494
495    let Some(Component::Normal(file_name)) = components.next() else {
496        return false;
497    };
498    if components.next().is_some() {
499        return false;
500    }
501
502    file_name
503        .to_str()
504        .is_some_and(|name| name == "index" || name.starts_with("index."))
505}
506
507fn validated_entry_point(
508    candidate: &Path,
509    canonical_root: &Path,
510    entry: &str,
511    source: EntryPointSource,
512    mut skipped_entries: Option<&mut FxHashMap<String, usize>>,
513) -> Option<EntryPoint> {
514    let canonical_candidate = match dunce::canonicalize(candidate) {
515        Ok(path) => path,
516        Err(err) => {
517            tracing::warn!(
518                path = %candidate.display(),
519                %entry,
520                error = %err,
521                "Skipping entry point that could not be canonicalized"
522            );
523            return None;
524        }
525    };
526
527    if !canonical_candidate.starts_with(canonical_root) {
528        if let Some(skipped_entries) = skipped_entries.as_mut() {
529            *skipped_entries.entry(entry.to_owned()).or_default() += 1;
530        } else {
531            tracing::warn!(
532                path = %candidate.display(),
533                %entry,
534                "Skipping entry point outside project root"
535            );
536        }
537        return None;
538    }
539
540    // `base.join("./index.js")` keeps the `./` segment. The graph and the
541    // reports match entry paths with discovered file paths, which have none.
542    Some(EntryPoint {
543        path: lexical_normalize(candidate),
544        source,
545    })
546}
547
548/// Resolve a package entry path with the disk check: a `lib/` file on disk
549/// stays the entry, also when the analysis does not include it.
550///
551/// Use [`resolve_entry_path_with_discovered`] when the analyzed files are
552/// known.
553pub fn resolve_entry_path(
554    base: &Path,
555    entry: &str,
556    canonical_root: &Path,
557    source: EntryPointSource,
558) -> Option<EntryPoint> {
559    resolve_entry_path_with_tracking(base, entry, canonical_root, source, None, None)
560}
561
562/// Resolve a package entry path against the analyzed files.
563///
564/// A `lib/` file on disk that `is_discovered` rejects counts as absent, so
565/// the entry maps to the same-stem file under `src/`.
566pub fn resolve_entry_path_with_discovered(
567    base: &Path,
568    entry: &str,
569    canonical_root: &Path,
570    source: EntryPointSource,
571    is_discovered: IsDiscovered<'_>,
572) -> Option<EntryPoint> {
573    resolve_entry_path_with_tracking(
574        base,
575        entry,
576        canonical_root,
577        source,
578        None,
579        Some(is_discovered),
580    )
581}
582/// Conventional source index file stems probed when a package.json entry lives
583/// in an ignored output directory. Ordered by preference.
584const SOURCE_INDEX_FALLBACK_STEMS: &[&str] = &["src/index", "src/main", "index", "main"];
585
586/// Return `true` when `entry` contains a known output directory component.
587///
588/// Matches any segment in `OUTPUT_DIRS`, e.g. `./dist/esm2022/index.js` →
589/// `true`, `src/main.ts` → `false`.
590fn is_entry_in_output_dir(entry: &str) -> bool {
591    Path::new(entry).components().any(|c| {
592        matches!(
593            c,
594            std::path::Component::Normal(s)
595                if s.to_str().is_some_and(|name| OUTPUT_DIRS.contains(&name))
596        )
597    })
598}
599
600/// Probe a package root for a conventional source index file.
601///
602/// Used when `package.json` points at compiled output but the canonical source
603/// entry is a standard TypeScript/JavaScript index file. Tries `src/index`,
604/// `src/main`, `index`, and `main` with each supported source extension, in
605/// that order.
606fn try_source_index_fallback(base: &Path) -> Option<PathBuf> {
607    for stem in SOURCE_INDEX_FALLBACK_STEMS {
608        for ext in SOURCE_EXTENSIONS {
609            let candidate = base.join(format!("{stem}.{ext}"));
610            if candidate.is_file() {
611                return Some(candidate);
612            }
613        }
614    }
615    None
616}
617
618/// Default index patterns used when no other entry points are found.
619const DEFAULT_INDEX_PATTERNS: &[&str] = &[
620    "src/index.{ts,tsx,js,jsx}",
621    "src/main.{ts,tsx,js,jsx}",
622    "index.{ts,tsx,js,jsx}",
623    "main.{ts,tsx,js,jsx}",
624];
625
626/// Process-wide matcher for the compile-time default index patterns.
627fn default_index_matchers() -> &'static globset::GlobSet {
628    static MATCHERS: std::sync::OnceLock<globset::GlobSet> = std::sync::OnceLock::new();
629    MATCHERS.get_or_init(|| {
630        let mut builder = globset::GlobSetBuilder::new();
631        for pattern in DEFAULT_INDEX_PATTERNS {
632            if let Ok(glob) = globset::Glob::new(pattern) {
633                builder.add(glob);
634            }
635        }
636        builder.build().unwrap_or_default()
637    })
638}
639
640/// Fall back to default index patterns if no entries were found.
641///
642/// When `ws_filter` is `Some`, only files whose path starts with the given
643/// workspace root are considered (used for workspace-scoped discovery).
644fn apply_default_fallback(
645    files: &[DiscoveredFile],
646    root: &Path,
647    ws_filter: Option<&Path>,
648) -> Vec<EntryPoint> {
649    let default_matchers = default_index_matchers();
650
651    let mut entries = Vec::new();
652    for file in files {
653        if let Some(ws_root) = ws_filter
654            && file.path.strip_prefix(ws_root).is_err()
655        {
656            continue;
657        }
658        let relative = file.path.strip_prefix(root).unwrap_or(&file.path);
659        let relative_str = relative.to_string_lossy();
660        if default_matchers.is_match(relative_str.as_ref()) {
661            entries.push(EntryPoint {
662                path: file.path.clone(),
663                source: EntryPointSource::DefaultIndex,
664            });
665        }
666    }
667    entries
668}
669
670/// Compute each file's path relative to `root` as a forward-slash-lossy string.
671pub(super) fn relative_paths_for(files: &[DiscoveredFile], root: &Path) -> Vec<String> {
672    files
673        .iter()
674        .map(|f| {
675            f.path
676                .strip_prefix(root)
677                .unwrap_or(&f.path)
678                .to_string_lossy()
679                .into_owned()
680        })
681        .collect()
682}
683
684/// Push entries derived from a package.json's declared entry points and scripts.
685fn push_package_json_entries(
686    discovery: &mut EntryPointDiscovery,
687    root: &Path,
688    pkg: &PackageJson,
689    canonical_root: &Path,
690    ignored: IgnoredCommandEntries<'_>,
691    workspaces: ScriptWorkspaces<'_>,
692) {
693    let output_map = TsconfigOutputMap::from_project(root);
694    for entry_path in pkg.entry_points() {
695        if let Some(ep) = resolve_entry_path_with_output_map(
696            root,
697            &entry_path,
698            canonical_root,
699            EntryPointSource::PackageJsonMain,
700            Some(&mut discovery.skipped_entries),
701            EntryTargets {
702                output_map: &output_map,
703                discovered: workspaces.discovered,
704            },
705        ) {
706            discovery.entries.push(ep);
707        }
708    }
709
710    let Some(scripts) = &pkg.scripts else {
711        return;
712    };
713    let package = ScriptPackage {
714        root,
715        canonical_root,
716        output_map: &output_map,
717        workspaces,
718    };
719    push_script_entries(
720        &package,
721        scripts,
722        ignored,
723        &mut PackageEntryBuckets {
724            runtime: &mut discovery.entries,
725            support: &mut discovery.support_entries,
726        },
727        &mut discovery.skipped_entries,
728    );
729}
730
731/// The workspace packages that a script command selects by name, by
732/// directory, or all of them (`yarn workspace web node scripts/a.ts`,
733/// `pnpm -r exec tsx scripts/a.ts`), and the project root that a file
734/// outside the calling package resolves against. Also the discovered files
735/// that the package entries of every package resolve against.
736#[derive(Clone, Copy)]
737pub struct ScriptWorkspaces<'a> {
738    /// The workspace packages of the project, the root package included.
739    pub packages: &'a std::sync::Arc<WorkspacePackages>,
740    /// The project root.
741    pub project_root: &'a Path,
742    /// The scripts of each package, by package directory, that a runtime
743    /// script of another package calls ([`workspace_runtime_script_seeds`]).
744    pub runtime_seeds: &'a RuntimeScriptSeeds,
745    /// Return `true` for a file of the analyzed file set. `None` keeps the
746    /// disk check for `lib/` entries.
747    ///
748    /// The predicate must cover the full analyzed file set of the project:
749    /// the same set that the graph later matches entries against. Workspace
750    /// scope and `--changed-since` filter findings after the analysis, so
751    /// they do not narrow this set.
752    pub discovered: Option<IsDiscovered<'a>>,
753}
754
755/// The scripts of each package, by package directory relative to the
756/// project root (empty for the root package), that a runtime script of
757/// another package calls.
758pub type RuntimeScriptSeeds = FxHashMap<String, FxHashSet<String>>;
759
760/// The package whose scripts add entry points.
761struct ScriptPackage<'a> {
762    root: &'a Path,
763    canonical_root: &'a Path,
764    output_map: &'a TsconfigOutputMap,
765    workspaces: ScriptWorkspaces<'a>,
766}
767
768impl ScriptPackage<'_> {
769    /// The directory of the package relative to the project root, with `/`
770    /// separators. `None` for a package outside the project root.
771    fn dir(&self) -> Option<String> {
772        self.root
773            .strip_prefix(self.workspaces.project_root)
774            .ok()
775            .map(|dir| dir.to_string_lossy().replace('\\', "/"))
776    }
777
778    /// Resolve a file reference of the script `script` of the package. A
779    /// reference outside the package, such as `../web/scripts/a.ts` from
780    /// `yarn workspace web node scripts/a.ts`, resolves from the project
781    /// root.
782    fn resolve(
783        &self,
784        file_ref: &str,
785        script: &str,
786        dir: Option<&str>,
787        skipped_entries: &mut FxHashMap<String, usize>,
788    ) -> Option<EntryPoint> {
789        if entry_has_parent_dir(file_ref)
790            && let Some(project_ref) =
791                dir.and_then(|dir| crate::scripts::normalize_script_entry_pattern(dir, file_ref))
792        {
793            let project_root = self.workspaces.project_root;
794            let canonical_project_root =
795                dunce::canonicalize(project_root).unwrap_or_else(|_| project_root.to_path_buf());
796            return resolve_entry_path_with_tracking(
797                project_root,
798                &project_ref,
799                &canonical_project_root,
800                EntryPointSource::package_json_script(script),
801                Some(skipped_entries),
802                self.workspaces.discovered,
803            );
804        }
805        resolve_entry_path_with_output_map(
806            self.root,
807            file_ref,
808            self.canonical_root,
809            EntryPointSource::package_json_script(script),
810            Some(skipped_entries),
811            EntryTargets {
812                output_map: self.output_map,
813                discovered: self.workspaces.discovered,
814            },
815        )
816    }
817}
818
819/// Push the entries that the scripts of `package` reference. A file that a
820/// runtime script runs is a runtime entry: the `start` lifecycle, and the
821/// scripts that a runtime script of another package calls. Other script
822/// files and every config file are support entries.
823#[expect(
824    clippy::disallowed_types,
825    reason = "API matches serde-deserialized package.json scripts map"
826)]
827fn push_script_entries(
828    package: &ScriptPackage<'_>,
829    scripts: &std::collections::HashMap<String, String>,
830    ignored: IgnoredCommandEntries<'_>,
831    entries: &mut PackageEntryBuckets<'_>,
832    skipped_entries: &mut FxHashMap<String, usize>,
833) {
834    let dir_buf = package.dir();
835    let dir = dir_buf.as_deref();
836    let no_seeds = FxHashSet::default();
837    let seeds = dir
838        .and_then(|dir| package.workspaces.runtime_seeds.get(dir))
839        .unwrap_or(&no_seeds);
840    let runtime_scripts = runtime_package_script_names_with_seeds(scripts, seeds);
841    let catalog = ScriptCatalog::from_scripts(scripts).with_workspaces(
842        std::sync::Arc::clone(package.workspaces.packages),
843        dir.unwrap_or_default(),
844    );
845    // Key order: the entry dedup keeps the first script that runs a file.
846    let sorted: std::collections::BTreeMap<_, _> = scripts.iter().collect();
847    for (script_name, script_value) in sorted {
848        let refs = package_script_refs(script_value, &catalog, ignored);
849        for file_ref in refs.inheritable {
850            if let Some(ep) = package.resolve(&file_ref, script_name, dir, skipped_entries) {
851                if runtime_scripts.contains(script_name) {
852                    entries.runtime.push(ep);
853                } else {
854                    entries.support.push(ep);
855                }
856            }
857        }
858        for config_ref in refs.support {
859            if let Some(ep) = package.resolve(&config_ref, script_name, dir, skipped_entries) {
860                entries.support.push(ep);
861            }
862        }
863    }
864}
865
866struct PackageScriptRefs {
867    inheritable: Vec<String>,
868    support: Vec<String>,
869}
870
871/// Collect the file references of one script. `catalog` holds the scripts of
872/// the same package, so a call such as `npm run lint -- src/a.ts` resolves to
873/// the command that the package manager runs.
874fn package_script_refs(
875    script: &str,
876    catalog: &ScriptCatalog,
877    ignored: IgnoredCommandEntries<'_>,
878) -> PackageScriptRefs {
879    let mut inheritable = Vec::new();
880    let mut support = Vec::new();
881    for command in crate::scripts::parse_script_with_catalog(script, catalog) {
882        inheritable.extend_from_slice(command.entry_files(ignored));
883        support.extend(command.config_args);
884    }
885    inheritable.extend(super::parse_scripts::extract_script_file_refs(
886        script,
887        super::parse_scripts::CommandRefContext {
888            ignored,
889            scripts: catalog,
890        },
891    ));
892    support.sort_unstable();
893    support.dedup();
894    inheritable.retain(|path| support.binary_search(path).is_err());
895    inheritable.sort_unstable();
896    inheritable.dedup();
897    PackageScriptRefs {
898        inheritable,
899        support,
900    }
901}
902
903/// npm's start lifecycle is a production execution surface. Other package
904/// scripts are conservatively treated as tooling: their files stay reachable,
905/// but do not prove that a devDependency ships with the application.
906#[expect(
907    clippy::disallowed_types,
908    reason = "API matches serde-deserialized package.json scripts map"
909)]
910fn runtime_package_script_names(
911    scripts: &std::collections::HashMap<String, String>,
912) -> FxHashSet<String> {
913    runtime_package_script_names_with_seeds(scripts, &FxHashSet::default())
914}
915
916#[expect(
917    clippy::disallowed_types,
918    reason = "API matches serde-deserialized package.json scripts map"
919)]
920fn runtime_package_script_names_with_seeds(
921    scripts: &std::collections::HashMap<String, String>,
922    seeds: &FxHashSet<String>,
923) -> FxHashSet<String> {
924    let catalog = ScriptCatalog::from_scripts(scripts);
925    let mut runtime = FxHashSet::default();
926    let mut pending = Vec::new();
927
928    enqueue_runtime_script("start", scripts, &mut runtime, &mut pending);
929    for seed in seeds {
930        enqueue_runtime_script(seed, scripts, &mut runtime, &mut pending);
931    }
932
933    while let Some(name) = pending.pop() {
934        let Some(body) = scripts.get(&name) else {
935            continue;
936        };
937        for referenced in crate::scripts::referenced_package_scripts(body, &catalog) {
938            enqueue_runtime_script(&referenced, scripts, &mut runtime, &mut pending);
939        }
940    }
941
942    runtime
943}
944
945/// The workspace packages of a project for script analysis: the root
946/// package and every workspace package, with their directories relative to
947/// `project_root` and their scripts.
948pub fn collect_workspace_packages(
949    project_root: &Path,
950    root_pkg: Option<&PackageJson>,
951    workspace_pkgs: &[(fallow_config::WorkspaceInfo, PackageJson)],
952) -> std::sync::Arc<WorkspacePackages> {
953    let mut packages = WorkspacePackages::default();
954    if let Some(pkg) = root_pkg {
955        packages.add_root(
956            pkg.name.as_deref().unwrap_or_default(),
957            pkg.scripts.as_ref(),
958        );
959    }
960    for (ws, ws_pkg) in workspace_pkgs {
961        let dir = ws
962            .root
963            .strip_prefix(project_root)
964            .unwrap_or(&ws.root)
965            .to_string_lossy()
966            .replace('\\', "/");
967        packages.add(&ws.name, &dir, ws_pkg.scripts.as_ref());
968    }
969    std::sync::Arc::new(packages.with_project_root(project_root))
970}
971
972/// The scripts of each package that a runtime script of another package
973/// calls, such as `serve` for a root `start` script
974/// `pnpm --filter api run serve`, `pnpm -r run serve`, or
975/// `pnpm -C packages/api run serve`. The calls are followed transitively.
976pub fn workspace_runtime_script_seeds(
977    packages: &std::sync::Arc<WorkspacePackages>,
978) -> RuntimeScriptSeeds {
979    let mut seeds = RuntimeScriptSeeds::default();
980    let mut pending: Vec<(String, String)> = packages
981        .iter()
982        .flat_map(|package| {
983            runtime_package_script_names(package.scripts())
984                .into_iter()
985                .map(|name| (package.dir().to_string(), name))
986        })
987        .collect();
988
989    let mut visited = FxHashSet::default();
990    while let Some((dir, name)) = pending.pop() {
991        if !visited.insert((dir.clone(), name.clone())) {
992            continue;
993        }
994        let Some(package) = packages.find_dir(&dir) else {
995            continue;
996        };
997        let Some(body) = package.scripts().get(&name) else {
998            continue;
999        };
1000        let catalog = ScriptCatalog::from_scripts(package.scripts())
1001            .with_workspaces(std::sync::Arc::clone(packages), &dir);
1002        for (target_dir, script) in crate::scripts::referenced_workspace_scripts(body, &catalog) {
1003            let Some(target) = packages.find_dir(&target_dir) else {
1004                continue;
1005            };
1006            let target_seeds = FxHashSet::from_iter([script]);
1007            for runtime_name in
1008                runtime_package_script_names_with_seeds(target.scripts(), &target_seeds)
1009            {
1010                if seeds
1011                    .entry(target_dir.clone())
1012                    .or_default()
1013                    .insert(runtime_name.clone())
1014                {
1015                    pending.push((target_dir.clone(), runtime_name));
1016                }
1017            }
1018        }
1019    }
1020    seeds
1021}
1022
1023#[expect(
1024    clippy::disallowed_types,
1025    reason = "API matches serde-deserialized package.json scripts map"
1026)]
1027fn enqueue_runtime_script(
1028    name: &str,
1029    scripts: &std::collections::HashMap<String, String>,
1030    runtime: &mut FxHashSet<String>,
1031    pending: &mut Vec<String>,
1032) {
1033    for candidate in [
1034        format!("pre{name}"),
1035        name.to_string(),
1036        format!("post{name}"),
1037    ] {
1038        if scripts.contains_key(&candidate) && runtime.insert(candidate.clone()) {
1039            pending.push(candidate);
1040        }
1041    }
1042}
1043
1044/// Discover the entry points of the root package: manual entries,
1045/// package.json fields and scripts, nested packages when
1046/// `include_nested_package_entries` is set, and the default fallback.
1047pub fn discover_root_entry_points(
1048    config: &ResolvedConfig,
1049    files: &[DiscoveredFile],
1050    root_pkg: Option<&PackageJson>,
1051    include_nested_package_entries: bool,
1052    workspaces: ScriptWorkspaces<'_>,
1053) -> EntryPointDiscovery {
1054    let _span = tracing::info_span!("discover_entry_points").entered();
1055    let mut discovery = EntryPointDiscovery::default();
1056
1057    let relative_paths = relative_paths_for(files, &config.root);
1058    push_manual_entry_matches(&mut discovery.entries, config, &relative_paths, files);
1059    push_support_entry_matches(&mut discovery, config, &relative_paths, files);
1060
1061    let canonical_root = dunce::canonicalize(&config.root).unwrap_or_else(|_| config.root.clone());
1062    if let Some(pkg) = root_pkg {
1063        push_package_json_entries(
1064            &mut discovery,
1065            &config.root,
1066            pkg,
1067            &canonical_root,
1068            IgnoredCommandEntries::new(&config.ignore_command_entries),
1069            workspaces,
1070        );
1071        for entry_path in pkg.entry_points() {
1072            if entry_path.contains('*') {
1073                expand_wildcard_entries(&config.root, &entry_path, files, &mut discovery.entries);
1074            }
1075        }
1076    }
1077
1078    if include_nested_package_entries {
1079        let exports_dirs = root_pkg
1080            .map(PackageJson::exports_subdirectories)
1081            .unwrap_or_default();
1082        let mut nested_entries = PackageEntryBuckets {
1083            runtime: &mut discovery.entries,
1084            support: &mut discovery.support_entries,
1085        };
1086        discover_nested_package_entries(
1087            &mut nested_entries,
1088            &NestedPackageSearch {
1089                canonical_root: &canonical_root,
1090                files,
1091                exports_subdirectories: &exports_dirs,
1092                ignored: IgnoredCommandEntries::new(&config.ignore_command_entries),
1093                workspaces,
1094            },
1095            &mut discovery.skipped_entries,
1096        );
1097    }
1098
1099    if discovery.entries.is_empty() {
1100        discovery.entries = apply_default_fallback(files, &config.root, None);
1101    }
1102
1103    discovery.non_manual_runtime_paths = super::entry_report::non_manual_paths(&discovery.entries);
1104    dedup_entry_paths(&mut discovery.entries);
1105    dedup_entry_paths(&mut discovery.support_entries);
1106
1107    discovery
1108}
1109
1110/// Discover the entry points of every package of a project: the root
1111/// package and each workspace package in `workspaces`, without plugin
1112/// entries. The script entries resolve package selections against the same
1113/// workspace packages and runtime script seeds as the analysis, so this
1114/// returns the package entries that the analysis finds.
1115#[must_use]
1116pub fn discover_entry_points(
1117    config: &ResolvedConfig,
1118    files: &[DiscoveredFile],
1119    workspaces: &[fallow_config::WorkspaceInfo],
1120) -> Vec<EntryPoint> {
1121    use rayon::prelude::*;
1122
1123    let root_pkg = fallow_config::load_dir_package_json(&config.root);
1124    let workspace_pkgs: Vec<(fallow_config::WorkspaceInfo, PackageJson)> = workspaces
1125        .iter()
1126        .filter_map(|ws| {
1127            fallow_config::load_dir_package_json(&ws.root).map(|pkg| (ws.clone(), pkg))
1128        })
1129        .collect();
1130    let packages = collect_workspace_packages(&config.root, root_pkg.as_ref(), &workspace_pkgs);
1131    let runtime_seeds = workspace_runtime_script_seeds(&packages);
1132    let discovered = DiscoveredPaths::new(files);
1133    let is_discovered = |path: &Path| discovered.contains(path);
1134    let script_workspaces = ScriptWorkspaces {
1135        packages: &packages,
1136        project_root: &config.root,
1137        runtime_seeds: &runtime_seeds,
1138        discovered: Some(&is_discovered),
1139    };
1140    let mut discovery = discover_root_entry_points(
1141        config,
1142        files,
1143        root_pkg.as_ref(),
1144        workspaces.is_empty(),
1145        script_workspaces,
1146    );
1147    let pkg_by_root: FxHashMap<&Path, &PackageJson> = workspace_pkgs
1148        .iter()
1149        .map(|(ws, pkg)| (ws.root.as_path(), pkg))
1150        .collect();
1151    let workspace_discovery: Vec<EntryPointDiscovery> = workspaces
1152        .par_iter()
1153        .map(|ws| {
1154            discover_workspace_package_entry_points(
1155                &ws.root,
1156                files,
1157                pkg_by_root.get(ws.root.as_path()).copied(),
1158                IgnoredCommandEntries::new(&config.ignore_command_entries),
1159                script_workspaces,
1160            )
1161        })
1162        .collect();
1163    for workspace in workspace_discovery {
1164        discovery.entries.extend(workspace.entries);
1165        discovery.support_entries.extend(workspace.support_entries);
1166        for (path, count) in workspace.skipped_entries {
1167            *discovery.skipped_entries.entry(path).or_insert(0) += count;
1168        }
1169    }
1170    warn_skipped_entry_summary(&discovery.skipped_entries);
1171    discovery.into_all_entries()
1172}
1173
1174/// Discover entry points from nested package.json files in subdirectories.
1175///
1176/// Scans two sources for sub-packages:
1177/// 1. Common monorepo directory patterns (`packages/`, `apps/`, `libs/`, etc.)
1178/// 2. Directories derived from the root package.json `exports` map keys
1179///    (e.g., `"./compat": {...}` implies `compat/` may be a sub-package)
1180///
1181/// For each discovered sub-package with a `package.json`, the `main`, `module`,
1182/// `source`, `exports`, and `bin` fields are treated as entry points.
1183struct PackageEntryBuckets<'a> {
1184    runtime: &'a mut Vec<EntryPoint>,
1185    support: &'a mut Vec<EntryPoint>,
1186}
1187
1188/// The inputs of the nested package search that every package shares.
1189struct NestedPackageSearch<'a> {
1190    canonical_root: &'a Path,
1191    files: &'a [DiscoveredFile],
1192    exports_subdirectories: &'a [String],
1193    ignored: IgnoredCommandEntries<'a>,
1194    workspaces: ScriptWorkspaces<'a>,
1195}
1196
1197fn discover_nested_package_entries(
1198    entries: &mut PackageEntryBuckets<'_>,
1199    search: &NestedPackageSearch<'_>,
1200    skipped_entries: &mut FxHashMap<String, usize>,
1201) {
1202    let root = search.workspaces.project_root;
1203    let mut visited = rustc_hash::FxHashSet::default();
1204
1205    let search_dirs = [
1206        "packages", "apps", "libs", "modules", "plugins", "services", "tools", "utils",
1207    ];
1208    for dir_name in &search_dirs {
1209        let search_dir = root.join(dir_name);
1210        if !search_dir.is_dir() {
1211            continue;
1212        }
1213        let Ok(read_dir) = std::fs::read_dir(&search_dir) else {
1214            continue;
1215        };
1216        for entry in read_dir.flatten() {
1217            let pkg_dir = entry.path();
1218            if visited.insert(pkg_dir.clone()) {
1219                collect_nested_package_entries(&pkg_dir, entries, search, skipped_entries);
1220            }
1221        }
1222    }
1223
1224    for dir_name in search.exports_subdirectories {
1225        let pkg_dir = root.join(dir_name);
1226        if pkg_dir.is_dir() && visited.insert(pkg_dir.clone()) {
1227            collect_nested_package_entries(&pkg_dir, entries, search, skipped_entries);
1228        }
1229    }
1230}
1231
1232/// Collect entry points from a single sub-package directory.
1233fn collect_nested_package_entries(
1234    pkg_dir: &Path,
1235    entries: &mut PackageEntryBuckets<'_>,
1236    search: &NestedPackageSearch<'_>,
1237    skipped_entries: &mut FxHashMap<String, usize>,
1238) {
1239    let Some(pkg) = fallow_config::load_dir_package_json(pkg_dir) else {
1240        return;
1241    };
1242    let output_map = TsconfigOutputMap::from_project(pkg_dir);
1243    for entry_path in pkg.entry_points() {
1244        if entry_path.contains('*') {
1245            expand_wildcard_entries(pkg_dir, &entry_path, search.files, entries.runtime);
1246        } else if let Some(ep) = resolve_entry_path_with_output_map(
1247            pkg_dir,
1248            &entry_path,
1249            search.canonical_root,
1250            EntryPointSource::PackageJsonExports,
1251            Some(&mut *skipped_entries),
1252            EntryTargets {
1253                output_map: &output_map,
1254                discovered: search.workspaces.discovered,
1255            },
1256        ) {
1257            entries.runtime.push(ep);
1258        }
1259    }
1260    if let Some(scripts) = &pkg.scripts {
1261        let package = ScriptPackage {
1262            root: pkg_dir,
1263            canonical_root: search.canonical_root,
1264            output_map: &output_map,
1265            workspaces: search.workspaces,
1266        };
1267        push_script_entries(&package, scripts, search.ignored, entries, skipped_entries);
1268    }
1269}
1270
1271/// Discover the entry points of a workspace package.
1272#[must_use]
1273pub fn discover_workspace_package_entry_points(
1274    ws_root: &Path,
1275    all_files: &[DiscoveredFile],
1276    pkg: Option<&PackageJson>,
1277    ignored: IgnoredCommandEntries<'_>,
1278    workspaces: ScriptWorkspaces<'_>,
1279) -> EntryPointDiscovery {
1280    let mut discovery = EntryPointDiscovery::default();
1281
1282    if let Some(pkg) = pkg {
1283        let canonical_ws_root =
1284            dunce::canonicalize(ws_root).unwrap_or_else(|_| ws_root.to_path_buf());
1285        let output_map = TsconfigOutputMap::from_project(ws_root);
1286        for entry_path in pkg.entry_points() {
1287            if entry_path.contains('*') {
1288                expand_wildcard_entries(ws_root, &entry_path, all_files, &mut discovery.entries);
1289            } else if let Some(ep) = resolve_entry_path_with_output_map(
1290                ws_root,
1291                &entry_path,
1292                &canonical_ws_root,
1293                EntryPointSource::PackageJsonMain,
1294                Some(&mut discovery.skipped_entries),
1295                EntryTargets {
1296                    output_map: &output_map,
1297                    discovered: workspaces.discovered,
1298                },
1299            ) {
1300                discovery.entries.push(ep);
1301            }
1302        }
1303
1304        if let Some(scripts) = &pkg.scripts {
1305            let package = ScriptPackage {
1306                root: ws_root,
1307                canonical_root: &canonical_ws_root,
1308                output_map: &output_map,
1309                workspaces,
1310            };
1311            push_script_entries(
1312                &package,
1313                scripts,
1314                ignored,
1315                &mut PackageEntryBuckets {
1316                    runtime: &mut discovery.entries,
1317                    support: &mut discovery.support_entries,
1318                },
1319                &mut discovery.skipped_entries,
1320            );
1321        }
1322    }
1323
1324    if discovery.entries.is_empty() {
1325        discovery.entries = apply_default_fallback(all_files, ws_root, Some(ws_root));
1326    }
1327
1328    discovery.entries.sort_by(|a, b| a.path.cmp(&b.path));
1329    discovery.entries.dedup_by(|a, b| a.path == b.path);
1330    discovery
1331        .support_entries
1332        .sort_by(|a, b| a.path.cmp(&b.path));
1333    discovery.support_entries.dedup_by(|a, b| a.path == b.path);
1334    discovery
1335}
1336
1337/// Discover entry points from `dynamicallyLoaded` config patterns.
1338///
1339/// Matches the configured glob patterns against the discovered file list and
1340/// marks matching files as entry points so they are never flagged as unused.
1341///
1342/// # Panics
1343///
1344/// Panics if a `dynamicallyLoaded` glob pattern is invalid. Config loading
1345/// validates these patterns first.
1346#[expect(
1347    clippy::expect_used,
1348    reason = "dynamicallyLoaded glob patterns are validated before entry point discovery"
1349)]
1350#[must_use]
1351pub fn discover_dynamically_loaded_entry_points(
1352    config: &ResolvedConfig,
1353    files: &[DiscoveredFile],
1354) -> Vec<EntryPoint> {
1355    if config.dynamically_loaded.is_empty() {
1356        return Vec::new();
1357    }
1358
1359    let mut builder = globset::GlobSetBuilder::new();
1360    for pattern in &config.dynamically_loaded {
1361        builder.add(
1362            fallow_config::compile_path_glob(pattern)
1363                .expect("dynamicallyLoaded pattern was validated at config load time"),
1364        );
1365    }
1366    let Ok(glob_set) = builder.build() else {
1367        return Vec::new();
1368    };
1369    if glob_set.is_empty() {
1370        return Vec::new();
1371    }
1372
1373    let mut entries = Vec::new();
1374    for file in files {
1375        let rel = file
1376            .path
1377            .strip_prefix(&config.root)
1378            .unwrap_or(&file.path)
1379            .to_string_lossy();
1380        if glob_set.is_match(rel.as_ref()) {
1381            entries.push(EntryPoint {
1382                path: file.path.clone(),
1383                source: EntryPointSource::DynamicallyLoaded,
1384            });
1385        }
1386    }
1387    entries
1388}
1389
1390#[cfg(test)]
1391mod tests {
1392    use super::*;
1393    use fallow_config::{EntryPointRole, FallowConfig, OutputFormat, RulesConfig};
1394    use fallow_types::discover::FileId;
1395    use proptest::prelude::*;
1396
1397    proptest! {
1398        /// Valid glob patterns should never panic when compiled via globset.
1399        #[test]
1400        fn glob_patterns_never_panic_on_compile(
1401            prefix in "[a-zA-Z0-9_]{1,20}",
1402            ext in prop::sample::select(vec!["ts", "tsx", "js", "jsx", "vue", "svelte", "astro", "mdx"]),
1403        ) {
1404            let pattern = format!("**/{prefix}*.{ext}");
1405            let result = globset::Glob::new(&pattern);
1406            prop_assert!(result.is_ok(), "Glob::new should not fail for well-formed patterns");
1407        }
1408
1409        /// Non-source extensions should NOT be in the SOURCE_EXTENSIONS list.
1410        #[test]
1411        fn non_source_extensions_not_in_list(
1412            ext in prop::sample::select(vec!["py", "rb", "rs", "go", "java", "xml", "yaml", "toml", "md", "txt", "png", "jpg", "wasm", "lock"]),
1413        ) {
1414            prop_assert!(
1415                !SOURCE_EXTENSIONS.contains(&ext),
1416                "Extension '{ext}' should NOT be in SOURCE_EXTENSIONS"
1417            );
1418        }
1419
1420    }
1421
1422    #[test]
1423    #[expect(
1424        clippy::too_many_lines,
1425        reason = "test fixture; linear setup/assert, length is not a maintainability concern"
1426    )]
1427    fn plugin_entry_point_sets_preserve_runtime_test_and_support_roles() {
1428        let dir = tempfile::tempdir().expect("create temp dir");
1429        let root = dir.path();
1430        std::fs::create_dir_all(root.join("src")).unwrap();
1431        std::fs::create_dir_all(root.join("tests")).unwrap();
1432        std::fs::write(root.join("src/runtime.ts"), "export const runtime = 1;").unwrap();
1433        std::fs::write(root.join("src/setup.ts"), "export const setup = 1;").unwrap();
1434        std::fs::write(root.join("tests/app.test.ts"), "export const test = 1;").unwrap();
1435
1436        let config = FallowConfig {
1437            type_aware: fallow_config::TypeAwareConfig::default(),
1438            schema: None,
1439            minimum_version: None,
1440            extends: vec![],
1441            entry: vec![],
1442            ignore_patterns: vec![],
1443            ignore_findings: vec![],
1444            framework: vec![],
1445            workspaces: None,
1446            ignore_dependencies: vec![],
1447            ignore_command_entries: vec![],
1448            ignore_unresolved_imports: vec![],
1449            ignore_exports: vec![],
1450            ignore_catalog_references: vec![],
1451            ignore_dependency_overrides: vec![],
1452            ignore_exports_used_in_file: fallow_config::IgnoreExportsUsedInFileConfig::default(),
1453            used_class_members: vec![],
1454            ignore_decorators: vec![],
1455            unused_component_props: fallow_config::UnusedComponentPropsConfig::default(),
1456            circular_dependencies: fallow_config::CircularDependenciesConfig::default(),
1457            duplicates: fallow_config::DuplicatesConfig::default(),
1458            similar_code: fallow_config::SimilarCodeConfig::default(),
1459            mutation: fallow_config::MutationConfig::default(),
1460            health: fallow_config::HealthConfig::default(),
1461            rules: RulesConfig::default(),
1462            boundaries: fallow_config::BoundaryConfig::default(),
1463            production: false.into(),
1464            plugins: vec![],
1465            rule_packs: vec![],
1466            overrides: vec![],
1467            regression: None,
1468            audit: fallow_config::AuditConfig::default(),
1469            codeowners: None,
1470            public_packages: vec![],
1471            flags: fallow_config::FlagsConfig::default(),
1472            security: fallow_config::SecurityConfig::default(),
1473            fix: fallow_config::FixConfig::default(),
1474            resolve: fallow_config::ResolveConfig::default(),
1475            sealed: false,
1476            include_entry_exports: false,
1477            show_cascade: false,
1478            auto_imports: false,
1479            fail_on_parse_error: false,
1480            cache: fallow_config::CacheConfig::default(),
1481            ..Default::default()
1482        }
1483        .resolve(root.to_path_buf(), OutputFormat::Human, 4, true, true, None);
1484
1485        let files = vec![
1486            DiscoveredFile {
1487                id: FileId(0),
1488                path: root.join("src/runtime.ts"),
1489                size_bytes: 1,
1490            },
1491            DiscoveredFile {
1492                id: FileId(1),
1493                path: root.join("src/setup.ts"),
1494                size_bytes: 1,
1495            },
1496            DiscoveredFile {
1497                id: FileId(2),
1498                path: root.join("tests/app.test.ts"),
1499                size_bytes: 1,
1500            },
1501        ];
1502
1503        let mut plugin_result = crate::plugins::AggregatedPluginResult::default();
1504        plugin_result.entry_patterns.push((
1505            crate::plugins::PathRule::new("src/runtime.ts"),
1506            "runtime-plugin".to_string(),
1507        ));
1508        plugin_result.entry_patterns.push((
1509            crate::plugins::PathRule::new("tests/app.test.ts"),
1510            "test-plugin".to_string(),
1511        ));
1512        plugin_result
1513            .always_used
1514            .push(("src/setup.ts".to_string(), "support-plugin".to_string()));
1515        plugin_result
1516            .entry_point_roles
1517            .insert("runtime-plugin".to_string(), EntryPointRole::Runtime);
1518        plugin_result
1519            .entry_point_roles
1520            .insert("test-plugin".to_string(), EntryPointRole::Test);
1521        plugin_result
1522            .entry_point_roles
1523            .insert("support-plugin".to_string(), EntryPointRole::Support);
1524
1525        let entries = discover_plugin_entry_point_sets(&plugin_result, &config, &files);
1526
1527        assert_eq!(entries.runtime.len(), 1, "expected one runtime entry");
1528        assert!(
1529            entries.runtime[0].path.ends_with("src/runtime.ts"),
1530            "runtime entry should stay runtime-only"
1531        );
1532        assert_eq!(entries.test.len(), 1, "expected one test entry");
1533        assert!(
1534            entries.test[0].path.ends_with("tests/app.test.ts"),
1535            "test entry should stay test-only"
1536        );
1537        assert_eq!(
1538            entries.all.len(),
1539            3,
1540            "support entries should stay in all entries"
1541        );
1542        assert!(
1543            entries
1544                .all
1545                .iter()
1546                .any(|entry| entry.path.ends_with("src/setup.ts")),
1547            "support entries should remain in the overall entry-point set"
1548        );
1549        assert!(
1550            !entries
1551                .runtime
1552                .iter()
1553                .any(|entry| entry.path.ends_with("src/setup.ts")),
1554            "support entries should not bleed into runtime reachability"
1555        );
1556        assert!(
1557            !entries
1558                .test
1559                .iter()
1560                .any(|entry| entry.path.ends_with("src/setup.ts")),
1561            "support entries should not bleed into test reachability"
1562        );
1563    }
1564
1565    #[test]
1566    fn resolve_plugin_setup_file_preserves_windows_absolute_path_on_any_host() {
1567        let root = Path::new("/workspace/project");
1568        let setup_file = Path::new(r"C:\workspace\project\setup.ts");
1569
1570        assert_eq!(
1571            plugin_entries::resolve_plugin_setup_file(root, setup_file),
1572            setup_file.to_path_buf()
1573        );
1574    }
1575
1576    #[cfg(windows)]
1577    #[test]
1578    fn resolve_plugin_setup_file_preserves_posix_rooted_path_on_windows() {
1579        let root = Path::new(r"C:\workspace\project");
1580        let setup_file = Path::new(r"/workspace/project/setup.ts");
1581
1582        assert_eq!(
1583            plugin_entries::resolve_plugin_setup_file(root, setup_file),
1584            setup_file.to_path_buf()
1585        );
1586    }
1587
1588    #[test]
1589    fn plugin_entry_point_rules_respect_exclusions() {
1590        let dir = tempfile::tempdir().expect("create temp dir");
1591        let root = dir.path();
1592        std::fs::create_dir_all(root.join("app/pages")).unwrap();
1593        std::fs::write(
1594            root.join("app/pages/index.tsx"),
1595            "export default function Page() { return null; }",
1596        )
1597        .unwrap();
1598        std::fs::write(
1599            root.join("app/pages/-helper.ts"),
1600            "export const helper = 1;",
1601        )
1602        .unwrap();
1603
1604        let config = FallowConfig {
1605            type_aware: fallow_config::TypeAwareConfig::default(),
1606            schema: None,
1607            minimum_version: None,
1608            extends: vec![],
1609            entry: vec![],
1610            ignore_patterns: vec![],
1611            ignore_findings: vec![],
1612            framework: vec![],
1613            workspaces: None,
1614            ignore_dependencies: vec![],
1615            ignore_command_entries: vec![],
1616            ignore_unresolved_imports: vec![],
1617            ignore_exports: vec![],
1618            ignore_catalog_references: vec![],
1619            ignore_dependency_overrides: vec![],
1620            ignore_exports_used_in_file: fallow_config::IgnoreExportsUsedInFileConfig::default(),
1621            used_class_members: vec![],
1622            ignore_decorators: vec![],
1623            unused_component_props: fallow_config::UnusedComponentPropsConfig::default(),
1624            circular_dependencies: fallow_config::CircularDependenciesConfig::default(),
1625            duplicates: fallow_config::DuplicatesConfig::default(),
1626            similar_code: fallow_config::SimilarCodeConfig::default(),
1627            mutation: fallow_config::MutationConfig::default(),
1628            health: fallow_config::HealthConfig::default(),
1629            rules: RulesConfig::default(),
1630            boundaries: fallow_config::BoundaryConfig::default(),
1631            production: false.into(),
1632            plugins: vec![],
1633            rule_packs: vec![],
1634            overrides: vec![],
1635            regression: None,
1636            audit: fallow_config::AuditConfig::default(),
1637            codeowners: None,
1638            public_packages: vec![],
1639            flags: fallow_config::FlagsConfig::default(),
1640            security: fallow_config::SecurityConfig::default(),
1641            fix: fallow_config::FixConfig::default(),
1642            resolve: fallow_config::ResolveConfig::default(),
1643            sealed: false,
1644            include_entry_exports: false,
1645            show_cascade: false,
1646            auto_imports: false,
1647            fail_on_parse_error: false,
1648            cache: fallow_config::CacheConfig::default(),
1649            ..Default::default()
1650        }
1651        .resolve(root.to_path_buf(), OutputFormat::Human, 4, true, true, None);
1652
1653        let files = vec![
1654            DiscoveredFile {
1655                id: FileId(0),
1656                path: root.join("app/pages/index.tsx"),
1657                size_bytes: 1,
1658            },
1659            DiscoveredFile {
1660                id: FileId(1),
1661                path: root.join("app/pages/-helper.ts"),
1662                size_bytes: 1,
1663            },
1664        ];
1665
1666        let mut plugin_result = crate::plugins::AggregatedPluginResult::default();
1667        plugin_result.entry_patterns.push((
1668            crate::plugins::PathRule::new("app/pages/**/*.{ts,tsx,js,jsx}")
1669                .with_excluded_globs(["app/pages/**/-*", "app/pages/**/-*/**/*"]),
1670            "tanstack-router".to_string(),
1671        ));
1672        plugin_result
1673            .entry_point_roles
1674            .insert("tanstack-router".to_string(), EntryPointRole::Runtime);
1675
1676        let entries = discover_plugin_entry_point_sets(&plugin_result, &config, &files);
1677        let entry_paths: Vec<_> = entries
1678            .all
1679            .iter()
1680            .map(|entry| {
1681                entry
1682                    .path
1683                    .strip_prefix(root)
1684                    .unwrap()
1685                    .to_string_lossy()
1686                    .into_owned()
1687            })
1688            .collect();
1689
1690        assert!(entry_paths.contains(&"app/pages/index.tsx".to_string()));
1691        assert!(!entry_paths.contains(&"app/pages/-helper.ts".to_string()));
1692    }
1693
1694    mod resolve_entry_path_tests {
1695        use super::*;
1696
1697        fn resolve_main(root: &Path, entry: &str) -> Option<PathBuf> {
1698            let canonical = dunce::canonicalize(root).unwrap();
1699            resolve_entry_path(
1700                &canonical,
1701                entry,
1702                &canonical,
1703                EntryPointSource::PackageJsonMain,
1704            )
1705            .map(|entry_point| entry_point.path)
1706        }
1707
1708        #[test]
1709        fn hand_written_lib_entry_wins_over_unrelated_source_index() {
1710            let dir = tempfile::tempdir().expect("create temp dir");
1711            let root = dunce::canonicalize(dir.path()).unwrap();
1712            std::fs::create_dir_all(root.join("lib")).unwrap();
1713            std::fs::create_dir_all(root.join("src")).unwrap();
1714            std::fs::write(root.join("lib/index.js"), "module.exports = {};").unwrap();
1715            std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1716
1717            assert_eq!(
1718                resolve_main(&root, "./lib/index.js"),
1719                Some(root.join("./lib/index.js"))
1720            );
1721        }
1722
1723        #[test]
1724        fn hand_written_lib_entry_does_not_fall_back_to_source_index() {
1725            let dir = tempfile::tempdir().expect("create temp dir");
1726            let root = dunce::canonicalize(dir.path()).unwrap();
1727            std::fs::create_dir_all(root.join("lib")).unwrap();
1728            std::fs::create_dir_all(root.join("src")).unwrap();
1729            std::fs::write(root.join("lib/foo.js"), "module.exports = {};").unwrap();
1730            std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1731            std::fs::write(root.join("index.js"), "module.exports = {};").unwrap();
1732
1733            assert_eq!(
1734                resolve_main(&root, "./lib/foo.js"),
1735                Some(root.join("./lib/foo.js"))
1736            );
1737        }
1738
1739        #[test]
1740        fn missing_lib_entry_without_same_stem_source_stays_unresolved() {
1741            let dir = tempfile::tempdir().expect("create temp dir");
1742            let root = dunce::canonicalize(dir.path()).unwrap();
1743            std::fs::create_dir_all(root.join("src")).unwrap();
1744            std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1745
1746            assert_eq!(resolve_main(&root, "./lib/foo.js"), None);
1747        }
1748
1749        #[test]
1750        fn missing_lib_entry_maps_to_same_stem_source() {
1751            let dir = tempfile::tempdir().expect("create temp dir");
1752            let root = dunce::canonicalize(dir.path()).unwrap();
1753            std::fs::create_dir_all(root.join("src")).unwrap();
1754            std::fs::write(root.join("src/index.ts"), "export {};").unwrap();
1755
1756            assert_eq!(
1757                resolve_main(&root, "./lib/index.mjs"),
1758                Some(root.join("src/index.ts"))
1759            );
1760        }
1761
1762        #[test]
1763        fn resolves_existing_file() {
1764            let dir = tempfile::tempdir().expect("create temp dir");
1765            let src = dir.path().join("src");
1766            std::fs::create_dir_all(&src).unwrap();
1767            std::fs::write(src.join("index.ts"), "export const a = 1;").unwrap();
1768
1769            let canonical = dunce::canonicalize(dir.path()).unwrap();
1770            let result = resolve_entry_path(
1771                dir.path(),
1772                "src/index.ts",
1773                &canonical,
1774                EntryPointSource::PackageJsonMain,
1775            );
1776            assert!(result.is_some(), "should resolve an existing file");
1777            assert!(result.unwrap().path.ends_with("src/index.ts"));
1778        }
1779
1780        #[test]
1781        fn resolves_with_extension_fallback() {
1782            let dir = tempfile::tempdir().expect("create temp dir");
1783            let canonical = dunce::canonicalize(dir.path()).unwrap();
1784            let src = canonical.join("src");
1785            std::fs::create_dir_all(&src).unwrap();
1786            std::fs::write(src.join("index.ts"), "export const a = 1;").unwrap();
1787
1788            let result = resolve_entry_path(
1789                &canonical,
1790                "src/index",
1791                &canonical,
1792                EntryPointSource::PackageJsonMain,
1793            );
1794            assert!(
1795                result.is_some(),
1796                "should resolve via extension fallback when exact path doesn't exist"
1797            );
1798            let ep = result.unwrap();
1799            assert!(
1800                ep.path.to_string_lossy().contains("index.ts"),
1801                "should find index.ts via extension fallback"
1802            );
1803        }
1804
1805        #[test]
1806        fn exact_file_wins_before_directory_index_fallback() {
1807            let dir = tempfile::tempdir().expect("create temp dir");
1808            let canonical = dunce::canonicalize(dir.path()).unwrap();
1809            let scripts = canonical.join("scripts");
1810            std::fs::create_dir_all(scripts.join("process-messages")).unwrap();
1811            std::fs::write(
1812                scripts.join("process-messages.js"),
1813                "export const direct = true;",
1814            )
1815            .unwrap();
1816            std::fs::write(
1817                scripts.join("process-messages").join("index.js"),
1818                "export const index = true;",
1819            )
1820            .unwrap();
1821
1822            let result = resolve_entry_path(
1823                &canonical,
1824                "scripts/process-messages.js",
1825                &canonical,
1826                EntryPointSource::package_json_script("build"),
1827            )
1828            .expect("exact file should resolve");
1829
1830            assert!(result.path.ends_with("scripts/process-messages.js"));
1831        }
1832
1833        #[test]
1834        fn extension_fallback_wins_before_directory_index_fallback() {
1835            let dir = tempfile::tempdir().expect("create temp dir");
1836            let canonical = dunce::canonicalize(dir.path()).unwrap();
1837            let scripts = canonical.join("scripts");
1838            std::fs::create_dir_all(scripts.join("process-messages")).unwrap();
1839            std::fs::write(
1840                scripts.join("process-messages.ts"),
1841                "export const withExt = true;",
1842            )
1843            .unwrap();
1844            std::fs::write(
1845                scripts.join("process-messages").join("index.js"),
1846                "export const index = true;",
1847            )
1848            .unwrap();
1849
1850            let result = resolve_entry_path(
1851                &canonical,
1852                "scripts/process-messages",
1853                &canonical,
1854                EntryPointSource::package_json_script("build"),
1855            )
1856            .expect("extension fallback should resolve");
1857
1858            assert!(result.path.ends_with("scripts/process-messages.ts"));
1859        }
1860
1861        #[test]
1862        fn resolves_directory_index_after_exact_and_extension_fallbacks() {
1863            let dir = tempfile::tempdir().expect("create temp dir");
1864            let canonical = dunce::canonicalize(dir.path()).unwrap();
1865            let scripts = canonical.join("scripts/process-messages");
1866            std::fs::create_dir_all(&scripts).unwrap();
1867            std::fs::write(scripts.join("index.js"), "export const index = true;").unwrap();
1868
1869            let result = resolve_entry_path(
1870                &canonical,
1871                "scripts/process-messages",
1872                &canonical,
1873                EntryPointSource::package_json_script("build"),
1874            )
1875            .expect("directory index should resolve");
1876
1877            assert!(result.path.ends_with("scripts/process-messages/index.js"));
1878        }
1879
1880        #[test]
1881        fn directory_index_fallback_ignores_wildcards_and_url_like_entries() {
1882            let dir = tempfile::tempdir().expect("create temp dir");
1883            let canonical = dunce::canonicalize(dir.path()).unwrap();
1884            std::fs::create_dir_all(canonical.join("scripts/process-messages")).unwrap();
1885            std::fs::write(
1886                canonical.join("scripts/process-messages/index.js"),
1887                "export const index = true;",
1888            )
1889            .unwrap();
1890
1891            for entry in [
1892                "scripts/*",
1893                "https://example.com/scripts/process-messages",
1894                "@scope/package/scripts/process-messages",
1895            ] {
1896                let result = resolve_entry_path(
1897                    &canonical,
1898                    entry,
1899                    &canonical,
1900                    EntryPointSource::package_json_script("build"),
1901                );
1902                assert!(result.is_none(), "{entry} should not resolve");
1903            }
1904        }
1905
1906        #[test]
1907        fn returns_none_for_nonexistent_file() {
1908            let dir = tempfile::tempdir().expect("create temp dir");
1909            let canonical = dunce::canonicalize(dir.path()).unwrap();
1910            let result = resolve_entry_path(
1911                dir.path(),
1912                "does/not/exist.ts",
1913                &canonical,
1914                EntryPointSource::PackageJsonMain,
1915            );
1916            assert!(result.is_none(), "should return None for nonexistent files");
1917        }
1918
1919        #[test]
1920        fn maps_dist_output_to_src() {
1921            let dir = tempfile::tempdir().expect("create temp dir");
1922            let src = dir.path().join("src");
1923            std::fs::create_dir_all(&src).unwrap();
1924            std::fs::write(src.join("utils.ts"), "export const u = 1;").unwrap();
1925
1926            let dist = dir.path().join("dist");
1927            std::fs::create_dir_all(&dist).unwrap();
1928            std::fs::write(dist.join("utils.js"), "// compiled").unwrap();
1929
1930            let canonical = dunce::canonicalize(dir.path()).unwrap();
1931            let result = resolve_entry_path(
1932                dir.path(),
1933                "./dist/utils.js",
1934                &canonical,
1935                EntryPointSource::PackageJsonExports,
1936            );
1937            assert!(result.is_some(), "should resolve dist/ path to src/");
1938            let ep = result.unwrap();
1939            assert!(
1940                ep.path
1941                    .to_string_lossy()
1942                    .replace('\\', "/")
1943                    .contains("src/utils.ts"),
1944                "should map ./dist/utils.js to src/utils.ts"
1945            );
1946        }
1947
1948        #[test]
1949        fn maps_build_output_to_src() {
1950            let dir = tempfile::tempdir().expect("create temp dir");
1951            let canonical = dunce::canonicalize(dir.path()).unwrap();
1952            let src = canonical.join("src");
1953            std::fs::create_dir_all(&src).unwrap();
1954            std::fs::write(src.join("index.tsx"), "export default () => {};").unwrap();
1955
1956            let result = resolve_entry_path(
1957                &canonical,
1958                "./build/index.js",
1959                &canonical,
1960                EntryPointSource::PackageJsonExports,
1961            );
1962            assert!(result.is_some(), "should map build/ output to src/");
1963            let ep = result.unwrap();
1964            assert!(
1965                ep.path
1966                    .to_string_lossy()
1967                    .replace('\\', "/")
1968                    .contains("src/index.tsx"),
1969                "should map ./build/index.js to src/index.tsx"
1970            );
1971        }
1972
1973        #[test]
1974        fn preserves_entry_point_source() {
1975            let dir = tempfile::tempdir().expect("create temp dir");
1976            std::fs::write(dir.path().join("index.ts"), "export const a = 1;").unwrap();
1977
1978            let canonical = dunce::canonicalize(dir.path()).unwrap();
1979            let result = resolve_entry_path(
1980                dir.path(),
1981                "index.ts",
1982                &canonical,
1983                EntryPointSource::package_json_script("build"),
1984            );
1985            assert!(result.is_some());
1986            assert_eq!(result.unwrap().source.script(), Some("build"));
1987        }
1988        #[test]
1989        fn tracks_skipped_entries_without_logging_each_repeat() {
1990            let dir = tempfile::tempdir().expect("create temp dir");
1991            let canonical = dunce::canonicalize(dir.path()).unwrap();
1992            let mut skipped_entries = FxHashMap::default();
1993
1994            let result = resolve_entry_path_with_tracking(
1995                dir.path(),
1996                "../scripts/build.js",
1997                &canonical,
1998                EntryPointSource::package_json_script("build"),
1999                Some(&mut skipped_entries),
2000                None,
2001            );
2002
2003            assert!(result.is_none(), "unsafe entry should be skipped");
2004            assert_eq!(
2005                skipped_entries.get("../scripts/build.js"),
2006                Some(&1),
2007                "warning tracker should count the skipped path"
2008            );
2009        }
2010
2011        #[test]
2012        fn formats_skipped_entry_warning_with_counts() {
2013            let mut skipped_entries = FxHashMap::default();
2014            skipped_entries.insert("../../scripts/rm.mjs".to_owned(), 8);
2015            skipped_entries.insert("../utils/bar.js".to_owned(), 2);
2016
2017            let warning =
2018                format_skipped_entry_warning(&skipped_entries).expect("warning should be rendered");
2019
2020            assert_eq!(
2021                warning,
2022                "Skipped 10 package.json entry points outside project root or containing parent directory traversal: ../../scripts/rm.mjs (8x), ../utils/bar.js (2x)"
2023            );
2024        }
2025
2026        #[test]
2027        fn skipped_entry_summary_dedupes_identical_messages() {
2028            let message = format!(
2029                "Skipped 1 package.json entry point outside project root: ../../pkg-{}/bin/x",
2030                std::process::id()
2031            );
2032            assert!(
2033                should_warn_skipped_entry(&message),
2034                "first occurrence of a message emits"
2035            );
2036            assert!(
2037                !should_warn_skipped_entry(&message),
2038                "identical repeat is suppressed"
2039            );
2040        }
2041
2042        #[test]
2043        fn rejects_parent_dir_escape_for_exact_file() {
2044            let sandbox = tempfile::tempdir().expect("create sandbox");
2045            let root = sandbox.path().join("project");
2046            std::fs::create_dir_all(&root).unwrap();
2047            std::fs::write(
2048                sandbox.path().join("escape.ts"),
2049                "export const escape = true;",
2050            )
2051            .unwrap();
2052
2053            let canonical = dunce::canonicalize(&root).unwrap();
2054            let result = resolve_entry_path(
2055                &root,
2056                "../escape.ts",
2057                &canonical,
2058                EntryPointSource::PackageJsonMain,
2059            );
2060
2061            assert!(
2062                result.is_none(),
2063                "should reject exact paths that escape the root"
2064            );
2065        }
2066
2067        #[test]
2068        fn rejects_parent_dir_escape_via_extension_fallback() {
2069            let sandbox = tempfile::tempdir().expect("create sandbox");
2070            let root = sandbox.path().join("project");
2071            std::fs::create_dir_all(&root).unwrap();
2072            std::fs::write(
2073                sandbox.path().join("escape.ts"),
2074                "export const escape = true;",
2075            )
2076            .unwrap();
2077
2078            let canonical = dunce::canonicalize(&root).unwrap();
2079            let result = resolve_entry_path(
2080                &root,
2081                "../escape",
2082                &canonical,
2083                EntryPointSource::PackageJsonMain,
2084            );
2085
2086            assert!(
2087                result.is_none(),
2088                "should reject extension fallback paths that escape the root"
2089            );
2090        }
2091    }
2092
2093    mod output_to_source_tests {
2094        use super::*;
2095
2096        /// The output mapping without a discovered file set: a `lib/` file on
2097        /// disk counts as present.
2098        fn try_legacy_output_to_source_path(base: &Path, entry: &str) -> Option<PathBuf> {
2099            output_entry_to_source_path(base, entry, SOURCE_EXTENSIONS, |_| true)
2100        }
2101
2102        #[test]
2103        fn maps_dist_to_src_with_ts_extension() {
2104            let dir = tempfile::tempdir().expect("create temp dir");
2105            let src = dir.path().join("src");
2106            std::fs::create_dir_all(&src).unwrap();
2107            std::fs::write(src.join("utils.ts"), "export const u = 1;").unwrap();
2108
2109            let result = try_legacy_output_to_source_path(dir.path(), "./dist/utils.js");
2110            assert!(result.is_some());
2111            assert!(
2112                result
2113                    .unwrap()
2114                    .to_string_lossy()
2115                    .replace('\\', "/")
2116                    .contains("src/utils.ts")
2117            );
2118        }
2119
2120        #[test]
2121        fn returns_none_when_no_source_file_exists() {
2122            let dir = tempfile::tempdir().expect("create temp dir");
2123            let result = try_legacy_output_to_source_path(dir.path(), "./dist/missing.js");
2124            assert!(result.is_none());
2125        }
2126
2127        #[test]
2128        fn ignores_non_output_directories() {
2129            let dir = tempfile::tempdir().expect("create temp dir");
2130            let src = dir.path().join("src");
2131            std::fs::create_dir_all(&src).unwrap();
2132            std::fs::write(src.join("foo.ts"), "export const f = 1;").unwrap();
2133
2134            let result = try_legacy_output_to_source_path(dir.path(), "./scripts/foo.js");
2135            assert!(result.is_none());
2136        }
2137
2138        #[test]
2139        fn maps_lib_entry_to_source_only_when_lib_target_is_missing() {
2140            let dir = tempfile::tempdir().expect("create temp dir");
2141            let src = dir.path().join("src");
2142            std::fs::create_dir_all(&src).unwrap();
2143            std::fs::write(src.join("foo.ts"), "export const f = 1;").unwrap();
2144
2145            assert_eq!(
2146                try_legacy_output_to_source_path(dir.path(), "./lib/foo.js"),
2147                Some(src.join("foo.ts")),
2148                "a missing lib/ build output maps to the same-stem source file"
2149            );
2150
2151            let lib = dir.path().join("lib");
2152            std::fs::create_dir_all(&lib).unwrap();
2153            std::fs::write(lib.join("foo.js"), "exports.f = 1;").unwrap();
2154            assert_eq!(
2155                try_legacy_output_to_source_path(dir.path(), "./lib/foo.js"),
2156                None,
2157                "a lib/ file on disk stays the entry"
2158            );
2159        }
2160
2161        #[test]
2162        fn lib_entry_without_extension_counts_as_present() {
2163            let dir = tempfile::tempdir().expect("create temp dir");
2164            std::fs::create_dir_all(dir.path().join("src")).unwrap();
2165            std::fs::write(dir.path().join("src/index.ts"), "export {};").unwrap();
2166            std::fs::create_dir_all(dir.path().join("lib")).unwrap();
2167            std::fs::write(dir.path().join("lib/index.js"), "module.exports = {};").unwrap();
2168
2169            assert_eq!(
2170                try_legacy_output_to_source_path(dir.path(), "./lib/index"),
2171                None
2172            );
2173            assert_eq!(try_legacy_output_to_source_path(dir.path(), "./lib"), None);
2174        }
2175
2176        #[test]
2177        fn maps_missing_lib_entry_with_nested_prefix() {
2178            let dir = tempfile::tempdir().expect("create temp dir");
2179            let modules_src = dir.path().join("modules/src");
2180            std::fs::create_dir_all(&modules_src).unwrap();
2181            std::fs::write(modules_src.join("x.ts"), "export const x = 1;").unwrap();
2182
2183            assert_eq!(
2184                try_legacy_output_to_source_path(dir.path(), "./modules/lib/x.mjs"),
2185                Some(modules_src.join("x.ts"))
2186            );
2187        }
2188
2189        #[test]
2190        fn bare_missing_lib_entry_does_not_map_to_source_directory() {
2191            let dir = tempfile::tempdir().expect("create temp dir");
2192            std::fs::create_dir_all(dir.path().join("src")).unwrap();
2193
2194            assert_eq!(try_legacy_output_to_source_path(dir.path(), "./lib"), None);
2195        }
2196
2197        #[test]
2198        fn lib_is_not_an_index_fallback_output_dir() {
2199            assert!(!is_entry_in_output_dir("./lib/foo.js"));
2200        }
2201
2202        #[test]
2203        fn maps_nested_output_path_preserving_prefix() {
2204            let dir = tempfile::tempdir().expect("create temp dir");
2205            let modules_src = dir.path().join("modules").join("src");
2206            std::fs::create_dir_all(&modules_src).unwrap();
2207            std::fs::write(modules_src.join("helper.ts"), "export const h = 1;").unwrap();
2208
2209            let result = try_legacy_output_to_source_path(dir.path(), "./modules/dist/helper.js");
2210            assert!(result.is_some());
2211            assert!(
2212                result
2213                    .unwrap()
2214                    .to_string_lossy()
2215                    .replace('\\', "/")
2216                    .contains("modules/src/helper.ts")
2217            );
2218        }
2219    }
2220
2221    mod source_index_fallback_tests {
2222        use super::*;
2223
2224        #[test]
2225        fn detects_dist_entry_in_output_dir() {
2226            assert!(is_entry_in_output_dir("./dist/esm2022/index.js"));
2227            assert!(is_entry_in_output_dir("dist/index.js"));
2228            assert!(is_entry_in_output_dir("./build/index.js"));
2229            assert!(is_entry_in_output_dir("./out/main.js"));
2230            assert!(is_entry_in_output_dir("./esm/index.js"));
2231            assert!(is_entry_in_output_dir("./cjs/index.js"));
2232        }
2233
2234        #[test]
2235        fn rejects_non_output_entry_paths() {
2236            assert!(!is_entry_in_output_dir("./src/index.ts"));
2237            assert!(!is_entry_in_output_dir("src/main.ts"));
2238            assert!(!is_entry_in_output_dir("./index.js"));
2239            assert!(!is_entry_in_output_dir(""));
2240        }
2241
2242        #[test]
2243        fn root_index_entries_are_recognized_for_source_fallback() {
2244            assert!(is_package_root_index_entry("./index.js"));
2245            assert!(is_package_root_index_entry("index.cjs"));
2246            assert!(is_package_root_index_entry("./index.d.ts"));
2247            assert!(!is_package_root_index_entry("./src/index.js"));
2248            assert!(!is_package_root_index_entry("./main.js"));
2249            assert!(!is_package_root_index_entry(""));
2250        }
2251
2252        #[test]
2253        fn rejects_substring_match_for_output_dir() {
2254            assert!(!is_entry_in_output_dir("./distro/index.js"));
2255            assert!(!is_entry_in_output_dir("./build-scripts/run.js"));
2256        }
2257
2258        #[test]
2259        fn finds_src_index_ts() {
2260            let dir = tempfile::tempdir().expect("create temp dir");
2261            let src = dir.path().join("src");
2262            std::fs::create_dir_all(&src).unwrap();
2263            let index_path = src.join("index.ts");
2264            std::fs::write(&index_path, "export const a = 1;").unwrap();
2265
2266            let result = try_source_index_fallback(dir.path());
2267            assert_eq!(result.as_deref(), Some(index_path.as_path()));
2268        }
2269
2270        #[test]
2271        fn finds_src_index_tsx_when_ts_missing() {
2272            let dir = tempfile::tempdir().expect("create temp dir");
2273            let src = dir.path().join("src");
2274            std::fs::create_dir_all(&src).unwrap();
2275            let index_path = src.join("index.tsx");
2276            std::fs::write(&index_path, "export default 1;").unwrap();
2277
2278            let result = try_source_index_fallback(dir.path());
2279            assert_eq!(result.as_deref(), Some(index_path.as_path()));
2280        }
2281
2282        #[test]
2283        fn prefers_src_index_over_root_index() {
2284            let dir = tempfile::tempdir().expect("create temp dir");
2285            let src = dir.path().join("src");
2286            std::fs::create_dir_all(&src).unwrap();
2287            let src_index = src.join("index.ts");
2288            std::fs::write(&src_index, "export const a = 1;").unwrap();
2289            let root_index = dir.path().join("index.ts");
2290            std::fs::write(&root_index, "export const b = 2;").unwrap();
2291
2292            let result = try_source_index_fallback(dir.path());
2293            assert_eq!(result.as_deref(), Some(src_index.as_path()));
2294        }
2295
2296        #[test]
2297        fn falls_back_to_src_main() {
2298            let dir = tempfile::tempdir().expect("create temp dir");
2299            let src = dir.path().join("src");
2300            std::fs::create_dir_all(&src).unwrap();
2301            let main_path = src.join("main.ts");
2302            std::fs::write(&main_path, "export const a = 1;").unwrap();
2303
2304            let result = try_source_index_fallback(dir.path());
2305            assert_eq!(result.as_deref(), Some(main_path.as_path()));
2306        }
2307
2308        #[test]
2309        fn falls_back_to_root_index_when_no_src() {
2310            let dir = tempfile::tempdir().expect("create temp dir");
2311            let index_path = dir.path().join("index.js");
2312            std::fs::write(&index_path, "module.exports = {};").unwrap();
2313
2314            let result = try_source_index_fallback(dir.path());
2315            assert_eq!(result.as_deref(), Some(index_path.as_path()));
2316        }
2317
2318        #[test]
2319        fn returns_none_when_nothing_matches() {
2320            let dir = tempfile::tempdir().expect("create temp dir");
2321            let result = try_source_index_fallback(dir.path());
2322            assert!(result.is_none());
2323        }
2324
2325        #[test]
2326        fn resolve_entry_path_falls_back_to_src_index_for_dist_entry() {
2327            let dir = tempfile::tempdir().expect("create temp dir");
2328            let canonical = dunce::canonicalize(dir.path()).unwrap();
2329
2330            let dist_dir = canonical.join("dist").join("esm2022");
2331            std::fs::create_dir_all(&dist_dir).unwrap();
2332            std::fs::write(dist_dir.join("index.js"), "export const x = 1;").unwrap();
2333
2334            let src = canonical.join("src");
2335            std::fs::create_dir_all(&src).unwrap();
2336            let src_index = src.join("index.ts");
2337            std::fs::write(&src_index, "export const x = 1;").unwrap();
2338
2339            let result = resolve_entry_path(
2340                &canonical,
2341                "./dist/esm2022/index.js",
2342                &canonical,
2343                EntryPointSource::PackageJsonMain,
2344            );
2345            assert!(result.is_some());
2346            let entry = result.unwrap();
2347            assert_eq!(entry.path, src_index);
2348        }
2349
2350        #[test]
2351        fn resolve_entry_path_uses_direct_src_mirror_when_available() {
2352            let dir = tempfile::tempdir().expect("create temp dir");
2353            let canonical = dunce::canonicalize(dir.path()).unwrap();
2354
2355            let src_mirror = canonical.join("src").join("esm2022");
2356            std::fs::create_dir_all(&src_mirror).unwrap();
2357            let mirror_index = src_mirror.join("index.ts");
2358            std::fs::write(&mirror_index, "export const x = 1;").unwrap();
2359
2360            let src_index = canonical.join("src").join("index.ts");
2361            std::fs::write(&src_index, "export const y = 2;").unwrap();
2362
2363            let result = resolve_entry_path(
2364                &canonical,
2365                "./dist/esm2022/index.js",
2366                &canonical,
2367                EntryPointSource::PackageJsonMain,
2368            );
2369            assert_eq!(result.map(|e| e.path), Some(mirror_index));
2370        }
2371
2372        /// A tsconfig with `rootDir: "."` claims `dist/` but names no file. A
2373        /// Nest build emits `dist/<path>.js` from `src/<path>.ts`.
2374        #[test]
2375        fn configured_output_without_source_maps_to_an_analyzed_src_file() {
2376            let dir = tempfile::tempdir().expect("create temp dir");
2377            let canonical = dunce::canonicalize(dir.path()).unwrap();
2378            std::fs::write(
2379                canonical.join("tsconfig.build.json"),
2380                r#"{"compilerOptions":{"rootDir":".","outDir":"./dist"}}"#,
2381            )
2382            .unwrap();
2383            std::fs::create_dir_all(canonical.join("src/scripts")).unwrap();
2384            let script = canonical.join("src/scripts/setup.ts");
2385            std::fs::write(&script, "export {};").unwrap();
2386            let entry = "dist/scripts/setup.js";
2387
2388            let analyzed: &(dyn Fn(&Path) -> bool + Sync) = &|_| true;
2389            let result = resolve_entry_path_with_discovered(
2390                &canonical,
2391                entry,
2392                &canonical,
2393                EntryPointSource::package_json_script("build"),
2394                analyzed,
2395            );
2396            assert_eq!(result.map(|e| e.path), Some(script));
2397
2398            let not_analyzed: &(dyn Fn(&Path) -> bool + Sync) = &|_| false;
2399            let result = resolve_entry_path_with_discovered(
2400                &canonical,
2401                entry,
2402                &canonical,
2403                EntryPointSource::package_json_script("build"),
2404                not_analyzed,
2405            );
2406            assert_eq!(
2407                result.map(|e| e.path),
2408                None,
2409                "a source file outside the analyzed files must not become an entry"
2410            );
2411        }
2412
2413        #[test]
2414        fn resolve_entry_path_falls_back_to_src_index_for_missing_root_index() {
2415            let dir = tempfile::tempdir().expect("create temp dir");
2416            let canonical = dunce::canonicalize(dir.path()).unwrap();
2417
2418            let src = canonical.join("src");
2419            std::fs::create_dir_all(&src).unwrap();
2420            let src_index = src.join("index.ts");
2421            std::fs::write(&src_index, "export const x = 1;").unwrap();
2422
2423            let result = resolve_entry_path(
2424                &canonical,
2425                "./index.js",
2426                &canonical,
2427                EntryPointSource::PackageJsonMain,
2428            );
2429            assert_eq!(result.map(|entry| entry.path), Some(src_index));
2430        }
2431    }
2432
2433    mod default_fallback_tests {
2434        use super::*;
2435
2436        #[test]
2437        fn finds_src_index_ts_as_fallback() {
2438            let dir = tempfile::tempdir().expect("create temp dir");
2439            let src = dir.path().join("src");
2440            std::fs::create_dir_all(&src).unwrap();
2441            let index_path = src.join("index.ts");
2442            std::fs::write(&index_path, "export const a = 1;").unwrap();
2443
2444            let files = vec![DiscoveredFile {
2445                id: FileId(0),
2446                path: index_path.clone(),
2447                size_bytes: 20,
2448            }];
2449
2450            let entries = apply_default_fallback(&files, dir.path(), None);
2451            assert_eq!(entries.len(), 1);
2452            assert_eq!(entries[0].path, index_path);
2453            assert!(matches!(entries[0].source, EntryPointSource::DefaultIndex));
2454        }
2455
2456        #[test]
2457        fn finds_root_index_js_as_fallback() {
2458            let dir = tempfile::tempdir().expect("create temp dir");
2459            let index_path = dir.path().join("index.js");
2460            std::fs::write(&index_path, "module.exports = {};").unwrap();
2461
2462            let files = vec![DiscoveredFile {
2463                id: FileId(0),
2464                path: index_path.clone(),
2465                size_bytes: 21,
2466            }];
2467
2468            let entries = apply_default_fallback(&files, dir.path(), None);
2469            assert_eq!(entries.len(), 1);
2470            assert_eq!(entries[0].path, index_path);
2471        }
2472
2473        #[test]
2474        fn returns_empty_when_no_index_file() {
2475            let dir = tempfile::tempdir().expect("create temp dir");
2476            let other_path = dir.path().join("src").join("utils.ts");
2477
2478            let files = vec![DiscoveredFile {
2479                id: FileId(0),
2480                path: other_path,
2481                size_bytes: 10,
2482            }];
2483
2484            let entries = apply_default_fallback(&files, dir.path(), None);
2485            assert!(
2486                entries.is_empty(),
2487                "non-index files should not match default fallback"
2488            );
2489        }
2490
2491        #[test]
2492        fn workspace_filter_restricts_scope() {
2493            let dir = tempfile::tempdir().expect("create temp dir");
2494            let ws_a = dir.path().join("packages").join("a").join("src");
2495            std::fs::create_dir_all(&ws_a).unwrap();
2496            let ws_b = dir.path().join("packages").join("b").join("src");
2497            std::fs::create_dir_all(&ws_b).unwrap();
2498
2499            let index_a = ws_a.join("index.ts");
2500            let index_b = ws_b.join("index.ts");
2501
2502            let files = vec![
2503                DiscoveredFile {
2504                    id: FileId(0),
2505                    path: index_a.clone(),
2506                    size_bytes: 10,
2507                },
2508                DiscoveredFile {
2509                    id: FileId(1),
2510                    path: index_b,
2511                    size_bytes: 10,
2512                },
2513            ];
2514
2515            let ws_root = dir.path().join("packages").join("a");
2516            let entries = apply_default_fallback(&files, &ws_root, Some(&ws_root));
2517            assert_eq!(entries.len(), 1);
2518            assert_eq!(entries[0].path, index_a);
2519        }
2520    }
2521
2522    fn config_for(root: &Path) -> ResolvedConfig {
2523        FallowConfig::default().resolve(
2524            root.to_path_buf(),
2525            OutputFormat::Human,
2526            1,
2527            true,
2528            true,
2529            None,
2530        )
2531    }
2532
2533    fn discovered(root: &Path, rel: &str, id: u32) -> DiscoveredFile {
2534        DiscoveredFile {
2535            id: FileId(id),
2536            path: root.join(rel),
2537            size_bytes: 1,
2538        }
2539    }
2540
2541    /// The root discovery of a project without workspace packages.
2542    fn discover_entry_points_with_warnings(
2543        config: &ResolvedConfig,
2544        files: &[DiscoveredFile],
2545    ) -> EntryPointDiscovery {
2546        let root_pkg = fallow_config::load_dir_package_json(&config.root);
2547        let packages = collect_workspace_packages(&config.root, root_pkg.as_ref(), &[]);
2548        let runtime_seeds = workspace_runtime_script_seeds(&packages);
2549        discover_root_entry_points(
2550            config,
2551            files,
2552            root_pkg.as_ref(),
2553            true,
2554            ScriptWorkspaces {
2555                packages: &packages,
2556                project_root: &config.root,
2557                runtime_seeds: &runtime_seeds,
2558                discovered: None,
2559            },
2560        )
2561    }
2562
2563    /// The discovery of one workspace package, without other packages.
2564    fn discover_workspace_entry_points_with_warnings(
2565        ws_root: &Path,
2566        config: &ResolvedConfig,
2567        files: &[DiscoveredFile],
2568    ) -> EntryPointDiscovery {
2569        let pkg = fallow_config::load_dir_package_json(ws_root);
2570        let packages = std::sync::Arc::default();
2571        discover_workspace_package_entry_points(
2572            ws_root,
2573            files,
2574            pkg.as_ref(),
2575            IgnoredCommandEntries::new(&config.ignore_command_entries),
2576            ScriptWorkspaces {
2577                packages: &packages,
2578                project_root: &config.root,
2579                runtime_seeds: &RuntimeScriptSeeds::default(),
2580                discovered: None,
2581            },
2582        )
2583    }
2584
2585    fn workspace(root: &Path, dir: &str, name: &str) -> fallow_config::WorkspaceInfo {
2586        fallow_config::WorkspaceInfo {
2587            root: root.join(dir),
2588            name: name.to_string(),
2589            is_internal_dependency: false,
2590        }
2591    }
2592
2593    #[test]
2594    fn root_entry_points_use_package_json_scripts() {
2595        let dir = tempfile::tempdir().expect("tempdir");
2596        let root = dir.path();
2597        std::fs::create_dir_all(root.join("scripts")).expect("scripts dir");
2598        std::fs::write(root.join("scripts/build.ts"), "export const build = true;")
2599            .expect("script file");
2600        std::fs::write(
2601            root.join("package.json"),
2602            r#"{"scripts":{"build":"tsx scripts/build.ts"}}"#,
2603        )
2604        .expect("package file");
2605        let config = config_for(root);
2606        let files = [discovered(root, "scripts/build.ts", 0)];
2607
2608        let entries = discover_entry_points(&config, &files, &[]);
2609
2610        assert_eq!(entries.len(), 1);
2611        assert!(entries[0].path.ends_with("scripts/build.ts"));
2612        assert!(matches!(
2613            entries[0].source,
2614            EntryPointSource::PackageJsonScript { .. }
2615        ));
2616    }
2617
2618    #[test]
2619    fn build_script_is_support_while_default_index_stays_runtime() {
2620        let dir = tempfile::tempdir().expect("tempdir");
2621        let root = dir.path();
2622        std::fs::create_dir_all(root.join("scripts")).expect("scripts dir");
2623        std::fs::create_dir_all(root.join("src")).expect("src dir");
2624        std::fs::write(root.join("scripts/build.ts"), "export const build = true;")
2625            .expect("script file");
2626        std::fs::write(root.join("src/index.ts"), "export const app = true;").expect("index file");
2627        std::fs::write(
2628            root.join("package.json"),
2629            r#"{"scripts":{"build":"tsx scripts/build.ts"}}"#,
2630        )
2631        .expect("package file");
2632        let config = config_for(root);
2633        let files = [
2634            discovered(root, "scripts/build.ts", 0),
2635            discovered(root, "src/index.ts", 1),
2636        ];
2637
2638        let discovery = discover_entry_points_with_warnings(&config, &files);
2639
2640        assert_eq!(discovery.entries.len(), 1);
2641        assert!(discovery.entries[0].path.ends_with("src/index.ts"));
2642        assert_eq!(discovery.support_entries.len(), 1);
2643        assert!(
2644            discovery.support_entries[0]
2645                .path
2646                .ends_with("scripts/build.ts")
2647        );
2648    }
2649
2650    #[test]
2651    fn indirect_quoted_start_script_stays_runtime() {
2652        let dir = tempfile::tempdir().expect("tempdir");
2653        let root = dir.path();
2654        std::fs::create_dir_all(root.join("src")).expect("src dir");
2655        std::fs::write(root.join("src/server.ts"), "export const server = true;")
2656            .expect("server file");
2657        std::fs::write(
2658            root.join("package.json"),
2659            r#"{"scripts":{"start":"npm run serve","serve":"node 'src/server.ts'"}}"#,
2660        )
2661        .expect("package file");
2662        let config = config_for(root);
2663        let files = [discovered(root, "src/server.ts", 0)];
2664
2665        let discovery = discover_entry_points_with_warnings(&config, &files);
2666
2667        assert_eq!(discovery.entries.len(), 1);
2668        assert!(discovery.entries[0].path.ends_with("src/server.ts"));
2669        assert!(discovery.support_entries.is_empty());
2670    }
2671
2672    #[test]
2673    fn indirect_start_script_includes_its_lifecycle_hooks() {
2674        let dir = tempfile::tempdir().expect("tempdir");
2675        let root = dir.path();
2676        std::fs::create_dir_all(root.join("src")).expect("src dir");
2677        for file in ["pre.ts", "server.ts", "post.ts"] {
2678            std::fs::write(root.join("src").join(file), "export const value = true;")
2679                .expect("runtime file");
2680        }
2681        std::fs::write(
2682            root.join("package.json"),
2683            r#"{"scripts":{"start":"npm run serve","preserve":"node src/pre.ts","serve":"node src/server.ts","postserve":"node src/post.ts"}}"#,
2684        )
2685        .expect("package file");
2686        let config = config_for(root);
2687        let files = [
2688            discovered(root, "src/pre.ts", 0),
2689            discovered(root, "src/server.ts", 1),
2690            discovered(root, "src/post.ts", 2),
2691        ];
2692
2693        let discovery = discover_entry_points_with_warnings(&config, &files);
2694
2695        assert_eq!(discovery.entries.len(), 3);
2696        assert!(discovery.support_entries.is_empty());
2697    }
2698
2699    #[test]
2700    #[expect(
2701        clippy::disallowed_types,
2702        reason = "test input matches the serde-deserialized package.json scripts map"
2703    )]
2704    fn start_does_not_recursively_invent_hooks_for_lifecycle_hooks() {
2705        let scripts = std::collections::HashMap::from([
2706            ("preprestart".to_string(), "node src/tool.ts".to_string()),
2707            ("prestart".to_string(), "node src/pre.ts".to_string()),
2708            ("start".to_string(), "node src/server.ts".to_string()),
2709            ("poststart".to_string(), "node src/post.ts".to_string()),
2710            ("postpoststart".to_string(), "node src/tool.ts".to_string()),
2711        ]);
2712
2713        let runtime = runtime_package_script_names(&scripts);
2714
2715        assert_eq!(
2716            runtime,
2717            FxHashSet::from_iter([
2718                "prestart".to_string(),
2719                "start".to_string(),
2720                "poststart".to_string(),
2721            ])
2722        );
2723    }
2724
2725    #[test]
2726    fn bun_build_script_remains_support_entry() {
2727        let dir = tempfile::tempdir().expect("tempdir");
2728        let root = dir.path();
2729        std::fs::create_dir_all(root.join("scripts")).expect("scripts dir");
2730        std::fs::write(root.join("scripts/build.ts"), "export const build = true;")
2731            .expect("build file");
2732        std::fs::write(
2733            root.join("package.json"),
2734            r#"{"scripts":{"build":"bun scripts/build.ts"}}"#,
2735        )
2736        .expect("package file");
2737        let config = config_for(root);
2738        let files = [discovered(root, "scripts/build.ts", 0)];
2739
2740        let discovery = discover_entry_points_with_warnings(&config, &files);
2741
2742        assert!(discovery.entries.is_empty());
2743        assert_eq!(discovery.support_entries.len(), 1);
2744    }
2745
2746    #[test]
2747    fn start_script_config_remains_support_only() {
2748        let dir = tempfile::tempdir().expect("tempdir");
2749        let root = dir.path();
2750        std::fs::write(root.join("vite.config.ts"), "export default {};").expect("config file");
2751        std::fs::write(
2752            root.join("package.json"),
2753            r#"{"scripts":{"start":"vite --config vite.config.ts"}}"#,
2754        )
2755        .expect("package file");
2756        let config = config_for(root);
2757        let files = [discovered(root, "vite.config.ts", 0)];
2758
2759        let discovery = discover_entry_points_with_warnings(&config, &files);
2760
2761        assert!(discovery.entries.is_empty());
2762        assert_eq!(discovery.support_entries.len(), 1);
2763        assert!(
2764            discovery.support_entries[0]
2765                .path
2766                .ends_with("vite.config.ts")
2767        );
2768    }
2769
2770    #[test]
2771    fn manifest_entry_remains_runtime_when_build_script_references_same_path() {
2772        let dir = tempfile::tempdir().expect("tempdir");
2773        let root = dir.path();
2774        std::fs::create_dir_all(root.join("src")).expect("src dir");
2775        std::fs::write(root.join("src/index.ts"), "export const app = true;").expect("index file");
2776        std::fs::write(
2777            root.join("package.json"),
2778            r#"{"main":"src/index.ts","scripts":{"build":"tsx src/index.ts"}}"#,
2779        )
2780        .expect("package file");
2781        let config = config_for(root);
2782        let files = [discovered(root, "src/index.ts", 0)];
2783
2784        let discovery = discover_entry_points_with_warnings(&config, &files);
2785
2786        assert_eq!(discovery.entries.len(), 1);
2787        assert!(discovery.entries[0].path.ends_with("src/index.ts"));
2788    }
2789
2790    #[test]
2791    fn workspace_build_script_is_support_with_runtime_fallback() {
2792        let dir = tempfile::tempdir().expect("tempdir");
2793        let root = dir.path();
2794        let workspace = root.join("packages/app");
2795        std::fs::create_dir_all(workspace.join("scripts")).expect("scripts dir");
2796        std::fs::create_dir_all(workspace.join("src")).expect("src dir");
2797        std::fs::write(
2798            workspace.join("scripts/build.ts"),
2799            "export const build = true;",
2800        )
2801        .expect("script file");
2802        std::fs::write(workspace.join("src/index.ts"), "export const app = true;")
2803            .expect("index file");
2804        std::fs::write(
2805            workspace.join("package.json"),
2806            r#"{"name":"app","scripts":{"build":"tsx scripts/build.ts"}}"#,
2807        )
2808        .expect("package file");
2809        let files = [
2810            discovered(root, "packages/app/scripts/build.ts", 0),
2811            discovered(root, "packages/app/src/index.ts", 1),
2812        ];
2813
2814        let discovery =
2815            discover_workspace_entry_points_with_warnings(&workspace, &config_for(root), &files);
2816
2817        assert_eq!(discovery.entries.len(), 1);
2818        assert!(discovery.entries[0].path.ends_with("src/index.ts"));
2819        assert_eq!(discovery.support_entries.len(), 1);
2820        assert!(
2821            discovery.support_entries[0]
2822                .path
2823                .ends_with("scripts/build.ts")
2824        );
2825    }
2826
2827    #[test]
2828    fn workspace_script_selected_by_root_start_is_runtime() {
2829        let dir = tempfile::tempdir().expect("tempdir");
2830        let root = dir.path();
2831        let workspace = root.join("packages/api");
2832        std::fs::create_dir_all(workspace.join("src")).expect("src dir");
2833        std::fs::write(workspace.join("src/server.ts"), "export const app = true;")
2834            .expect("server file");
2835        let workspace_pkg: PackageJson = serde_json::from_str(
2836            r#"{"name":"@scope/api","scripts":{"serve":"node src/server.ts"}}"#,
2837        )
2838        .expect("workspace package");
2839        let files = [discovered(root, "packages/api/src/server.ts", 0)];
2840        let runtime_seeds = RuntimeScriptSeeds::from_iter([(
2841            "packages/api".to_string(),
2842            FxHashSet::from_iter(["serve".to_string()]),
2843        )]);
2844
2845        let packages = std::sync::Arc::default();
2846        let discovery = discover_workspace_package_entry_points(
2847            &workspace,
2848            &files,
2849            Some(&workspace_pkg),
2850            IgnoredCommandEntries::NONE,
2851            ScriptWorkspaces {
2852                packages: &packages,
2853                project_root: root,
2854                runtime_seeds: &runtime_seeds,
2855                discovered: None,
2856            },
2857        );
2858
2859        assert_eq!(discovery.entries.len(), 1);
2860        assert!(discovery.entries[0].path.ends_with("src/server.ts"));
2861        assert!(discovery.support_entries.is_empty());
2862    }
2863
2864    #[test]
2865    fn scripts_that_select_workspace_packages_add_entries_in_each_pass() {
2866        let dir = tempfile::tempdir().expect("tempdir");
2867        let root = dir.path();
2868        for file in [
2869            "packages/web/scripts/root-start.ts",
2870            "packages/web/scripts/api-start.ts",
2871            "packages/web/scripts/gen.ts",
2872        ] {
2873            let path = root.join(file);
2874            std::fs::create_dir_all(path.parent().expect("parent")).expect("dir");
2875            std::fs::write(path, "export const run = true;").expect("script file");
2876        }
2877        let root_pkg: PackageJson = serde_json::from_str(
2878            r#"{"scripts":{"start":"yarn workspace web node scripts/root-start.ts"}}"#,
2879        )
2880        .expect("root package");
2881        let api_pkg: PackageJson = serde_json::from_str(
2882            r#"{
2883                "name": "api",
2884                "scripts": {
2885                    "start": "yarn workspace web node scripts/api-start.ts",
2886                    "gen": "pnpm -r exec tsx scripts/gen.ts"
2887                }
2888            }"#,
2889        )
2890        .expect("api package");
2891        let mut packages = crate::scripts::WorkspacePackages::default();
2892        packages.add("web", "packages/web", None);
2893        packages.add("api", "packages/api", api_pkg.scripts.as_ref());
2894        let packages = std::sync::Arc::new(packages);
2895        let runtime_seeds = RuntimeScriptSeeds::default();
2896        let workspaces = ScriptWorkspaces {
2897            packages: &packages,
2898            project_root: root,
2899            runtime_seeds: &runtime_seeds,
2900            discovered: None,
2901        };
2902        let config = config_for(root);
2903
2904        let root_discovery =
2905            discover_root_entry_points(&config, &[], Some(&root_pkg), false, workspaces);
2906        assert!(
2907            root_discovery
2908                .entries
2909                .iter()
2910                .any(|entry| entry.path.ends_with("packages/web/scripts/root-start.ts")),
2911            "a root start script that selects a package adds a runtime entry: {:?}",
2912            root_discovery.entries
2913        );
2914
2915        let api_discovery = discover_workspace_package_entry_points(
2916            &root.join("packages/api"),
2917            &[],
2918            Some(&api_pkg),
2919            IgnoredCommandEntries::NONE,
2920            workspaces,
2921        );
2922        assert!(
2923            api_discovery
2924                .entries
2925                .iter()
2926                .any(|entry| entry.path.ends_with("packages/web/scripts/api-start.ts")),
2927            "a package start script that selects another package adds a runtime entry: {:?}",
2928            api_discovery.entries
2929        );
2930        assert!(
2931            api_discovery
2932                .support_entries
2933                .iter()
2934                .any(|entry| entry.path.ends_with("packages/web/scripts/gen.ts")),
2935            "`pnpm -r exec` adds the file of each package where it exists: {:?}",
2936            api_discovery.support_entries
2937        );
2938        assert!(
2939            api_discovery.skipped_entries.is_empty(),
2940            "a file outside the calling package resolves from the project root: {:?}",
2941            api_discovery.skipped_entries
2942        );
2943    }
2944
2945    #[test]
2946    fn workspace_script_selection_does_not_promote_same_named_root_script() {
2947        let dir = tempfile::tempdir().expect("tempdir");
2948        let root = dir.path();
2949        let root_pkg: PackageJson = serde_json::from_str(
2950            r#"{
2951                "scripts": {
2952                    "start": "pnpm --filter=@scope/api run serve",
2953                    "serve": "node src/unrelated.ts"
2954                }
2955            }"#,
2956        )
2957        .expect("root package");
2958        let api_pkg: PackageJson = serde_json::from_str(
2959            r#"{"name":"@scope/api","scripts":{"serve":"node src/server.ts"}}"#,
2960        )
2961        .expect("api package");
2962        let workspace_pkgs = vec![(workspace(root, "packages/api", "@scope/api"), api_pkg)];
2963        let scripts = root_pkg.scripts.as_ref().expect("root scripts");
2964
2965        let runtime = runtime_package_script_names(scripts);
2966        let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
2967        let workspace_seeds = workspace_runtime_script_seeds(&packages);
2968
2969        assert_eq!(runtime, FxHashSet::from_iter(["start".to_string()]));
2970        assert_eq!(
2971            workspace_seeds,
2972            RuntimeScriptSeeds::from_iter([(
2973                "packages/api".to_string(),
2974                FxHashSet::from_iter(["serve".to_string()])
2975            )])
2976        );
2977    }
2978
2979    #[test]
2980    fn workspace_runtime_script_seeds_follow_transitive_workspace_calls() {
2981        let dir = tempfile::tempdir().expect("tempdir");
2982        let root = dir.path();
2983        let root_pkg: PackageJson =
2984            serde_json::from_str(r#"{"scripts":{"start":"pnpm --filter @scope/api run serve"}}"#)
2985                .expect("root package");
2986        let api_pkg: PackageJson = serde_json::from_str(
2987            r#"{"name":"@scope/api","scripts":{"serve":"npm --workspace ../worker run work"}}"#,
2988        )
2989        .expect("api package");
2990        let worker_pkg: PackageJson = serde_json::from_str(
2991            r#"{"name":"@scope/worker","scripts":{"prework":"node pre.ts","work":"node worker.ts"}}"#,
2992        )
2993        .expect("worker package");
2994        let workspace_pkgs = vec![
2995            (workspace(root, "packages/api", "@scope/api"), api_pkg),
2996            (
2997                workspace(root, "packages/worker", "@scope/worker"),
2998                worker_pkg,
2999            ),
3000        ];
3001
3002        let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
3003        let seeds = workspace_runtime_script_seeds(&packages);
3004
3005        assert_eq!(
3006            seeds.get("packages/api"),
3007            Some(&FxHashSet::from_iter(["serve".to_string()]))
3008        );
3009        assert_eq!(
3010            seeds.get("packages/worker"),
3011            Some(&FxHashSet::from_iter([
3012                "prework".to_string(),
3013                "work".to_string(),
3014            ]))
3015        );
3016    }
3017
3018    #[test]
3019    fn every_selection_form_seeds_the_runtime_scripts_of_the_selected_packages() {
3020        let dir = tempfile::tempdir().expect("tempdir");
3021        let root = dir.path();
3022        let web_pkg: PackageJson = serde_json::from_str(
3023            r#"{"name":"web","scripts":{"preserve":"node pre.ts","serve":"node web.ts"}}"#,
3024        )
3025        .expect("web package");
3026        let api_pkg: PackageJson =
3027            serde_json::from_str(r#"{"name":"api","scripts":{"serve":"node api.ts"}}"#)
3028                .expect("api package");
3029        let workspace_pkgs = vec![
3030            (workspace(root, "packages/web", "web"), web_pkg),
3031            (workspace(root, "packages/api", "api"), api_pkg),
3032        ];
3033        let web_serve = FxHashSet::from_iter(["preserve".to_string(), "serve".to_string()]);
3034        let api_serve = FxHashSet::from_iter(["serve".to_string()]);
3035        for (start, expected) in [
3036            (
3037                "pnpm -r run serve",
3038                vec![("packages/api", &api_serve), ("packages/web", &web_serve)],
3039            ),
3040            (
3041                "pnpm -C packages/web run serve",
3042                vec![("packages/web", &web_serve)],
3043            ),
3044            (
3045                "pnpm --dir=packages/web serve",
3046                vec![("packages/web", &web_serve)],
3047            ),
3048            (
3049                "npm --prefix packages/web run serve",
3050                vec![("packages/web", &web_serve)],
3051            ),
3052            (
3053                "yarn --cwd packages/web serve",
3054                vec![("packages/web", &web_serve)],
3055            ),
3056            (
3057                "yarn workspaces foreach -A run serve",
3058                vec![("packages/api", &api_serve), ("packages/web", &web_serve)],
3059            ),
3060            (
3061                "pnpm --filter './packages/*' --filter '!api' run serve",
3062                vec![("packages/web", &web_serve)],
3063            ),
3064        ] {
3065            let root_pkg: PackageJson =
3066                serde_json::from_str(&format!(r#"{{"scripts":{{"start":"{start}"}}}}"#))
3067                    .expect("root package");
3068            let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
3069            let seeds = workspace_runtime_script_seeds(&packages);
3070            let expected: RuntimeScriptSeeds = expected
3071                .into_iter()
3072                .map(|(dir, names)| (dir.to_string(), names.clone()))
3073                .collect();
3074            assert_eq!(seeds, expected, "`{start}`");
3075        }
3076    }
3077
3078    #[test]
3079    fn a_workspace_start_script_seeds_a_script_of_the_root_package() {
3080        let dir = tempfile::tempdir().expect("tempdir");
3081        let root = dir.path();
3082        let root_pkg: PackageJson =
3083            serde_json::from_str(r#"{"name":"monorepo","scripts":{"serve":"node server.ts"}}"#)
3084                .expect("root package");
3085        let web_pkg: PackageJson =
3086            serde_json::from_str(r#"{"name":"web","scripts":{"start":"pnpm -w run serve"}}"#)
3087                .expect("web package");
3088        let workspace_pkgs = vec![(workspace(root, "packages/web", "web"), web_pkg)];
3089
3090        let packages = collect_workspace_packages(root, Some(&root_pkg), &workspace_pkgs);
3091        let seeds = workspace_runtime_script_seeds(&packages);
3092
3093        assert_eq!(
3094            seeds,
3095            RuntimeScriptSeeds::from_iter([(
3096                String::new(),
3097                FxHashSet::from_iter(["serve".to_string()])
3098            )])
3099        );
3100    }
3101
3102    #[test]
3103    fn root_entry_points_fall_back_to_default_index() {
3104        let dir = tempfile::tempdir().expect("tempdir");
3105        let root = dir.path();
3106        std::fs::create_dir_all(root.join("src")).expect("src dir");
3107        std::fs::write(root.join("src/index.ts"), "export const main = true;").expect("index file");
3108        let config = config_for(root);
3109        let files = [discovered(root, "src/index.ts", 0)];
3110
3111        let entries = discover_entry_points(&config, &files, &[]);
3112
3113        assert_eq!(entries.len(), 1);
3114        assert!(entries[0].path.ends_with("src/index.ts"));
3115        assert!(matches!(entries[0].source, EntryPointSource::DefaultIndex));
3116    }
3117
3118    #[test]
3119    fn default_index_matchers_preserve_patterns_and_are_shared() {
3120        let matchers = default_index_matchers();
3121        for path in [
3122            "src/index.ts",
3123            "src/index.tsx",
3124            "src/index.js",
3125            "src/index.jsx",
3126            "src/main.ts",
3127            "src/main.tsx",
3128            "src/main.js",
3129            "src/main.jsx",
3130            "index.ts",
3131            "index.tsx",
3132            "index.js",
3133            "index.jsx",
3134            "main.ts",
3135            "main.tsx",
3136            "main.js",
3137            "main.jsx",
3138        ] {
3139            assert!(
3140                matchers.is_match(path),
3141                "default index did not match {path}"
3142            );
3143        }
3144        for path in [
3145            "src/index.mts",
3146            "src/nested/index.ts",
3147            "packages/app/src/index.ts",
3148            "custom-entry.ts",
3149        ] {
3150            assert!(!matchers.is_match(path), "non-default index matched {path}");
3151        }
3152
3153        std::thread::scope(|scope| {
3154            let handles = std::iter::repeat_with(|| scope.spawn(default_index_matchers))
3155                .take(4)
3156                .collect::<Vec<_>>();
3157            for handle in handles {
3158                let from_thread = handle.join().expect("fallback matcher thread");
3159                assert!(std::ptr::eq(matchers, from_thread));
3160            }
3161        });
3162    }
3163
3164    #[test]
3165    fn workspace_entry_points_use_workspace_package_json() {
3166        let dir = tempfile::tempdir().expect("tempdir");
3167        let root = dir.path();
3168        let ws_root = root.join("packages/app");
3169        std::fs::create_dir_all(ws_root.join("src")).expect("workspace src dir");
3170        std::fs::write(ws_root.join("src/main.ts"), "export const main = true;")
3171            .expect("workspace main");
3172        std::fs::write(ws_root.join("package.json"), r#"{"main":"src/main.ts"}"#)
3173            .expect("workspace package file");
3174        let config = config_for(root);
3175        let files = [discovered(root, "packages/app/src/main.ts", 0)];
3176
3177        let entries =
3178            discover_entry_points(&config, &files, &[workspace(root, "packages/app", "app")]);
3179
3180        assert_eq!(entries.len(), 1);
3181        assert!(entries[0].path.ends_with("packages/app/src/main.ts"));
3182        assert!(matches!(
3183            entries[0].source,
3184            EntryPointSource::PackageJsonMain
3185        ));
3186    }
3187
3188    #[test]
3189    fn workspace_entry_paths_have_no_current_dir_segment() {
3190        let dir = tempfile::tempdir().expect("tempdir");
3191        let root = dir.path();
3192        let ws_root = root.join("packages/a");
3193        std::fs::create_dir_all(&ws_root).expect("workspace dir");
3194        std::fs::write(ws_root.join("index.js"), "exports.a = 1;").expect("index");
3195        std::fs::write(ws_root.join("wrapper.mjs"), "export const a = 1;").expect("wrapper");
3196        std::fs::write(
3197            ws_root.join("package.json"),
3198            r#"{"main":"./index.js","exports":{"import":"./wrapper.mjs","require":"./index.js"}}"#,
3199        )
3200        .expect("workspace package file");
3201        let config = config_for(root);
3202        let files = [
3203            discovered(root, "packages/a/index.js", 0),
3204            discovered(root, "packages/a/wrapper.mjs", 1),
3205        ];
3206
3207        let entries = discover_entry_points(&config, &files, &[workspace(root, "packages/a", "a")]);
3208
3209        let mut paths: Vec<String> = entries
3210            .iter()
3211            .map(|entry| {
3212                entry
3213                    .path
3214                    .strip_prefix(root)
3215                    .expect("entry inside root")
3216                    .to_string_lossy()
3217                    .replace('\\', "/")
3218            })
3219            .collect();
3220        paths.sort();
3221        assert_eq!(paths, vec!["packages/a/index.js", "packages/a/wrapper.mjs"]);
3222    }
3223
3224    #[test]
3225    fn root_wildcard_export_skips_files_of_nested_packages() {
3226        let dir = tempfile::tempdir().expect("tempdir");
3227        let root = dir.path();
3228        std::fs::create_dir_all(root.join("src")).expect("src dir");
3229        std::fs::create_dir_all(root.join("examples/demo/src")).expect("example dir");
3230        std::fs::write(root.join("src/vanilla.ts"), "export const v = 1;").expect("source");
3231        std::fs::write(
3232            root.join("examples/demo/src/util.js"),
3233            "export const u = 1;",
3234        )
3235        .expect("example file");
3236        std::fs::write(
3237            root.join("examples/demo/package.json"),
3238            r#"{"name":"demo"}"#,
3239        )
3240        .expect("example package file");
3241        std::fs::write(root.join("package.json"), r#"{"exports":{"./*":"./*.js"}}"#)
3242            .expect("package file");
3243        let config = config_for(root);
3244        let files = [
3245            discovered(root, "examples/demo/src/util.js", 0),
3246            discovered(root, "src/vanilla.ts", 1),
3247        ];
3248
3249        let entries = discover_entry_points(&config, &files, &[]);
3250
3251        let paths: Vec<PathBuf> = entries.iter().map(|entry| entry.path.clone()).collect();
3252        assert_eq!(paths, vec![root.join("src/vanilla.ts")]);
3253    }
3254
3255    #[test]
3256    fn root_wildcard_export_of_build_output_maps_to_source() {
3257        let dir = tempfile::tempdir().expect("tempdir");
3258        let root = dir.path();
3259        std::fs::create_dir_all(root.join("src/middleware")).expect("src dir");
3260        for file in [
3261            "src/index.ts",
3262            "src/middleware.ts",
3263            "src/middleware/immer.ts",
3264        ] {
3265            std::fs::write(root.join(file), "export const value = 1;").expect("source file");
3266        }
3267        std::fs::write(
3268            root.join("package.json"),
3269            r#"{"main":"./index.js","exports":{".":{"default":"./index.js"},"./*":{"import":"./esm/*.mjs","default":"./*.js"}}}"#,
3270        )
3271        .expect("package file");
3272        let config = config_for(root);
3273        let files = [
3274            discovered(root, "src/index.ts", 0),
3275            discovered(root, "src/middleware.ts", 1),
3276            discovered(root, "src/middleware/immer.ts", 2),
3277        ];
3278
3279        let entries = discover_entry_points(&config, &files, &[]);
3280
3281        let mut paths: Vec<String> = entries
3282            .iter()
3283            .map(|entry| {
3284                entry
3285                    .path
3286                    .strip_prefix(root)
3287                    .expect("entry inside root")
3288                    .to_string_lossy()
3289                    .replace('\\', "/")
3290            })
3291            .collect();
3292        paths.sort();
3293        paths.dedup();
3294        assert_eq!(
3295            paths,
3296            vec![
3297                "src/index.ts",
3298                "src/middleware.ts",
3299                "src/middleware/immer.ts"
3300            ]
3301        );
3302    }
3303}