@rigour-labs/core 6.2.4 → 6.3.0

package/dist/gates/hallucinated-imports/js-resolver.d.ts

@@ -9,21 +9,26 @@
  * - node_modules dependency verification
  */
 import { HallucinatedImport } from './index.js';
-interface TsPathRule {
-    key: string;
-    hasWildcard: boolean;
-    prefix: string;
-    suffix: string;
-    targets: string[];
-}
-interface TsPathConfig {
-    baseDir: string;
-    rules: TsPathRule[];
+import { type SvelteKitRoots } from './framework-modules.js';
+import { type TsPathConfig } from './tsconfig-paths.js';
+/** Everything a JS/TS import check needs besides the file itself. */
+export interface JsImportContext {
+    cwd: string;
+    projectFiles: Set<string>;
+    rootDeps: Set<string>;
+    depCacheByDir: Map<string, Set<string>>;
+    hasNodeModules: boolean;
+    hallucinated: HallucinatedImport[];
+    tsPathCacheByDir: Map<string, TsPathConfig | null>;
+    kitRoots: SvelteKitRoots;
+    shouldIgnore: (importPath: string) => boolean;
+    resolveRelativeImport: (fromFile: string, importPath: string, projectFiles: Set<string>) => boolean;
+    extractPackageName: (importPath: string) => string;
 }
 /**
  * Check JavaScript/TypeScript imports in a source file and add hallucinated findings.
  */
-export declare function checkJSImports(content: string, file: string, cwd: string, projectFiles: Set<string>, rootDeps: Set<string>, depCacheByDir: Map<string, Set<string>>, hasNodeModules: boolean, hallucinated: HallucinatedImport[], tsPathCacheByDir: Map<string, TsPathConfig | null>, shouldIgnore: (importPath: string) => boolean, buildImportCandidates: (resolvedPath: string) => string[], resolveRelativeImport: (fromFile: string, importPath: string, projectFiles: Set<string>) => boolean, extractPackageName: (importPath: string) => string): Promise<void>;
+export declare function checkJSImports(content: string, file: string, ctx: JsImportContext): Promise<void>;
 /**
  * Collect all import statements from JavaScript/TypeScript file content.
  * Handles import, export, require(), and dynamic import() statements.
@@ -42,4 +47,3 @@ export declare function resolveJSDepsForFile(file: string, cwd: string, rootDeps
  * Returns true if resolved, false if alias exists but doesn't resolve, null if no alias found.
  */
 export declare function resolveTsPathAlias(file: string, importPath: string, cwd: string, projectFiles: Set<string>, tsPathCacheByDir: Map<string, TsPathConfig | null>): Promise<boolean | null>;
-export {};

package/dist/gates/hallucinated-imports/js-resolver.js

@@ -13,51 +13,78 @@ import path from 'path';
 import ts from 'typescript';
 import { isNodeBuiltin } from '../hallucinated-imports-stdlib.js';
 import { resolveTsPathTarget } from './ts-path-target.js';
+import { isSvelteKitProvided, resolveSvelteKitLib } from './framework-modules.js';
+import { loadTsPathConfig } from './tsconfig-paths.js';
 /**
  * Check JavaScript/TypeScript imports in a source file and add hallucinated findings.
  */
-export async function checkJSImports(content, file, cwd, projectFiles, rootDeps, depCacheByDir, hasNodeModules, hallucinated, tsPathCacheByDir, shouldIgnore, buildImportCandidates, resolveRelativeImport, extractPackageName) {
-    const depsForFile = await resolveJSDepsForFile(file, cwd, rootDeps, depCacheByDir);
-    for (const spec of collectJSImportSpecs(content, file)) {
-        const { importPath, line } = spec;
-        if (!importPath || shouldIgnore(importPath))
+export async function checkJSImports(content, file, ctx) {
+    const depsForFile = await resolveJSDepsForFile(file, ctx.cwd, ctx.rootDeps, ctx.depCacheByDir);
+    const kitRoot = await ctx.kitRoots.rootFor(file);
+    for (const { importPath, line } of collectJSImportSpecs(content, file)) {
+        if (!importPath || ctx.shouldIgnore(importPath))
             continue;
-        if (importPath.startsWith('.')) {
-            const resolved = resolveRelativeImport(file, importPath, projectFiles);
-            if (!resolved) {
-                hallucinated.push({
-                    file, line, importPath, type: 'relative',
-                    reason: `File not found: ${importPath}`,
-                });
-            }
+        if (kitRoot && isSvelteKitProvided(importPath))
+            continue;
+        const reason = importPath.startsWith('.')
+            ? await checkRelativeImport(file, importPath, ctx)
+            : await checkBareImport(file, importPath, depsForFile, kitRoot, ctx);
+        if (reason) {
+            ctx.hallucinated.push({
+                file, line, importPath,
+                type: importPath.startsWith('.') ? 'relative' : 'package',
+                reason,
+            });
         }
-        else {
-            const aliasResolution = await resolveTsPathAlias(file, importPath, cwd, projectFiles, tsPathCacheByDir);
-            if (aliasResolution === true)
-                continue;
-            if (aliasResolution === false) {
-                hallucinated.push({
-                    file, line, importPath, type: 'package',
-                    reason: `Path alias '${importPath}' does not resolve to a project file`,
-                });
-                continue;
-            }
-            const pkgName = extractPackageName(importPath);
-            if (isNodeBuiltin(pkgName))
-                continue;
-            if (!depsForFile.has(pkgName)) {
-                if (hasNodeModules) {
-                    const pkgPath = path.join(cwd, 'node_modules', pkgName);
-                    if (await fs.pathExists(pkgPath))
-                        continue;
-                }
-                hallucinated.push({
-                    file, line, importPath, type: 'package',
-                    reason: `Package '${pkgName}' not in package.json dependencies`,
-                });
-            }
+    }
+}
+async function checkRelativeImport(file, importPath, ctx) {
+    if (ctx.resolveRelativeImport(file, importPath, ctx.projectFiles))
+        return null;
+    const config = await resolveTsPathConfigForFile(file, ctx.cwd, ctx.tsPathCacheByDir);
+    if (config?.rootDirs.length && await resolveThroughRootDirs(file, importPath, config.rootDirs, ctx))
+        return null;
+    return `File not found: ${importPath}`;
+}
+/**
+ * tsconfig `rootDirs`: directories merged into one virtual root, so
+ * `./$types` next to `src/routes/+page.ts` can live in
+ * `.svelte-kit/types/src/routes/$types.d.ts`. Generated folders are often
+ * git-ignored and absent from the file list, so resolution checks the disk.
+ */
+async function resolveThroughRootDirs(file, importPath, rootDirs, ctx) {
+    const target = path.resolve(path.dirname(path.resolve(ctx.cwd, file)), importPath);
+    for (const root of rootDirs) {
+        const relative = path.relative(root, target);
+        if (relative.startsWith('..') || path.isAbsolute(relative))
+            continue;
+        for (const other of rootDirs) {
+            if (other !== root && await resolveTsPathTarget(other, relative, ctx.cwd, ctx.projectFiles))
+                return true;
         }
     }
+    return false;
+}
+/** Reason the bare import is hallucinated, or null when it resolves. */
+async function checkBareImport(file, importPath, depsForFile, kitRoot, ctx) {
+    const aliasResolution = await resolveTsPathAlias(file, importPath, ctx.cwd, ctx.projectFiles, ctx.tsPathCacheByDir);
+    if (aliasResolution === true)
+        return null;
+    if (aliasResolution === false)
+        return `Path alias '${importPath}' does not resolve to a project file`;
+    if (kitRoot) {
+        const lib = await resolveSvelteKitLib(importPath, kitRoot, ctx.cwd, ctx.projectFiles);
+        if (lib === true)
+            return null;
+        if (lib === false)
+            return `Path alias '${importPath}' does not resolve to a file under src/lib`;
+    }
+    const pkgName = ctx.extractPackageName(importPath);
+    if (isNodeBuiltin(pkgName) || depsForFile.has(pkgName))
+        return null;
+    if (ctx.hasNodeModules && await fs.pathExists(path.join(ctx.cwd, 'node_modules', pkgName)))
+        return null;
+    return `Package '${pkgName}' not in package.json dependencies`;
 }
 /**
  * Collect all import statements from JavaScript/TypeScript file content.
@@ -196,118 +223,3 @@ async function resolveTsPathConfigForFile(file, cwd, tsPathCacheByDir) {
     }
     return null;
 }
-/**
- * Load TypeScript path aliases from tsconfig.json, jsconfig.json, or tsconfig.base.json.
- * Follows the extends chain to merge path mappings.
- */
-async function loadTsPathConfig(searchDir) {
-    const candidates = ['tsconfig.json', 'jsconfig.json', 'tsconfig.base.json'];
-    for (const configName of candidates) {
-        const configPath = path.join(searchDir, configName);
-        if (!(await fs.pathExists(configPath)))
-            continue;
-        const mergedPaths = {};
-        let baseUrl = '.';
-        let resolvedBaseDir = searchDir;
-        await resolveExtendsChain(configPath, mergedPaths, (bu) => { baseUrl = bu; }, new Set());
-        const parsed = await readLooseJson(configPath);
-        const compilerOptions = parsed?.compilerOptions || {};
-        if (compilerOptions.paths) {
-            for (const [key, value] of Object.entries(compilerOptions.paths)) {
-                if (typeof key === 'string' && Array.isArray(value)) {
-                    mergedPaths[key] = value;
-                }
-            }
-        }
-        if (compilerOptions.baseUrl)
-            baseUrl = compilerOptions.baseUrl;
-        if (Object.keys(mergedPaths).length === 0)
-            continue;
-        resolvedBaseDir = path.resolve(searchDir, baseUrl);
-        const rules = [];
-        for (const [key, value] of Object.entries(mergedPaths)) {
-            if (typeof key !== 'string' || !Array.isArray(value) || value.length === 0)
-                continue;
-            const hasWildcard = key.includes('*');
-            const [prefix, suffix = ''] = key.split('*');
-            const targets = value.filter(v => typeof v === 'string');
-            if (targets.length === 0)
-                continue;
-            rules.push({ key, hasWildcard, prefix, suffix, targets });
-        }
-        rules.sort((left, right) => {
-            if (left.hasWildcard !== right.hasWildcard)
-                return left.hasWildcard ? 1 : -1;
-            return (right.prefix.length + right.suffix.length)
-                - (left.prefix.length + left.suffix.length);
-        });
-        if (rules.length === 0)
-            continue;
-        return { baseDir: resolvedBaseDir, rules };
-    }
-    return null;
-}
-/**
- * Recursively follow tsconfig `extends` chain to collect path mappings.
- */
-async function resolveExtendsChain(configPath, mergedPaths, setBaseUrl, visited) {
-    const resolved = path.resolve(configPath);
-    if (visited.has(resolved))
-        return;
-    visited.add(resolved);
-    const parsed = await readLooseJson(configPath);
-    if (!parsed)
-        return;
-    if (parsed.extends) {
-        const extendsPath = typeof parsed.extends === 'string' ? parsed.extends : null;
-        if (extendsPath) {
-            let resolvedExtends;
-            if (extendsPath.startsWith('.')) {
-                resolvedExtends = path.resolve(path.dirname(configPath), extendsPath);
-            }
-            else {
-                resolvedExtends = path.resolve(path.dirname(configPath), 'node_modules', extendsPath);
-            }
-            if (!resolvedExtends.endsWith('.json')) {
-                const withJson = resolvedExtends + '.json';
-                if (await fs.pathExists(withJson)) {
-                    resolvedExtends = withJson;
-                }
-            }
-            if (await fs.pathExists(resolvedExtends)) {
-                await resolveExtendsChain(resolvedExtends, mergedPaths, setBaseUrl, visited);
-            }
-        }
-    }
-    const compilerOptions = parsed.compilerOptions || {};
-    if (compilerOptions.baseUrl) {
-        setBaseUrl(compilerOptions.baseUrl);
-    }
-    if (compilerOptions.paths) {
-        for (const [key, value] of Object.entries(compilerOptions.paths)) {
-            if (typeof key === 'string' && Array.isArray(value)) {
-                mergedPaths[key] = value;
-            }
-        }
-    }
-}
-/**
- * Read JSON file with support for comments and trailing commas.
- */
-async function readLooseJson(filePath) {
-    try {
-        const text = await fs.readFile(filePath, 'utf-8');
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            const noBlockComments = text.replace(/\/\*[\s\S]*?\*\//g, '');
-            const noLineComments = noBlockComments.replace(/(^|\s)\/\/.*$/gm, '$1');
-            const noTrailingCommas = noLineComments.replace(/,\s*([}\]])/g, '$1');
-            return JSON.parse(noTrailingCommas);
-        }
-    }
-    catch {
-        return null;
-    }
-}

package/dist/gates/hallucinated-imports/ts-path-target.js

@@ -1,6 +1,21 @@
 import fs from 'fs-extra';
 import path from 'path';
 const sourceExtensions = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.d.ts'];
+/** TypeScript ESM imports name the emitted file: `utils.js` for `utils.ts`. */
+const RUNTIME_TO_SOURCE = {
+    '.js': ['.ts', '.tsx', '.d.ts'],
+    '.jsx': ['.tsx'],
+    '.mjs': ['.mts', '.d.mts'],
+    '.cjs': ['.cts', '.d.cts'],
+};
+function sourceSiblings(target) {
+    const extension = path.extname(target);
+    const sources = RUNTIME_TO_SOURCE[extension];
+    if (!sources)
+        return [];
+    const base = target.slice(0, -extension.length);
+    return sources.map(source => base + source);
+}
 export async function resolveTsPathTarget(baseDir, candidatePattern, cwd, projectFiles) {
     const absolute = path.resolve(baseDir, candidatePattern);
     const relative = path.relative(cwd, absolute).replace(/\\/g, '/');
@@ -10,6 +25,7 @@ export async function resolveTsPathTarget(baseDir, candidatePattern, cwd, projec
     const candidates = [
         ...sourceExtensions.map(extension => normalized + extension),
         ...sourceExtensions.map(extension => `${normalized}/index${extension}`),
+        ...sourceSiblings(normalized),
     ];
     if (candidates.some(candidate => projectFiles.has(candidate)))
         return true;

package/dist/gates/hallucinated-imports/tsconfig-paths.d.ts

@@ -0,0 +1,16 @@
+export interface TsPathRule {
+    key: string;
+    hasWildcard: boolean;
+    prefix: string;
+    suffix: string;
+    targets: string[];
+}
+export interface TsPathConfig {
+    /** Directory `paths` targets are relative to: the effective baseUrl, else the declaring config's folder. */
+    baseDir: string;
+    rules: TsPathRule[];
+    /** Absolute `rootDirs`, each resolved against its declaring config. */
+    rootDirs: string[];
+}
+/** The first config in `searchDir` that defines `paths` or `rootDirs` (directly or inherited). */
+export declare function loadTsPathConfig(searchDir: string): Promise<TsPathConfig | null>;

package/dist/gates/hallucinated-imports/tsconfig-paths.js

@@ -0,0 +1,120 @@
+/**
+ * tsconfig `paths`, `baseUrl` and `rootDirs`, resolved the way tsc does.
+ *
+ * Each option is resolved against the config that declares it, not the one
+ * that extends it: SvelteKit's generated `.svelte-kit/tsconfig.json` says
+ * `"$lib": ["../src/lib"]`, which means `<repo>/src/lib`, not `<repo>/../src/lib`.
+ * A child's `paths` replaces its parent's; later entries of an `extends`
+ * array override earlier ones.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { Logger } from '../../utils/logger.js';
+const CONFIG_NAMES = ['tsconfig.json', 'jsconfig.json', 'tsconfig.base.json'];
+/** The first config in `searchDir` that defines `paths` or `rootDirs` (directly or inherited). */
+export async function loadTsPathConfig(searchDir) {
+    for (const name of CONFIG_NAMES) {
+        const configPath = path.join(searchDir, name);
+        if (!(await fs.pathExists(configPath)))
+            continue;
+        const effective = await readChain(configPath, new Set());
+        if (!effective.paths && !effective.rootDirs?.length)
+            continue;
+        return {
+            baseDir: effective.baseUrl ?? effective.paths?.dir ?? searchDir,
+            rules: toRules(effective.paths?.entries ?? {}),
+            rootDirs: effective.rootDirs ?? [],
+        };
+    }
+    return null;
+}
+async function readChain(configPath, visited) {
+    const resolved = path.resolve(configPath);
+    if (visited.has(resolved))
+        return {};
+    visited.add(resolved);
+    const parsed = await readLooseJson(resolved);
+    if (!parsed)
+        return {};
+    let effective = {};
+    for (const extendsPath of extendsList(parsed.extends)) {
+        const target = await resolveExtends(resolved, extendsPath);
+        if (target)
+            effective = { ...effective, ...await readChain(target, visited) };
+        else
+            warnMissingExtends(resolved, extendsPath);
+    }
+    const dir = path.dirname(resolved);
+    const options = parsed.compilerOptions ?? {};
+    if (typeof options.baseUrl === 'string')
+        effective.baseUrl = path.resolve(dir, options.baseUrl);
+    if (options.paths && typeof options.paths === 'object')
+        effective.paths = { entries: options.paths, dir };
+    if (Array.isArray(options.rootDirs)) {
+        effective.rootDirs = options.rootDirs.filter((r) => typeof r === 'string').map((r) => path.resolve(dir, r));
+    }
+    return effective;
+}
+function extendsList(value) {
+    if (typeof value === 'string')
+        return [value];
+    return Array.isArray(value) ? value.filter((v) => typeof v === 'string') : [];
+}
+async function resolveExtends(configPath, extendsPath) {
+    const base = extendsPath.startsWith('.') || path.isAbsolute(extendsPath)
+        ? path.resolve(path.dirname(configPath), extendsPath)
+        : path.resolve(path.dirname(configPath), 'node_modules', extendsPath);
+    for (const candidate of [base, `${base}.json`, path.join(base, 'tsconfig.json')]) {
+        if (await fs.pathExists(candidate) && (await fs.stat(candidate)).isFile())
+            return candidate;
+    }
+    return null;
+}
+function toRules(entries) {
+    const rules = [];
+    for (const [key, value] of Object.entries(entries)) {
+        if (!Array.isArray(value))
+            continue;
+        const targets = value.filter((v) => typeof v === 'string');
+        if (targets.length === 0)
+            continue;
+        const [prefix, suffix = ''] = key.split('*');
+        rules.push({ key, hasWildcard: key.includes('*'), prefix, suffix, targets });
+    }
+    // Exact keys first, then the longest wildcard prefix/suffix (tsc's precedence).
+    return rules.sort((left, right) => {
+        if (left.hasWildcard !== right.hasWildcard)
+            return left.hasWildcard ? 1 : -1;
+        return (right.prefix.length + right.suffix.length) - (left.prefix.length + left.suffix.length);
+    });
+}
+const warnedMissingExtends = new Set();
+/**
+ * A missing `extends` target drops its options. Say so once, instead of
+ * reporting every aliased import as missing without a reason.
+ */
+function warnMissingExtends(configPath, extendsPath) {
+    const key = `${configPath}\0${extendsPath}`;
+    if (warnedMissingExtends.has(key))
+        return;
+    warnedMissingExtends.add(key);
+    const hint = extendsPath.includes('.svelte-kit') ? ' Run `svelte-kit sync` first to generate it.' : '';
+    Logger.warn(`${path.basename(configPath)} extends '${extendsPath}', which does not exist; its path aliases are ignored.${hint}`);
+}
+/** JSON with comments and trailing commas, as tsconfig files allow. */
+async function readLooseJson(filePath) {
+    try {
+        const text = await fs.readFile(filePath, 'utf-8');
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const noBlockComments = text.replace(/\/\*[\s\S]*?\*\//g, '');
+            const noLineComments = noBlockComments.replace(/(^|\s)\/\/.*$/gm, '$1');
+            return JSON.parse(noLineComments.replace(/,\s*([}\]])/g, '$1'));
+        }
+    }
+    catch {
+        return null;
+    }
+}

package/dist/gates/hallucinated-imports-sveltekit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gates/hallucinated-imports-sveltekit.test.js

@@ -0,0 +1,108 @@
+/**
+ * SvelteKit on a fresh clone: `.svelte-kit/` (and its tsconfig with the
+ * `$lib` alias) does not exist until `svelte-kit sync` runs.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { HallucinatedImportsGate } from './hallucinated-imports/index.js';
+function write(root, rel, body) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), body);
+}
+async function missingImports(cwd) {
+    const failures = await new HallucinatedImportsGate().run({ cwd });
+    return failures.map(f => f.details).join('\n');
+}
+describe('HallucinatedImportsGate — SvelteKit', () => {
+    let cwd;
+    beforeEach(() => {
+        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'kit-imports-'));
+        write(cwd, 'package.json', JSON.stringify({ devDependencies: { '@sveltejs/kit': '2.0.0', svelte: '5.0.0' } }));
+        write(cwd, 'tsconfig.json', JSON.stringify({ extends: './.svelte-kit/tsconfig.json' }));
+        write(cwd, 'src/lib/format.ts', 'export const format = (n: number) => String(n);\n');
+        write(cwd, 'src/lib/components/badge.svelte', '<span><slot /></span>\n');
+    });
+    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
+    it('accepts kit virtual modules, generated $types, $lib and .svelte imports without svelte-kit sync', async () => {
+        write(cwd, 'src/routes/+page.ts', [
+            "import { goto } from '$app/navigation';",
+            "import { page } from '$app/state';",
+            "import { PUBLIC_API_URL } from '$env/static/public';",
+            "import { env } from '$env/dynamic/private';",
+            "import type { PageLoad } from './$types';",
+            "import { format } from '$lib/format';",
+            "import Badge from '$lib/components/badge.svelte';",
+            "import Local from '../lib/components/badge.svelte';",
+            'export const load: PageLoad = () => ({ goto, page, PUBLIC_API_URL, env, format, Badge, Local });',
+        ].join('\n'));
+        expect(await missingImports(cwd)).toBe('');
+    });
+    it('still flags a $lib import that points at no file', async () => {
+        write(cwd, 'src/routes/+page.ts', "import { gone } from '$lib/does-not-exist';\nexport const x = gone;\n");
+        expect(await missingImports(cwd)).toContain("'$lib/does-not-exist'");
+    });
+    it('still flags a missing relative .svelte component', async () => {
+        write(cwd, 'src/routes/+page.ts', "import Missing from './missing.svelte';\nexport const x = Missing;\n");
+        expect(await missingImports(cwd)).toContain("'./missing.svelte'");
+    });
+    it('still flags a real missing package in a kit project', async () => {
+        write(cwd, 'src/routes/+page.ts', "import made from 'package-that-does-not-exist';\nexport const x = made;\n");
+        expect(await missingImports(cwd)).toContain("'package-that-does-not-exist'");
+    });
+    it('does not treat $app or $lib as provided outside a SvelteKit project', async () => {
+        write(cwd, 'package.json', JSON.stringify({ dependencies: {} }));
+        write(cwd, 'src/index.ts', "import { goto } from '$app/navigation';\nimport { format } from '$lib/format';\nexport const x = [goto, format];\n");
+        const details = await missingImports(cwd);
+        expect(details).toContain("'$app/navigation'");
+        expect(details).toContain("'$lib/format'");
+    });
+    it('resolves a $lib import written with the emitted .js extension to its .ts source', async () => {
+        write(cwd, 'src/lib/utils.ts', 'export const cn = (...c: string[]) => c.join(" ");\n');
+        write(cwd, 'src/lib/components/button-variants.ts', "import { cn } from '$lib/utils.js';\nexport const x = cn;\n");
+        expect(await missingImports(cwd)).toBe('');
+    });
+    it('resolves a tsconfig path alias written with .js to its .ts source (any framework)', async () => {
+        write(cwd, 'package.json', JSON.stringify({ dependencies: {} }));
+        write(cwd, 'tsconfig.json', JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@/*': ['src/*'] } } }));
+        write(cwd, 'src/util/math.ts', 'export const add = (a: number, b: number) => a + b;\n');
+        write(cwd, 'src/index.ts', "import { add } from '@/util/math.js';\nexport const x = add;\n");
+        expect(await missingImports(cwd)).toBe('');
+    });
+    it('resolves inherited paths against the config that declares them (after svelte-kit sync)', async () => {
+        write(cwd, '.svelte-kit/tsconfig.json', JSON.stringify({
+            compilerOptions: { paths: { $lib: ['../src/lib'], '$lib/*': ['../src/lib/*'] }, rootDirs: ['..', './types'] },
+        }));
+        write(cwd, 'src/routes/+page.ts', "import { format } from '$lib/format';\nimport { gone } from '$lib/does-not-exist';\nexport const x = [format, gone];\n");
+        const details = await missingImports(cwd);
+        expect(details).not.toContain("'$lib/format'");
+        expect(details).toContain("'$lib/does-not-exist'");
+    });
+});
+describe('HallucinatedImportsGate — tsconfig inheritance and rootDirs', () => {
+    let cwd;
+    beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'tsconfig-inherit-')); });
+    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
+    it('resolves paths inherited from a shared base config against that config (Nx-style)', async () => {
+        write(cwd, 'package.json', JSON.stringify({ dependencies: {} }));
+        write(cwd, 'libs/tsconfig.base.json', JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { '@org/util': ['util/src/index.ts'] } } }));
+        write(cwd, 'libs/util/src/index.ts', 'export const util = 1;\n');
+        write(cwd, 'apps/web/tsconfig.json', JSON.stringify({ extends: '../../libs/tsconfig.base.json' }));
+        write(cwd, 'apps/web/src/main.ts', "import { util } from '@org/util';\nexport const x = util;\n");
+        expect(await missingImports(cwd)).toBe('');
+    });
+    it('resolves a relative import through rootDirs into a generated folder', async () => {
+        write(cwd, 'package.json', JSON.stringify({ dependencies: {} }));
+        write(cwd, 'tsconfig.json', JSON.stringify({ compilerOptions: { rootDirs: ['src', 'generated'] } }));
+        write(cwd, 'generated/schema.ts', 'export const schema = {};\n');
+        write(cwd, 'src/api.ts', "import { schema } from './schema';\nexport const x = schema;\n");
+        expect(await missingImports(cwd)).toBe('');
+    });
+    it('still flags a relative import found in no root', async () => {
+        write(cwd, 'package.json', JSON.stringify({ dependencies: {} }));
+        write(cwd, 'tsconfig.json', JSON.stringify({ compilerOptions: { rootDirs: ['src', 'generated'] } }));
+        write(cwd, 'src/api.ts', "import { schema } from './nowhere';\nexport const x = schema;\n");
+        expect(await missingImports(cwd)).toContain("'./nowhere'");
+    });
+});

package/dist/gates/logic-drift.js

@@ -22,6 +22,7 @@ import { Logger } from '../utils/logger.js';
 import { languageAdapters } from './language-adapters/index.js';
 import { extractCallSequence, isDangerousMutation } from './logic-drift-extractors.js';
 import { isGitWorktree, resolveGitLogicBase } from './logic-drift-git-base.js';
+import { isScoped } from '../utils/scope.js';
 import fs from 'fs-extra';
 import path from 'path';
 import crypto from 'crypto';
@@ -94,6 +95,11 @@ export class LogicDriftGate extends Gate {
                 Logger.debug('Failed to load logic baseline');
             }
         }
+        // A scoped run sees only some files: compare against the baseline but
+        // never create or overwrite it, or the rest of the repo drops out of it.
+        const scoped = isScoped(context.patterns);
+        if (!previousBaseline && scoped)
+            return [];
         if (!previousBaseline) {
             // First scan: save baseline, no comparisons yet
             const baseline = {
@@ -151,7 +157,7 @@ export class LogicDriftGate extends Gate {
             lastUpdated: new Date().toISOString(),
             scanCount: previousBaseline.scanCount + 1,
         };
-        if (!gitBase)
+        if (!gitBase && !scoped)
             await fs.writeJson(baselinePath, updatedBaseline, { spaces: 2 });
         if (failures.length > 0) {
             Logger.info(`Logic Drift: Found ${failures.length} logic mutations`);