svelte-docinfo 0.1.0

package/dist/exports.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Package.json exports field discovery for source files.
+ *
+ * Maps dist paths in package.json `exports` to source file paths,
+ * enabling zero-config file discovery without glob patterns.
+ *
+ * @see `source.ts` for `SourceFileInfo`
+ * @see `analyze.ts` for `analyzeFromFiles` (primary consumer)
+ *
+ * @module
+ */
+import type { SourceFileInfo } from './source.js';
+import type { Diagnostic } from './diagnostics.js';
+/**
+ * A parsed entry from package.json exports field.
+ */
+export interface ExportEntry {
+    /** The export specifier (e.g., `"."`, `"./*.js"`). */
+    specifier: string;
+    /** Whether the specifier contains a wildcard (`*`). */
+    isPattern: boolean;
+    /** Resolved dist paths by condition (e.g., `{types: "./dist/index.d.ts", default: "./dist/index.js"}`). */
+    conditions: Record<string, string>;
+}
+/**
+ * Options for `discoverFromExports`.
+ */
+export interface ExportsDiscoveryOptions {
+    /** Absolute path to project root. */
+    projectRoot: string;
+    /** Dist directory name relative to projectRoot. Default: `'dist'`. */
+    distDir?: string;
+    /** Source directory name relative to projectRoot. Default: `'src/lib'`. */
+    sourceDir?: string;
+    /** Glob patterns to exclude from discovered files. */
+    exclude?: Array<string>;
+}
+/**
+ * Result of discovering source files from package.json exports.
+ *
+ * Self-contained: includes both the discovered files and any error diagnostics
+ * (e.g., files that exist but could not be read).
+ */
+export interface ExportsDiscoveryResult {
+    /**
+     * Discovered source files, or `null` if no exports field found.
+     * Empty array means exports field exists but resolved no source files
+     * (likely a misconfigured dist-to-source mapping).
+     */
+    files: Array<SourceFileInfo> | null;
+    /** Error diagnostics for files that exist but could not be read. */
+    diagnostics: Array<Diagnostic>;
+}
+/**
+ * Result of reading and parsing package.json exports.
+ */
+export interface ParsedExports {
+    /** All parsed export entries. */
+    entries: Array<ExportEntry>;
+    /** Whether the package.json had an exports field. */
+    hasExports: boolean;
+}
+/**
+ * Read and parse the exports field from package.json.
+ *
+ * Handles all Node.js export formats: strings, objects with conditions,
+ * nested conditions, null exclusions, and wildcard patterns.
+ *
+ * @param projectRoot - absolute path to project root
+ * @returns parsed `ParsedExports`, or `{entries: [], hasExports: false}` if no exports field
+ */
+export declare const parsePackageExports: (projectRoot: string) => Promise<ParsedExports>;
+/**
+ * Map a dist file path to its source file path.
+ *
+ * Replaces the dist directory prefix with the source directory and maps
+ * file extensions based on the export condition.
+ *
+ * @param distPath - the dist path from exports (e.g., `"./dist/index.js"`)
+ * @param condition - the export condition (e.g., `"default"`, `"svelte"`, `"types"`)
+ * @param options - mapping configuration
+ * @returns source path relative to project root, or null if not mappable
+ */
+export declare const mapDistToSource: (distPath: string, condition: string, options: {
+    distDir: string;
+    sourceDir: string;
+}) => string | null;
+/**
+ * Discover source files using package.json exports field.
+ *
+ * Reads package.json, parses exports, maps dist paths to source paths,
+ * expands wildcard patterns, and loads file content.
+ *
+ * Returns `{files: null}` when no package.json or no exports field exists,
+ * signaling the caller to fall back to glob discovery. Returns `{files: []}`
+ * when exports exist but resolve no source files (likely misconfigured mapping).
+ *
+ * For concrete exports, maps directly to source paths and verifies existence.
+ * For wildcard exports, globs the source directory for matching files.
+ *
+ * @param options - discovery configuration
+ * @returns `ExportsDiscoveryResult` with discovered files and any error diagnostics
+ */
+export declare const discoverFromExports: (options: ExportsDiscoveryOptions) => Promise<ExportsDiscoveryResult>;
+//# sourceMappingURL=exports.d.ts.map

package/dist/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/exports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAMjD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAC;IACnB,2GAA2G;IAC3G,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACtC;;;;OAIG;IACH,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;IACpC,oEAAoE;IACpE,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC5B,qDAAqD;IACrD,UAAU,EAAE,OAAO,CAAC;CACpB;AASD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,aAAa,CA+BpF,CAAC;AAiCF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC3B,UAAU,MAAM,EAChB,WAAW,MAAM,EACjB,SAAS;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,KAC3C,MAAM,GAAG,IAwCX,CAAC;AAkBF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,GAC/B,SAAS,uBAAuB,KAC9B,OAAO,CAAC,sBAAsB,CA0DhC,CAAC"}

package/dist/exports.js

@@ -0,0 +1,274 @@
+/**
+ * Package.json exports field discovery for source files.
+ *
+ * Maps dist paths in package.json `exports` to source file paths,
+ * enabling zero-config file discovery without glob patterns.
+ *
+ * @see `source.ts` for `SourceFileInfo`
+ * @see `analyze.ts` for `analyzeFromFiles` (primary consumer)
+ *
+ * @module
+ */
+import { readFile, access } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { glob } from 'tinyglobby';
+import { toPosixPath } from './paths.js';
+import { MAX_FILE_CONCURRENCY, map_concurrent } from './concurrency.js';
+// ── Condition priority ───────────────────────────────────────────────────────
+/** Priority order for selecting the condition to use for source mapping. */
+const CONDITION_PRIORITY = ['svelte', 'default', 'import', 'require'];
+// ── Parsing ──────────────────────────────────────────────────────────────────
+/**
+ * Read and parse the exports field from package.json.
+ *
+ * Handles all Node.js export formats: strings, objects with conditions,
+ * nested conditions, null exclusions, and wildcard patterns.
+ *
+ * @param projectRoot - absolute path to project root
+ * @returns parsed `ParsedExports`, or `{entries: [], hasExports: false}` if no exports field
+ */
+export const parsePackageExports = async (projectRoot) => {
+    let pkg;
+    try {
+        const content = await readFile(join(projectRoot, 'package.json'), 'utf-8');
+        pkg = JSON.parse(content);
+    }
+    catch {
+        return { entries: [], hasExports: false };
+    }
+    const exportsField = pkg.exports;
+    if (!exportsField || typeof exportsField !== 'object') {
+        return { entries: [], hasExports: false };
+    }
+    const entries = [];
+    for (const [specifier, value] of Object.entries(exportsField)) {
+        // Skip package.json self-reference
+        if (specifier === './package.json')
+            continue;
+        const conditions = flattenConditions(value);
+        if (!conditions)
+            continue; // null exclusion or unparseable
+        entries.push({
+            specifier,
+            isPattern: specifier.includes('*'),
+            conditions,
+        });
+    }
+    return { entries, hasExports: true };
+};
+/**
+ * Flatten a possibly-nested export value into a flat conditions record.
+ *
+ * @returns flat conditions record, or null for explicit exclusions
+ */
+const flattenConditions = (value, prefix) => {
+    // Null = explicit exclusion
+    if (value === null || value === undefined)
+        return null;
+    // String = direct path (condition is the parent key, or 'default')
+    if (typeof value === 'string') {
+        return { [prefix ?? 'default']: value };
+    }
+    // Object = conditions map (possibly nested)
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        const result = {};
+        for (const [key, nested] of Object.entries(value)) {
+            const flattened = flattenConditions(nested, key);
+            if (flattened) {
+                Object.assign(result, flattened);
+            }
+        }
+        return Object.keys(result).length > 0 ? result : null;
+    }
+    return null;
+};
+// ── Source mapping ───────────────────────────────────────────────────────────
+/**
+ * Map a dist file path to its source file path.
+ *
+ * Replaces the dist directory prefix with the source directory and maps
+ * file extensions based on the export condition.
+ *
+ * @param distPath - the dist path from exports (e.g., `"./dist/index.js"`)
+ * @param condition - the export condition (e.g., `"default"`, `"svelte"`, `"types"`)
+ * @param options - mapping configuration
+ * @returns source path relative to project root, or null if not mappable
+ */
+export const mapDistToSource = (distPath, condition, options) => {
+    const { distDir, sourceDir } = options;
+    // Skip types-only conditions (not source files)
+    if (condition === 'types')
+        return null;
+    // Normalize: strip leading ./
+    const normalized = distPath.replace(/^\.\//, '');
+    // Must start with dist dir
+    if (!normalized.startsWith(distDir + '/'))
+        return null;
+    // Replace dist prefix with source prefix. Empty `sourceDir` (the
+    // no-common-prefix sourcePaths case where `getSourceRoot` returns `''`)
+    // means "source files live at project root" — emit `relPath` directly
+    // rather than `'/relPath'`, which would resolve as an absolute path and
+    // fail every `fileExists` check.
+    const relPath = normalized.slice(distDir.length + 1);
+    const sourceBase = sourceDir ? `${sourceDir}/${relPath}` : relPath;
+    // Extension mapping based on condition
+    if (condition === 'svelte') {
+        // Svelte condition → keep .svelte extension
+        return sourceBase;
+    }
+    if (sourceBase.endsWith('.css')) {
+        return sourceBase;
+    }
+    if (sourceBase.endsWith('.json')) {
+        return sourceBase;
+    }
+    // .js → .ts (primary), .js (fallback — handled by caller checking existence)
+    if (sourceBase.endsWith('.js')) {
+        return sourceBase.replace(/\.js$/, '.ts');
+    }
+    return sourceBase;
+};
+// ── Discovery ────────────────────────────────────────────────────────────────
+/**
+ * Select the best condition for source mapping from an export entry.
+ */
+const selectCondition = (conditions) => {
+    for (const key of CONDITION_PRIORITY) {
+        if (key in conditions)
+            return [key, conditions[key]];
+    }
+    // Fall back to first non-types condition
+    for (const [key, value] of Object.entries(conditions)) {
+        if (key !== 'types')
+            return [key, value];
+    }
+    return null;
+};
+/**
+ * Discover source files using package.json exports field.
+ *
+ * Reads package.json, parses exports, maps dist paths to source paths,
+ * expands wildcard patterns, and loads file content.
+ *
+ * Returns `{files: null}` when no package.json or no exports field exists,
+ * signaling the caller to fall back to glob discovery. Returns `{files: []}`
+ * when exports exist but resolve no source files (likely misconfigured mapping).
+ *
+ * For concrete exports, maps directly to source paths and verifies existence.
+ * For wildcard exports, globs the source directory for matching files.
+ *
+ * @param options - discovery configuration
+ * @returns `ExportsDiscoveryResult` with discovered files and any error diagnostics
+ */
+export const discoverFromExports = async (options) => {
+    const { projectRoot, distDir = 'dist', sourceDir = 'src/lib', exclude } = options;
+    const parsed = await parsePackageExports(projectRoot);
+    if (!parsed.hasExports)
+        return { files: null, diagnostics: [] };
+    const mappingOptions = { distDir, sourceDir };
+    const discovered = new Map(); // absolute path → relative source path
+    for (const entry of parsed.entries) {
+        const selected = selectCondition(entry.conditions);
+        if (!selected)
+            continue;
+        const [condition, distPath] = selected;
+        if (entry.isPattern) {
+            // Wildcard: expand via glob
+            await expandWildcardExport(distPath, condition, mappingOptions, projectRoot, exclude, discovered);
+        }
+        else {
+            // Concrete: map directly
+            await resolveConcreteExport(distPath, condition, mappingOptions, projectRoot, discovered);
+        }
+    }
+    if (discovered.size === 0)
+        return { files: [], diagnostics: [] };
+    // Load file contents with bounded concurrency to keep FD pressure under
+    // the typical ulimit on large projects. See `concurrency.ts`.
+    const diagnostics = [];
+    const absPaths = Array.from(discovered.keys());
+    const results = await map_concurrent(absPaths, MAX_FILE_CONCURRENCY, async (absPath) => {
+        try {
+            const content = await readFile(absPath, 'utf-8');
+            return { id: absPath, content };
+        }
+        catch (err) {
+            diagnostics.push({
+                kind: 'module_unreadable',
+                severity: 'error',
+                file: toPosixPath(relative(projectRoot, absPath)),
+                message: `Could not read file discovered via package.json exports: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return null;
+        }
+    });
+    const files = results.filter((r) => r !== null);
+    return { files, diagnostics };
+};
+/**
+ * Resolve a concrete (non-wildcard) export entry to a source file.
+ */
+const resolveConcreteExport = async (distPath, condition, mappingOptions, projectRoot, discovered) => {
+    const sourcePath = mapDistToSource(distPath, condition, mappingOptions);
+    if (!sourcePath)
+        return;
+    const absPath = toPosixPath(resolve(projectRoot, sourcePath));
+    if (discovered.has(absPath))
+        return;
+    // Check existence — try .ts first, fall back to .js
+    if (await fileExists(absPath)) {
+        discovered.set(absPath, sourcePath);
+    }
+    else if (sourcePath.endsWith('.ts')) {
+        const jsPath = sourcePath.replace(/\.ts$/, '.js');
+        const absJs = toPosixPath(resolve(projectRoot, jsPath));
+        if (await fileExists(absJs)) {
+            discovered.set(absJs, jsPath);
+        }
+    }
+};
+/**
+ * Expand a wildcard export pattern to matching source files.
+ */
+const expandWildcardExport = async (distPath, condition, mappingOptions, projectRoot, exclude, discovered) => {
+    const sourcePattern = mapDistToSource(distPath, condition, mappingOptions);
+    if (!sourcePattern)
+        return;
+    // Convert mapped pattern to glob: "src/lib/*.ts" is already a valid glob
+    const patterns = [sourcePattern];
+    // For .ts patterns, also try .svelte and .js
+    if (sourcePattern.endsWith('.ts')) {
+        patterns.push(sourcePattern.replace(/\.ts$/, '.svelte'));
+        patterns.push(sourcePattern.replace(/\.ts$/, '.js'));
+        // Also try CSS
+        patterns.push(sourcePattern.replace(/\.ts$/, '.css'));
+    }
+    const filePaths = await glob(patterns, {
+        cwd: projectRoot,
+        ignore: exclude,
+        absolute: true,
+    });
+    for (const rawAbsPath of filePaths) {
+        // Posixify before keying — tinyglobby returns native separators on
+        // Windows; the rest of the pipeline expects POSIX absolute paths.
+        const absPath = toPosixPath(rawAbsPath);
+        if (!discovered.has(absPath)) {
+            // Compute relative source path from absolute. Both sides are POSIX
+            // at this point, so the slice produces a forward-slash relative path.
+            const relPath = absPath.slice(projectRoot.length + 1);
+            discovered.set(absPath, relPath);
+        }
+    }
+};
+/**
+ * Check if a file exists.
+ */
+const fileExists = async (path) => {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/dist/files.d.ts

@@ -0,0 +1,77 @@
+/**
+ * File system helpers — file loading and glob discovery.
+ *
+ * Composable primitives for `analyzeFromFiles` / `discoverSourceFiles`. For
+ * most use cases prefer those higher-level entry points.
+ *
+ * Build tools that want to drive resolve outside the session can construct an
+ * `ImportResolver` directly and pass it to `createAnalysisSession`.
+ *
+ * @see `analyzeFromFiles` for the high-level disk-discovery wrapper
+ * @see `discoverSourceFiles` for exports-first discovery with glob fallback
+ *
+ * @module
+ */
+import type { SourceFileInfo } from './source.js';
+/**
+ * Load a single source file from disk.
+ *
+ * Accepts either relative or absolute paths. Relative paths are resolved against `projectRoot`.
+ *
+ * @param path - file path (relative to `projectRoot` or absolute)
+ * @param projectRoot - absolute path to project root
+ * @returns source file info with content loaded
+ * @throws Error if the file cannot be read (e.g., missing or permission denied)
+ *
+ * @example
+ * ```ts
+ * const file = await loadFile('src/lib/math.ts', process.cwd());
+ * // {id: '/abs/path/to/src/lib/math.ts', content: '...'}
+ * ```
+ */
+export declare const loadFile: (path: string, projectRoot: string) => Promise<SourceFileInfo>;
+/**
+ * Build an include pattern array from source paths.
+ *
+ * Each path becomes a `<path>/**\/*.{ts,js,svelte,css,json}` glob. Used by
+ * `discoverSourceFiles` to derive a default `include` from
+ * `sourceOptions.sourcePaths` when no explicit pattern is supplied — keeps
+ * the glob fallback consistent with custom `sourcePaths` instead of silently
+ * defaulting to `src/lib`.
+ *
+ * @example
+ * ```ts
+ * deriveIncludePatterns(['packages/foo', 'packages/bar'])
+ * // => ['packages/foo/**\/*.{ts,js,svelte,css,json}', 'packages/bar/**\/*.{ts,js,svelte,css,json}']
+ * ```
+ */
+export declare const deriveIncludePatterns: (sourcePaths: ReadonlyArray<string>) => Array<string>;
+/**
+ * Options for `globFiles`.
+ */
+export interface GlobFilesOptions {
+    /** Absolute path to project root. */
+    projectRoot: string;
+    /** Glob patterns to include (relative to `projectRoot`). */
+    include: Array<string>;
+    /** Optional glob patterns to exclude. */
+    exclude?: Array<string>;
+}
+/**
+ * Discover source files via glob patterns.
+ *
+ * @param options - glob configuration
+ * @returns array of source files with content loaded
+ * @throws Error if any matched file cannot be read — `Promise.all` rejects on the first read failure
+ *
+ * @example
+ * ```ts
+ * const files = await globFiles({
+ *   projectRoot: process.cwd(),
+ *   include: deriveIncludePatterns(['src/lib']),
+ *   exclude: DEFAULT_SOURCE_OPTIONS.exclude,
+ * });
+ * ```
+ */
+export declare const globFiles: (options: GlobFilesOptions) => Promise<Array<SourceFileInfo>>;
+//# sourceMappingURL=files.d.ts.map

package/dist/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/files.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAIhD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,GAAU,MAAM,MAAM,EAAE,aAAa,MAAM,KAAG,OAAO,CAAC,cAAc,CAQxF,CAAC;AASF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,aAAa,CAAC,MAAM,CAAC,KAAG,KAAK,CAAC,MAAM,CACvB,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,yCAAyC;IACzC,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACxB;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,GAAU,SAAS,gBAAgB,KAAG,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAexF,CAAC"}

package/dist/files.js

@@ -0,0 +1,95 @@
+/**
+ * File system helpers — file loading and glob discovery.
+ *
+ * Composable primitives for `analyzeFromFiles` / `discoverSourceFiles`. For
+ * most use cases prefer those higher-level entry points.
+ *
+ * Build tools that want to drive resolve outside the session can construct an
+ * `ImportResolver` directly and pass it to `createAnalysisSession`.
+ *
+ * @see `analyzeFromFiles` for the high-level disk-discovery wrapper
+ * @see `discoverSourceFiles` for exports-first discovery with glob fallback
+ *
+ * @module
+ */
+import { readFile } from 'node:fs/promises';
+import { resolve, isAbsolute } from 'node:path';
+import { glob } from 'tinyglobby';
+import { toPosixPath } from './paths.js';
+import { MAX_FILE_CONCURRENCY, map_concurrent } from './concurrency.js';
+/**
+ * Load a single source file from disk.
+ *
+ * Accepts either relative or absolute paths. Relative paths are resolved against `projectRoot`.
+ *
+ * @param path - file path (relative to `projectRoot` or absolute)
+ * @param projectRoot - absolute path to project root
+ * @returns source file info with content loaded
+ * @throws Error if the file cannot be read (e.g., missing or permission denied)
+ *
+ * @example
+ * ```ts
+ * const file = await loadFile('src/lib/math.ts', process.cwd());
+ * // {id: '/abs/path/to/src/lib/math.ts', content: '...'}
+ * ```
+ */
+export const loadFile = async (path, projectRoot) => {
+    const absolutePath = isAbsolute(path) ? path : resolve(projectRoot, path);
+    const content = await readFile(absolutePath, 'utf-8');
+    return {
+        id: toPosixPath(absolutePath),
+        content,
+    };
+};
+/**
+ * Glob extension list for source files. Matches the extension set covered by
+ * `getDefaultAnalyzer` in `source.ts` — keep in sync if a new analyzable
+ * extension is added there.
+ */
+const SOURCE_FILE_EXTENSIONS = 'ts,js,svelte,css,json';
+/**
+ * Build an include pattern array from source paths.
+ *
+ * Each path becomes a `<path>/**\/*.{ts,js,svelte,css,json}` glob. Used by
+ * `discoverSourceFiles` to derive a default `include` from
+ * `sourceOptions.sourcePaths` when no explicit pattern is supplied — keeps
+ * the glob fallback consistent with custom `sourcePaths` instead of silently
+ * defaulting to `src/lib`.
+ *
+ * @example
+ * ```ts
+ * deriveIncludePatterns(['packages/foo', 'packages/bar'])
+ * // => ['packages/foo/**\/*.{ts,js,svelte,css,json}', 'packages/bar/**\/*.{ts,js,svelte,css,json}']
+ * ```
+ */
+export const deriveIncludePatterns = (sourcePaths) => sourcePaths.map((p) => `${p}/**/*.{${SOURCE_FILE_EXTENSIONS}}`);
+/**
+ * Discover source files via glob patterns.
+ *
+ * @param options - glob configuration
+ * @returns array of source files with content loaded
+ * @throws Error if any matched file cannot be read — `Promise.all` rejects on the first read failure
+ *
+ * @example
+ * ```ts
+ * const files = await globFiles({
+ *   projectRoot: process.cwd(),
+ *   include: deriveIncludePatterns(['src/lib']),
+ *   exclude: DEFAULT_SOURCE_OPTIONS.exclude,
+ * });
+ * ```
+ */
+export const globFiles = async (options) => {
+    const { projectRoot, include, exclude } = options;
+    const filePaths = await glob(include, {
+        cwd: projectRoot,
+        ignore: exclude,
+        absolute: true,
+    });
+    // Bounded concurrency to keep FD pressure under the typical ulimit on
+    // large projects. See `concurrency.ts`.
+    return map_concurrent(filePaths, MAX_FILE_CONCURRENCY, async (id) => {
+        const content = await readFile(id, 'utf-8');
+        return { id: toPosixPath(id), content };
+    });
+};

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * svelte-docinfo: static analysis for TypeScript and Svelte.
+ *
+ * This barrel export provides the common API surface. Every module also exports
+ * its full public API via direct imports (e.g., `svelte-docinfo/typescript-exports.js`)
+ * for power users who need lower-level access to TypeScript compiler wrappers,
+ * Svelte analysis internals, or TSDoc parsing utilities.
+ *
+ * @module
+ * @nodocs
+ */
+export { analyze, analyzeFromFiles } from './analyze.js';
+export type { AnalyzeOptions, AnalyzeFromFilesOptions } from './analyze.js';
+export { throwOnDuplicates, AnalyzeResultJson } from './analyze-core.js';
+export type { OnDuplicates, OnDuplicatesCallback } from './analyze-core.js';
+export { createAnalysisSession } from './session.js';
+export type { AnalysisSession, AnalysisSessionOptions, SetFileOptions, SetFileResult, SetFilesResult, QueryOptions, } from './session.js';
+export { normalizeResolveImport } from './dep-resolver.js';
+export type { ImportResolver, ResolveImport, ResolveImportFn } from './dep-resolver.js';
+export { DeclarationKind, DeclarationModifier, MemberKind, Reactivity, GenericParamJson, ParameterJson, ComponentPropJson, OverloadJson, FunctionMemberJson, VariableMemberJson, ConstructorMemberJson, MemberJson, FunctionDeclarationJson, ClassDeclarationJson, InterfaceDeclarationJson, TypeDeclarationJson, VariableDeclarationJson, EnumDeclarationJson, ComponentDeclarationJson, SnippetDeclarationJson, NamespaceDeclarationJson, DeclarationJson, ModuleJson, } from './types.js';
+export { getDisplayName, generateImport, compactReplacer, isKind, findTypeReferences, buildTypeReferencePatterns, } from './declaration-helpers.js';
+export type { SourceFileInfo, AnalyzerType } from './source.js';
+export { createSourceOptions, DEFAULT_SOURCE_OPTIONS } from './source-config.js';
+export type { ModuleSourceOptions, SourceOptionsDefaults } from './source-config.js';
+export { findDuplicates, mergeReExports, resolveComponentAliases } from './postprocess.js';
+export type { DuplicateDeclaration, ReExportEntry } from './postprocess.js';
+export { deriveIncludePatterns } from './files.js';
+export { discoverSourceFiles } from './discovery.js';
+export type { Discovery, DiscoverSourceFilesOptions, DiscoverSourceFilesResult, } from './discovery.js';
+export { hasErrors, hasWarnings, errorsOf, warningsOf, byKind, formatDiagnostic, DiagnosticSeverity, DiagnosticKind, Diagnostic, } from './diagnostics.js';
+export type { AnalysisLog } from './log.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAC,OAAO,EAAE,gBAAgB,EAAC,MAAM,cAAc,CAAC;AACvD,YAAY,EAAC,cAAc,EAAE,uBAAuB,EAAC,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAC,iBAAiB,EAAE,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACvE,YAAY,EAAC,YAAY,EAAE,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAC,qBAAqB,EAAC,MAAM,cAAc,CAAC;AACnD,YAAY,EACX,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,GACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAC,sBAAsB,EAAC,MAAM,mBAAmB,CAAC;AACzD,YAAY,EAAC,cAAc,EAAE,aAAa,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAItF,OAAO,EACN,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACV,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,eAAe,EACf,UAAU,GACV,MAAM,YAAY,CAAC;AAIpB,OAAO,EACN,cAAc,EACd,cAAc,EACd,eAAe,EACf,MAAM,EACN,kBAAkB,EAClB,0BAA0B,GAC1B,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EAAC,cAAc,EAAE,YAAY,EAAC,MAAM,aAAa,CAAC;AAI9D,OAAO,EAAC,mBAAmB,EAAE,sBAAsB,EAAC,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAC,mBAAmB,EAAE,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAInF,OAAO,EAAC,cAAc,EAAE,cAAc,EAAE,uBAAuB,EAAC,MAAM,kBAAkB,CAAC;AACzF,YAAY,EAAC,oBAAoB,EAAE,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAI1E,OAAO,EAAC,qBAAqB,EAAC,MAAM,YAAY,CAAC;AAIjD,OAAO,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACX,SAAS,EACT,0BAA0B,EAC1B,yBAAyB,GACzB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACN,SAAS,EACT,WAAW,EACX,QAAQ,EACR,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,UAAU,GACV,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+/**
+ * svelte-docinfo: static analysis for TypeScript and Svelte.
+ *
+ * This barrel export provides the common API surface. Every module also exports
+ * its full public API via direct imports (e.g., `svelte-docinfo/typescript-exports.js`)
+ * for power users who need lower-level access to TypeScript compiler wrappers,
+ * Svelte analysis internals, or TSDoc parsing utilities.
+ *
+ * @module
+ * @nodocs
+ */
+// ── Core entry points ───────────────────────────────────────────────────────
+export { analyze, analyzeFromFiles } from './analyze.js';
+export { throwOnDuplicates, AnalyzeResultJson } from './analyze-core.js';
+export { createAnalysisSession } from './session.js';
+export { normalizeResolveImport } from './dep-resolver.js';
+// ── Types (Zod schemas + TypeScript interfaces) ─────────────────────────────
+export { DeclarationKind, DeclarationModifier, MemberKind, Reactivity, GenericParamJson, ParameterJson, ComponentPropJson, OverloadJson, FunctionMemberJson, VariableMemberJson, ConstructorMemberJson, MemberJson, FunctionDeclarationJson, ClassDeclarationJson, InterfaceDeclarationJson, TypeDeclarationJson, VariableDeclarationJson, EnumDeclarationJson, ComponentDeclarationJson, SnippetDeclarationJson, NamespaceDeclarationJson, DeclarationJson, ModuleJson, } from './types.js';
+// ── Declaration helpers ────────────────────────────────────────────────────
+export { getDisplayName, generateImport, compactReplacer, isKind, findTypeReferences, buildTypeReferencePatterns, } from './declaration-helpers.js';
+// ── Source options ──────────────────────────────────────────────────────────
+export { createSourceOptions, DEFAULT_SOURCE_OPTIONS } from './source-config.js';
+// ── Post-processing ────────────────────────────────────────────────────────
+export { findDuplicates, mergeReExports, resolveComponentAliases } from './postprocess.js';
+// ── File system constants ──────────────────────────────────────────────────
+export { deriveIncludePatterns } from './files.js';
+// ── File discovery ──────────────────────────────────────────────────────────
+export { discoverSourceFiles } from './discovery.js';
+// ── Diagnostics ─────────────────────────────────────────────────────────────
+export { hasErrors, hasWarnings, errorsOf, warningsOf, byKind, formatDiagnostic, DiagnosticSeverity, DiagnosticKind, Diagnostic, } from './diagnostics.js';

package/dist/log.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Minimal logger interface threaded through analysis functions.
+ *
+ * Separate from `diagnostics.ts` because logging and diagnostics are not the
+ * same concern: diagnostics are structured, schema-validated records of
+ * analysis-time failures; logs are unstructured progress/info messages the
+ * caller chooses how to display.
+ *
+ * @module
+ */
+/**
+ * Minimal logger interface for analysis functions.
+ *
+ * Intentionally narrow so that both `@fuzdev/fuz_util`'s `Logger` class and
+ * Vite's built-in logger satisfy it without adapters or casts.
+ *
+ * @example
+ * ```ts
+ * // Stderr logger for CLI usage
+ * const log: AnalysisLog = {
+ *   info: (msg) => console.error(msg),
+ *   warn: (msg) => console.error(`warning: ${msg}`),
+ *   error: (msg) => console.error(`error: ${msg}`),
+ * };
+ * ```
+ */
+export interface AnalysisLog {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+}
+//# sourceMappingURL=log.d.ts.map

package/dist/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B"}