knip 6.5.0 → 6.6.1

package/dist/ConfigurationChief.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, IgnorePatterns, RawConfiguration, WorkspaceConfiguration } from './types/config.ts';
+import type { Configuration, IgnorePatterns, RawConfiguration, SourceMap, WorkspaceConfiguration } from './types/config.ts';
 import type { ConfigurationHint } from './types/issues.ts';
 import type { WorkspacePackage } from './types/package-json.ts';
 import type { MainOptions } from './util/create-options.ts';
@@ -14,8 +14,7 @@ export type Workspace = {
     manifestPath: string;
     manifestStr: string;
     ignoreMembers: IgnorePatterns;
-    srcDir?: string;
-    outDir?: string;
+    sourceMaps?: SourceMap[];
 };
 export declare class ConfigurationChief {
     cwd: string;
@@ -637,6 +636,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'sveltejs-package'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sveltekit?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -931,6 +935,7 @@ export declare class ConfigurationChief {
         stryker?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         stylelint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         svelte?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "sveltejs-package"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         sveltekit?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         svgo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         svgr?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/WorkspaceWorker.d.ts

@@ -1,10 +1,11 @@
 import { CacheConsultant } from './CacheConsultant.ts';
 import { type Workspace } from './ConfigurationChief.ts';
-import type { HandleInput, RegisterCompiler, RegisterVisitorsOptions, WorkspaceConfiguration } from './types/config.ts';
+import type { HandleInput, RegisterCompiler, RegisterVisitorsOptions, SourceMap, WorkspaceConfiguration } from './types/config.ts';
 import type { ConfigurationHint } from './types/issues.ts';
 import type { PluginName } from './types/PluginNames.ts';
 import type { PackageJson } from './types/package-json.ts';
 import type { DependencySet } from './types/workspace.ts';
+import { type Manifest } from './util/package-json.ts';
 import type { MainOptions } from './util/create-options.ts';
 import { type Input } from './util/input.ts';
 type WorkspaceManagerOptions = {
@@ -13,7 +14,7 @@ type WorkspaceManagerOptions = {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
-    rootManifest: PackageJson | undefined;
+    rootManifest: Manifest | undefined;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
     readFile: (filePath: string) => string;
@@ -32,8 +33,8 @@ export declare class WorkspaceWorker {
     name: string;
     dir: string;
     config: WorkspaceConfiguration;
-    manifest: PackageJson;
-    rootManifest: PackageJson | undefined;
+    manifest: Manifest;
+    rootManifest: Manifest | undefined;
     dependencies: DependencySet;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
@@ -60,6 +61,7 @@ export declare class WorkspaceWorker {
     getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
     private getConfigurationFilePatterns;
     registerCompilers(registerCompiler: RegisterCompiler): Promise<void>;
+    resolveSourceMaps(): Promise<SourceMap[]>;
     registerVisitors(options: RegisterVisitorsOptions): void;
     runPlugins(): Promise<Input[]>;
     private filterTransitiveDependencies;

package/dist/WorkspaceWorker.js

@@ -5,6 +5,7 @@ import { isDefaultPattern } from './ConfigurationChief.js';
 import { DEFAULT_EXTENSIONS, ROOT_WORKSPACE_NAME } from './constants.js';
 import { getFilteredScripts } from './manifest/helpers.js';
 import { PluginEntries, Plugins } from './plugins.js';
+import { createManifest } from './util/package-json.js';
 import { collectStringLiterals, isExternalReExportsOnly } from './typescript/ast-helpers.js';
 import { parseFile } from './typescript/visitors/helpers.js';
 import { compact } from './util/array.js';
@@ -42,7 +43,7 @@ export class WorkspaceWorker {
         this.name = name;
         this.dir = dir;
         this.config = config;
-        this.manifest = manifest;
+        this.manifest = createManifest(manifest);
         this.rootManifest = rootManifest;
         this.dependencies = dependencies;
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
@@ -170,6 +171,24 @@ export class WorkspaceWorker {
             await plugin.registerCompilers({ cwd, hasDependency, registerCompiler });
         }
     }
+    async resolveSourceMaps() {
+        const options = {
+            cwd: this.dir,
+            rootCwd: this.options.cwd,
+            manifest: this.manifest,
+            rootManifest: this.rootManifest,
+            dependencies: this.dependencies,
+        };
+        const pairs = [];
+        for (const pluginName of this.enabledPlugins) {
+            const plugin = Plugins[pluginName];
+            if (!plugin.resolveSourceMap)
+                continue;
+            for (const pair of await plugin.resolveSourceMap(options))
+                pairs.push(pair);
+        }
+        return pairs;
+    }
     registerVisitors(options) {
         for (const pluginName of this.enabledPlugins) {
             if (options.registeredPlugins.has(pluginName))
@@ -189,10 +208,9 @@ export class WorkspaceWorker {
         const containingFilePath = join(cwd, 'package.json');
         const isProduction = this.options.isProduction;
         const knownBinsOnly = false;
-        const manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
         const rootManifest = this.rootManifest;
-        const baseOptions = { manifestScriptNames, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
-        const baseScriptOptions = { ...baseOptions, manifest, isProduction, enabledPlugins: this.enabledPlugins };
+        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
+        const baseScriptOptions = { ...baseOptions, isProduction, enabledPlugins: this.enabledPlugins };
         const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);
         const productionInputsFromManifest = _getInputsFromScripts(Object.values(productionScripts), baseOptions);

package/dist/binaries/plugins.js

@@ -9,7 +9,7 @@ const isGlobLikeMatch = /(^!|[*+\\(|{^$])/;
 const isGlobLike = (value) => isGlobLikeMatch.test(value);
 const nodeLoadersArgs = { import: ['r', 'experimental-loader', 'require', 'loader'] };
 export const resolve = (binary, _args, options) => {
-    const { cwd, fromArgs, containingFilePath } = options;
+    const { cwd, fromArgs, containingFilePath, manifest } = options;
     const [pluginName, pluginArgs] = pluginArgsMap.get(binary) ?? [];
     if (!pluginArgs)
         return fallbackResolve(binary, _args, options);
@@ -59,7 +59,7 @@ export const resolve = (binary, _args, options) => {
         return parsed[id] && pluginName ? [toConfig(pluginName, fn(parsed[id]), inputOpts)] : [];
     };
     const configFilePaths = config.flatMap(mapToConfigPattern);
-    const inputs = pluginArgs.resolveInputs?.(parsed, { args, cwd }) ?? [];
+    const inputs = pluginArgs.resolveInputs?.(parsed, { args, cwd, manifest }) ?? [];
     return [
         toBinary(binary, inputOpts),
         ...positionals,

package/dist/binaries/resolvers/bun.js

@@ -57,10 +57,10 @@ export const resolve = (_binary, args, options) => {
         const argsForX = args.filter(arg => arg !== 'x');
         return resolveX(argsForX, options);
     }
-    const { manifestScriptNames, cwd, fromArgs } = options;
-    if (command === 'run' && manifestScriptNames.has(script))
+    const { manifest, cwd, fromArgs } = options;
+    if (command === 'run' && manifest.scriptNames.has(script))
         return [];
-    if (manifestScriptNames.has(command))
+    if (manifest.scriptNames.has(command))
         return [];
     if (command !== 'run' && commands.has(command))
         return [];

package/dist/binaries/resolvers/npm.js

@@ -1,12 +1,12 @@
 import parseArgs from 'minimist';
 export const resolve = (_binary, args, options) => {
-    const { fromArgs, manifestScriptNames } = options;
+    const { fromArgs, manifest } = options;
     const parsed = parseArgs(args, { '--': true });
     const [command, script] = parsed._;
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'exec')
         return _childArgs;
-    if (command === 'run' && manifestScriptNames.has(script))
+    if (command === 'run' && manifest.scriptNames.has(script))
         return _childArgs;
     return [];
 };

package/dist/binaries/resolvers/pnpm.js

@@ -73,14 +73,14 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    const { manifestScriptNames, fromArgs } = options;
+    const { manifest, fromArgs } = options;
     if (parsed.filter && !parsed.recursive)
         return [];
     const childInputs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'exec') {
         return childInputs.length > 0 ? childInputs : fromArgs(parsed._.slice(1));
     }
-    const isScript = manifestScriptNames.has(command);
+    const isScript = manifest.scriptNames.has(command);
     if (isScript || commands.includes(command))
         return childInputs;
     return command && isValidBinary(command) ? [toBinary(command)] : [];

package/dist/binaries/resolvers/yarn.js

@@ -49,7 +49,7 @@ const resolveDlx = (args, options) => {
     return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
 };
 export const resolve = (_binary, args, options) => {
-    const { manifestScriptNames, fromArgs, cwd, rootCwd } = options;
+    const { manifest, fromArgs, cwd, rootCwd } = options;
     const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'], '--': true });
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const [command, binary] = parsed._;
@@ -57,7 +57,7 @@ export const resolve = (_binary, args, options) => {
         return [];
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
-        if (manifestScriptNames.has(binary))
+        if (manifest.scriptNames.has(binary))
             return _childArgs;
         const bin = toBinary(binary, { optional: true });
         if (dir)
@@ -70,7 +70,7 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    if ((!dir && manifestScriptNames.has(command)) || commands.includes(command))
+    if ((!dir && manifest.scriptNames.has(command)) || commands.includes(command))
         return _childArgs;
     const opts = dir ? { cwd: dir } : {};
     return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);

package/dist/compilers/index.d.ts

@@ -583,6 +583,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'sveltejs-package'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     sveltekit?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1339,6 +1344,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'sveltejs-package'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sveltekit?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/graph/build.js

@@ -6,6 +6,7 @@ import { createInputHandler } from '../util/create-input-handler.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { existsSync } from 'node:fs';
 import { tryRealpath } from '../util/fs.js';
+import { createManifest } from '../util/package-json.js';
 import { _glob, _syncGlob, negate, prependDirToPattern as prependDir } from '../util/glob.js';
 import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isIgnore, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
 import { loadTSConfig } from '../util/load-tsconfig.js';
@@ -14,7 +15,7 @@ import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpe
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join, relative } from '../util/path.js';
-import { augmentWorkspace, getToSourcePathsHandler } from '../util/to-source-path.js';
+import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
 export async function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options, }) {
     const configFilesMap = new Map();
@@ -24,7 +25,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     const addIssue = (issue) => collector.addIssue(issue) && options.isWatch && collector.retainIssue(issue);
     const externalRefsFromInputs = options.isSession ? new Map() : undefined;
     const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
-    const rootManifest = chief.getManifestForWorkspace('.');
+    const rawRootManifest = chief.getManifestForWorkspace('.');
+    const rootManifest = rawRootManifest ? createManifest(rawRootManifest) : undefined;
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
@@ -57,8 +59,6 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
         const { isFile, compilerOptions, fileNames } = await loadTSConfig(tsConfigFilePath);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
-        if (isFile)
-            augmentWorkspace(workspace, dir, compilerOptions);
         const worker = new WorkspaceWorker({
             name,
             dir,
@@ -89,6 +89,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);
         worker.config = config;
+        const pluginSourceMaps = await worker.resolveSourceMaps();
+        augmentWorkspace(workspace, dir, isFile ? compilerOptions : undefined, pluginSourceMaps);
         const inputs = new Set();
         if (definitionPaths.length > 0) {
             debugLogArray(name, 'Definition paths', definitionPaths);
@@ -105,13 +107,21 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             inputs.add(toProductionEntry(filePath));
         }
         for (const identifier of entrySpecifiersFromManifest) {
-            if (!identifier.startsWith('!') && !isGitIgnored(join(dir, identifier))) {
-                const exists = identifier.includes('*')
-                    ? _syncGlob({ patterns: [identifier], cwd: dir }).length > 0
-                    : existsSync(join(dir, identifier));
-                if (!exists) {
-                    collector.addConfigurationHint({ type: 'package-entry', filePath, identifier, workspaceName: name });
-                }
+            if (identifier.startsWith('!') || isGitIgnored(join(dir, identifier)))
+                continue;
+            if (!identifier.startsWith('.') && !identifier.startsWith('/')) {
+                const packageName = getPackageNameFromModuleSpecifier(identifier);
+                if (packageName && dependencies.has(packageName))
+                    continue;
+            }
+            const abs = prependDir(dir, identifier);
+            const mapped = toSourceMappedSpecifiers(workspace, abs, extensionGlobStr);
+            const hasWildcard = identifier.includes('*');
+            const exists = hasWildcard
+                ? _syncGlob({ patterns: [identifier, ...mapped], cwd: dir }).length > 0
+                : existsSync(abs) || mapped.some(pattern => _syncGlob({ patterns: [pattern], cwd: dir }).length > 0);
+            if (!exists) {
+                collector.addConfigurationHint({ type: 'package-entry', filePath, identifier, workspaceName: name });
             }
         }
         for (const dep of getManifestImportDependencies(manifest))
@@ -322,16 +332,16 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     }
                 }
             }
-            if (file.scripts && file.scripts.size > 0) {
+            const manifest = chief.getManifestForWorkspace(workspace.name);
+            if (manifest && file.scripts && file.scripts.size > 0) {
                 const dependencies = deputy.getDependencies(workspace.name);
-                const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const dir = dirname(filePath);
                 const opts = {
                     cwd: dir,
                     rootCwd: options.cwd,
                     containingFilePath: filePath,
                     dependencies,
-                    manifestScriptNames,
+                    manifest: createManifest(manifest),
                     rootManifest,
                 };
                 const inputs = _getInputsFromScripts(file.scripts, opts);

package/dist/plugins/astro/index.js

@@ -1,8 +1,9 @@
 import { toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getAliasInputs } from '../vitest/helpers.js';
 import compiler from './compiler.js';
 import mdxCompiler from './compiler-mdx.js';
-import { getSrcDir, usesPassthroughImageService } from './resolveFromAST.js';
+import { getSrcDir, getViteAliases, usesPassthroughImageService } from './resolveFromAST.js';
 const title = 'Astro';
 const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -16,12 +17,13 @@ const production = [
     'src/middleware.{js,ts}',
     'src/actions/index.{js,ts}',
 ];
-const resolveFromAST = program => {
+const resolveFromAST = (program, options) => {
     const srcDir = getSrcDir(program);
     const setSrcDir = (entry) => entry.replace(/^src\//, `${srcDir}/`);
     const inputs = [
         ...entry.map(setSrcDir).map(path => toEntry(path)),
         ...production.map(setSrcDir).map(path => toProductionEntry(path)),
+        ...getAliasInputs(getViteAliases(program), options.cwd),
     ];
     if (!usesPassthroughImageService(program))
         inputs.push(toDependency('sharp', { optional: true }));

package/dist/plugins/astro/resolveFromAST.d.ts

@@ -1,3 +1,4 @@
 import type { Program } from 'oxc-parser';
 export declare const getSrcDir: (program: Program) => string;
 export declare const usesPassthroughImageService: (program: Program) => boolean;
+export declare const getViteAliases: (program: Program) => Record<string, string>;

package/dist/plugins/astro/resolveFromAST.js

@@ -1,6 +1,45 @@
-import { collectPropertyValues, hasImportSpecifier } from '../../typescript/ast-helpers.js';
+import { collectPropertyValues, findProperty, getPropertyKey, getStringValue, hasImportSpecifier, } from '../../typescript/ast-helpers.js';
 export const getSrcDir = (program) => {
     const values = collectPropertyValues(program, 'srcDir');
     return values.size > 0 ? Array.from(values)[0] : 'src';
 };
 export const usesPassthroughImageService = (program) => hasImportSpecifier(program, 'astro/config', 'passthroughImageService');
+const findFirstStringArg = (node) => {
+    const literal = getStringValue(node);
+    if (literal)
+        return literal;
+    if (node?.type === 'CallExpression' || node?.type === 'NewExpression') {
+        for (const arg of node.arguments ?? []) {
+            const found = findFirstStringArg(arg);
+            if (found)
+                return found;
+        }
+    }
+};
+export const getViteAliases = (program) => {
+    const aliases = {};
+    for (const node of program.body ?? []) {
+        if (node.type !== 'ExportDefaultDeclaration')
+            continue;
+        const decl = node.declaration;
+        const root = decl?.type === 'ObjectExpression'
+            ? decl
+            : decl?.type === 'CallExpression' && decl.arguments?.[0]?.type === 'ObjectExpression'
+                ? decl.arguments[0]
+                : undefined;
+        const aliasNode = findProperty(findProperty(findProperty(root, 'vite'), 'resolve'), 'alias');
+        if (aliasNode?.type !== 'ObjectExpression')
+            continue;
+        for (const prop of aliasNode.properties ?? []) {
+            if (prop.type !== 'Property')
+                continue;
+            const key = getPropertyKey(prop);
+            if (!key)
+                continue;
+            const raw = findFirstStringArg(prop.value);
+            if (raw)
+                aliases[key] = raw;
+        }
+    }
+    return aliases;
+};

package/dist/plugins/eslint/index.js

@@ -17,13 +17,8 @@ const config = [
 const isLoadConfig = ({ configFileName, manifest }, dependencies) => {
     if (isFlatConfig(configFileName))
         return false;
-    const version = manifest.devDependencies?.['eslint'] || manifest.dependencies?.['eslint'];
-    if (version) {
-        const major = version.match(/\d+/);
-        if (major && Number.parseInt(major[0], 10) === 9 && dependencies.has('eslint-config-next')) {
-            return false;
-        }
-    }
+    if (manifest.getMajor('eslint') === 9 && dependencies.has('eslint-config-next'))
+        return false;
     return true;
 };
 const resolveConfig = (localConfig, options) => getInputs(localConfig, options);

package/dist/plugins/index.d.ts

@@ -120,6 +120,7 @@ export declare const Plugins: {
     stryker: import("../types/config.ts").Plugin;
     stylelint: import("../types/config.ts").Plugin;
     svelte: import("../types/config.ts").Plugin;
+    'sveltejs-package': import("../types/config.ts").Plugin;
     sveltekit: import("../types/config.ts").Plugin;
     svgo: import("../types/config.ts").Plugin;
     svgr: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -114,6 +114,7 @@ import { default as storybook } from './storybook/index.js';
 import { default as stryker } from './stryker/index.js';
 import { default as stylelint } from './stylelint/index.js';
 import { default as svelte } from './svelte/index.js';
+import { default as sveltejsPackage } from './sveltejs-package/index.js';
 import { default as sveltekit } from './sveltekit/index.js';
 import { default as svgo } from './svgo/index.js';
 import { default as svgr } from './svgr/index.js';
@@ -262,6 +263,7 @@ export const Plugins = {
     stryker,
     stylelint,
     svelte,
+    'sveltejs-package': sveltejsPackage,
     sveltekit,
     svgo,
     svgr,

package/dist/plugins/react-email/index.js

@@ -7,10 +7,12 @@ const entry = ['emails/**/*.tsx'];
 const previewCommands = new Set(['build', 'dev', 'start']);
 const args = {
     binaries: ['email'],
-    resolveInputs: parsed => {
+    resolveInputs: (parsed, { manifest }) => {
         const inputs = [];
-        if (previewCommands.has(parsed._[0]))
-            inputs.push(toDependency('@react-email/preview-server'));
+        if (previewCommands.has(parsed._[0])) {
+            const dep = (manifest.getMajor('react-email') ?? 0) >= 6 ? '@react-email/ui' : '@react-email/preview-server';
+            inputs.push(toDependency(dep));
+        }
         if (parsed.dir)
             inputs.push(toEntry(`${parsed.dir}/**/*.tsx`));
         return inputs;

package/dist/plugins/rslib/index.js

@@ -1,16 +1,19 @@
+import { toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getEntryFromAST } from './resolveFromAST.js';
 const title = 'Rslib';
 const enablers = ['@rslib/core'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const entry = ['rslib*.config.{mjs,ts,js,cjs,mts,cts}'];
-const resolveConfig = () => {
-    return [];
+const config = ['rslib*.config.{mjs,ts,js,cjs,mts,cts}'];
+const resolveFromAST = program => {
+    const entries = getEntryFromAST(program);
+    return [...entries].map(id => toProductionEntry(id, { allowIncludeExports: true }));
 };
 const plugin = {
     title,
     enablers,
     isEnabled,
-    entry,
-    resolveConfig,
+    config,
+    resolveFromAST,
 };
 export default plugin;

package/dist/plugins/rslib/resolveFromAST.d.ts

@@ -0,0 +1,2 @@
+import type { Program } from 'oxc-parser';
+export declare const getEntryFromAST: (program: Program) => Set<string>;

package/dist/plugins/rslib/resolveFromAST.js

@@ -0,0 +1,4 @@
+import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+export const getEntryFromAST = (program) => {
+    return collectPropertyValues(program, 'entry');
+};

package/dist/plugins/sveltejs-package/helpers.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_INPUT = "src/lib";
+export declare const DEFAULT_OUTPUT = "dist";
+interface IO {
+    input: string;
+    output: string;
+}
+export declare const parseScripts: (scripts: Record<string, string | undefined> | undefined) => IO[];
+export {};

package/dist/plugins/sveltejs-package/helpers.js

@@ -0,0 +1,65 @@
+import parseArgs from 'minimist';
+import { parse } from 'unbash';
+const BIN = 'svelte-package';
+export const DEFAULT_INPUT = 'src/lib';
+export const DEFAULT_OUTPUT = 'dist';
+const parseCommandIO = (args) => {
+    const parsed = parseArgs(args, { string: ['i', 'o', 'input', 'output'], alias: { input: ['i'], output: ['o'] } });
+    return { input: parsed.input ?? DEFAULT_INPUT, output: parsed.output ?? DEFAULT_OUTPUT };
+};
+const collectFromCommands = (statements, out) => {
+    for (const stmt of statements)
+        visit(stmt.command, out);
+};
+const visit = (node, out) => {
+    switch (node.type) {
+        case 'Command':
+            if (node.name?.value === BIN)
+                out.push(parseCommandIO(node.suffix.map(w => w.value)));
+            return;
+        case 'AndOr':
+        case 'Pipeline':
+            for (const n of node.commands)
+                visit(n, out);
+            return;
+        case 'If':
+            collectFromCommands(node.clause.commands, out);
+            collectFromCommands(node.then.commands, out);
+            if (node.else)
+                visit(node.else, out);
+            return;
+        case 'While':
+            collectFromCommands(node.clause.commands, out);
+            collectFromCommands(node.body.commands, out);
+            return;
+        case 'For':
+        case 'Select':
+        case 'Subshell':
+        case 'BraceGroup':
+            collectFromCommands(node.body.commands, out);
+            return;
+        case 'CompoundList':
+            collectFromCommands(node.commands, out);
+            return;
+        case 'Function':
+        case 'Coproc':
+            visit(node.body, out);
+            return;
+        case 'Statement':
+            visit(node.command, out);
+    }
+};
+export const parseScripts = (scripts) => {
+    const out = [];
+    for (const script of Object.values(scripts ?? {})) {
+        if (typeof script !== 'string' || !script.includes(BIN))
+            continue;
+        try {
+            const parsed = parse(script);
+            if (parsed.commands)
+                collectFromCommands(parsed.commands, out);
+        }
+        catch { }
+    }
+    return out;
+};

package/dist/plugins/sveltejs-package/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/sveltejs-package/index.js

@@ -0,0 +1,27 @@
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { DEFAULT_INPUT, DEFAULT_OUTPUT, parseScripts } from './helpers.js';
+const title = '@sveltejs/package';
+const enablers = ['@sveltejs/package'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const resolveSourceMap = ({ cwd, manifest }) => {
+    const ios = parseScripts(manifest.scripts);
+    const effective = ios.length > 0 ? ios : [{ input: DEFAULT_INPUT, output: DEFAULT_OUTPUT }];
+    const seen = new Set();
+    const pairs = [];
+    for (const { input, output } of effective) {
+        const key = `${input}→${output}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        pairs.push({ srcDir: join(cwd, input), outDir: join(cwd, output) });
+    }
+    return pairs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    resolveSourceMap,
+};
+export default plugin;

package/dist/plugins/vitest/helpers.d.ts

@@ -1,3 +1,5 @@
-import type { ViteConfig } from './types.ts';
+import { type Input } from '../../util/input.ts';
+import type { AliasOptions, ViteConfig } from './types.ts';
 export declare const getEnvSpecifier: (env: string) => string;
+export declare const getAliasInputs: (aliasOptions: AliasOptions, cwd: string) => Input[];
 export declare const getExternalReporters: (reporters?: ViteConfig['test']['reporters']) => string[];