source-config.ts

Anchor the baseline exclusion globs below a discovery base directory.

Anchoring is what preserves the escape hatch at discovery time: the ignores for base .hidden/src are .hidden/src/**\/node_modules/** etc., which don't match the base's own dot segment. '' anchors at the project root. Used as glob ignore by globFiles (per include-pattern base) and discoverFromExports (below the source dir).

Create complete, normalized, validated source options from project root and optional overrides.

Merges overrides with DEFAULT_SOURCE_OPTIONS, then normalizes via normalizeSourceOptions — so the returned object always has an absolute projectRoot, slash-stripped path entries, and an explicit sourceRoot (auto-derived for multi-path layouts). Throws on validation failure.

Create source options with include-pattern widening applied.

The include-aware form of createSourceOptions, used by the discovery entry points (analyzeFromFiles, the Vite plugin): builds options from overrides, then unions each include pattern's static base into sourcePaths via widenSourcePathsForInclude so include-discovered files pass the query-time source gate. When the set widens, options are rebuilt from the original overrides so sourceRoot derivation and validation (including the projectRoot-escape throw) see the final set — re-normalizing the first result would bake a derived sourceRoot in as if explicit and fail validation against the widened bases. Owning both steps here keeps that original-overrides requirement an implementation detail instead of a caller contract.

Logs when a pattern contributes the '' base: a root-crossing glob ('**\/*.ts') or a literal root file ('vite.config.ts') scopes the whole project root as source — the baseline exclusions (node_modules, dot-directories) shrink that cliff but don't remove it, so the widening leaves a trace instead of happening silently.

Default partial options for standard SvelteKit library structure.

Does not include projectRoot — use createSourceOptions to create complete options with your project root.

exclude is the single source of truth for filtering: globs applied at both discovery time (by globFiles/discoverFromExports) and analysis time (by isSource() against project-root-relative paths).

Exclude patterns as accepted by the override surfaces (createSourceOptions, analyzeFromFiles, the Vite plugin — not the CLI, whose --exclude is array-only).

An array replaces DEFAULT_SOURCE_OPTIONS.exclude wholesale; the callback form receives a fresh copy of those defaults and returns the list to use, so extending them doesn't require restating them:

The callback runs at most once per built options object (include-pattern widening rebuilds options from the already-resolved array). Resolved to a plain array before normalization; ModuleSourceOptions.exclude never carries the function form.

Extract dependencies and dependents for a module from source file info.

Filters to only include source modules (excludes external packages, node_modules, tests). Returns sorted arrays of module paths (relative to sourceRoot) for deterministic output.

Native paths in sourceFile.dependencies/dependents are accepted — isSource and extractPath posixify their inputs, so direct callers with hand-built input need not pre-normalize.

Accepts SourceFileInfo plus an optional dependents field — the public input type carries only dependencies (caller-supplied opt-in), while dependents is computed downstream by computeDependents and flows through as an enriched shape.

Extract module path relative to source root from absolute source ID.

Uses proper path semantics: strips projectRoot/sourceRoot/ prefix.

Get the effective sourceRoot from options.

Returns sourceRoot if provided, otherwise:

• Single sourcePath: returns that path
• Multiple sourcePaths: derives the longest common directory prefix

Whether a base-relative path contains an always-excluded directory segment.

The always-on baseline: node_modules directories and dot-directories (.svelte-kit, .git, .cache, …) are never source. Matched against the path *relative to the matched source path*, not the project root — so an explicit dot-dir source path (sourcePaths: ['.hidden/src']) still works: the dot segment sits in the base, not the remainder. That relativity is the opt-out; there is no flag. Deliberately only these two families — dist/build/coverage are ordinary names a project can legitimately keep source in, and over-excluding fails silently.

Only directory segments are checked; the final segment (the file itself) is not, so a dotfile like .config.ts inside a source dir passes.

Deliberately NOT part of DEFAULT_SOURCE_OPTIONS.exclude: user exclude replaces the defaults wholesale and would silently strip the baseline. baselineExcludesForBase is the discovery-time glob form.

Static base directory of a discovery include pattern.

picomatch.scan().base for glob patterns ('src/other/**\/*.ts' → 'src/other'); a literal non-glob pattern names a file, so it contributes its directory ('src/foo.ts' → 'src', a root file → ''); a negated pattern has no base (null). Shared by widenSourcePathsForInclude (scope widening), globFiles (anchoring the baseline exclusions), and createSourceOptionsWithInclude (detecting root-scoping patterns to log).

Patterns are expected projectRoot-relative — the discovery seams (createSourceOptionsWithInclude, discoverSourceFiles) run normalizeIncludePatterns first, which relativizes in-root absolute patterns and throws on out-of-root ones, so no absolute pattern reaches the base scan through the public entry points.

Check if a path is an analyzable source file.

Combines all filtering: source directory paths, the always-on baseline (node_modules + dot-directories below the matched source path — see hasBaselineExcludedSegment), exclude globs, and analyzer availability. This is the single check for whether a file should be included in library analysis.

Uses proper path semantics with startsWith matching against projectRoot/sourcePath/. No heuristics needed — nested directories are correctly excluded by the prefix check.

Order is sourceDir-then-exclude: the prefix check guarantees the path lives under projectRoot before relativization, so relative() always produces a clean glob-shaped string for the matcher. Files outside projectRoot (rare; would require monorepo path mapping) short-circuit at the prefix check before reaching the matcher.

Configuration for module source detection and path extraction.

Uses proper path semantics with projectRoot as the base for all path operations. Paths are matched using startsWith rather than substring search, which correctly handles nested directories without special heuristics.

Normalize discovery include patterns to projectRoot-relative form.

The include-pattern counterpart of normalizeSourceOptions' absolute-entry handling: in-root absolute patterns relativize, out-of-root ones throw, relative ones pass through (see normalizeGlobPattern; exclude gets the same treatment inside normalizeSourceOptions). Applied by the discovery seams (createSourceOptionsWithInclude, discoverSourceFiles) so widening, the anchored baseline ignores, and the glob itself all see canonical relative patterns; projectRoot must be normalized (absolute POSIX, no trailing slash) — pass ModuleSourceOptions.projectRoot.

Normalize and validate ModuleSourceOptions, returning a new options object.

Normalization:

• projectRoot resolved to absolute via path.resolve (relative paths resolve against cwd)
• Trailing slash stripped from projectRoot
• sourcePaths entries and sourceRoot resolved against projectRoot and stored root-relative: ./.. segments collapse (src/../lib → lib, . → ''), trailing slashes drop, and absolute entries inside the root relativize (matching loadFile's treatment of path inputs)
• exclude globs relativized when absolute inside the root (textual prefix strip, since glob metacharacters aren't path segments), so discovery's glob ignore and analysis-time isSource see the same relative pattern

Validation (after normalization):

1. No sourcePaths entry, sourceRoot, or absolute exclude glob resolves outside projectRoot (out-of-root modules are unrepresentable — module paths and diagnostics are project-root-relative; widened include bases funnel through here too; absolute out-of-root entries get a drop-the-leading-slash hint)
2. sourcePaths has at least one entry
3. sourceRoot (if provided and non-empty) is a prefix of all sourcePaths

When sourceRoot is omitted and multiple sourcePaths are provided, sourceRoot is auto-derived as their longest common path prefix. If the paths share no common prefix, the derived root is '' and extractPath produces project-relative module paths.

Returns a fresh object — the input is not mutated. Re-normalization produces a fresh identity, which naturally invalidates the excludeMatcherCache (keyed by options-object identity) without a separate "rebuild a fresh object" rule.

Default source options preset (without projectRoot).

Use with createSourceOptions to build complete options. Contains all ModuleSourceOptions fields except projectRoot, which is provided separately as the first argument to createSourceOptions.

Override surface for building ModuleSourceOptions: all fields optional, with exclude widened to ExcludeOption so callers can extend the default patterns instead of replacing them. Accepted by createSourceOptions / createSourceOptionsWithInclude and the option types layered on them (AnalyzeFromFilesOptions.sourceOptions, the Vite plugin's sourceOptions).

Union sourcePaths with the static base directories of explicit include patterns, so include-discovered files count as source at analysis time.

Discovery include globs can reach outside sourcePaths (`--include 'src/other/' under the default ['src/lib']`); without widening, the query-time source gate would drop those modules, and extractPath would have no root to relativize their paths against (its fallback is the absolute path). Each pattern contributes its static base (see includePatternBase). A root-crossing pattern (`'\/*.ts'`) contributes '', which scopes the whole project root as source.

Pure path-set logic — callers re-run createSourceOptions on the widened list so sourceRoot derivation and validation see the final set (an *explicit* sourceRoot that doesn't prefix a widened path fails that validation loudly rather than emitting absolute module paths; an out-of-root base hits the projectRoot-escape throw). Returns the input array identity when nothing widens. createSourceOptionsWithInclude wraps both steps for the common call shape.