@alex-dbs/coderuler 0.0.0-stage → 1.3.0

package/dist/adapter/filesystem/rule-resolution.js

@@ -0,0 +1,516 @@
+import { closeSync, constants, fstatSync, lstatSync, mkdtempSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { createRequire, isBuiltin, registerHooks } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import npa from 'npm-package-arg';
+import { ruleDependencyLockKey } from './dependencies.js';
+const SDK = '@alex-dbs/coderuler';
+const SDK_ENTRY = new URL(import.meta.url.endsWith('.ts') ? '../../index.ts' : '../../index.js', import.meta.url).href;
+// This prevents accidental ambient dependency borrowing, not deliberate escape:
+// trusted rule code can still use Node APIs, absolute paths, or custom loaders.
+const contexts = new Map();
+const commonJSDirectories = new Map();
+const sdkModules = new Set();
+const requireFromHere = createRequire(import.meta.url);
+const ownerKeys = new Map();
+const installations = new Map();
+const importScopes = new Map();
+const temporaryScopes = new Set();
+function record(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`Invalid ${label}`);
+    return value;
+}
+function json(path) {
+    return record(JSON.parse(readFileSync(path, 'utf8')), path);
+}
+function inside(root, filename) {
+    const path = relative(root, filename);
+    return path === '' || (!isAbsolute(path) && path !== '..' && !path.startsWith(`..${sep}`));
+}
+function filename(url) {
+    if (!url?.startsWith('file:'))
+        return undefined;
+    const path = fileURLToPath(url);
+    try {
+        return realpathSync(path);
+    }
+    catch (error) {
+        // createRequire's synthetic parent need not exist on disk.
+        if (error.code === 'ENOENT')
+            return path;
+        throw error;
+    }
+}
+function nameOf(specifier) {
+    return specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
+}
+function bare(specifier) {
+    return !specifier.startsWith('.') && !specifier.startsWith('#') && !isAbsolute(specifier) && !/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(specifier);
+}
+function contextKey(dependencies) {
+    return `${dependencies.directory}\0${dependencies.key}`;
+}
+function stale(dependencies, detail) {
+    return new Error(`Rule dependencies changed or installation is in progress in ${dependencies.directory}: ${detail}; rerun the command after coderuler deps sync completes. If the write mutex is stale, remove it only after confirming its owner exited`);
+}
+function regularText(path) {
+    if (!lstatSync(path).isFile())
+        throw new Error(`Not a regular, non-symlinked file: ${path}`);
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        if (!fstatSync(fd).isFile())
+            throw new Error(`Not a regular file: ${path}`);
+        return readFileSync(fd, 'utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function assertIdle(dependencies) {
+    const mutex = join(dependencies.directory, '.coderuler-deps-write');
+    try {
+        lstatSync(mutex);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw stale(dependencies, mutex);
+    }
+    throw stale(dependencies, mutex);
+}
+function snapshot(dependencies) {
+    const registeredKey = ownerKeys.get(dependencies.directory);
+    if (registeredKey !== undefined && registeredKey !== dependencies.key)
+        throw stale(dependencies, 'this process already loaded a different dependency snapshot for this owner');
+    assertIdle(dependencies);
+    try {
+        let text = null;
+        try {
+            text = regularText(join(dependencies.directory, 'coderuler.lock'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const lock = text === null ? null : record(JSON.parse(text), 'rule dependency lock');
+        if (ruleDependencyLockKey(lock, dependencies.directory) !== dependencies.key)
+            throw new Error('committed lock no longer matches the prepared context');
+        if (dependencies.key === 'empty') {
+            if (dependencies.directDependencies.length !== 0)
+                throw new Error('empty context has declared packages');
+            assertIdle(dependencies);
+            return undefined;
+        }
+        const packages = record(lock['packages'], 'rule dependency lock packages');
+        const direct = Object.keys(record(record(packages[''], 'root package')['dependencies'] ?? {}, 'direct dependencies')).sort();
+        if (JSON.stringify(direct) !== JSON.stringify([...dependencies.directDependencies].sort()))
+            throw new Error('direct dependencies no longer match');
+        const modules = join(dependencies.directory, 'node_modules');
+        if (!lstatSync(modules).isDirectory() || realpathSync(modules) !== modules)
+            throw new Error(`invalid local package directory ${modules}`);
+        const marker = record(JSON.parse(regularText(join(dependencies.directory, 'node_modules', '.coderuler-install.json'))), 'rule dependency installation marker');
+        if (marker['version'] !== 1 || marker['key'] !== dependencies.key || !Array.isArray(marker['installedLocations']))
+            throw new Error('local installation marker no longer matches');
+        if (direct.some(name => !marker['installedLocations'].includes(`node_modules/${name}`)))
+            throw new Error('local installation omits a direct dependency');
+        const installed = installations.get(contextKey(dependencies));
+        if (installed !== undefined && installed.marker !== JSON.stringify(marker))
+            throw new Error('local installation metadata changed during this command');
+        assertIdle(dependencies);
+        return { lock: lock, marker };
+    }
+    catch (error) {
+        throw stale(dependencies, error instanceof Error ? error.message : String(error));
+    }
+}
+export function assertRuleDependenciesCurrent(dependencies) {
+    snapshot(dependencies);
+}
+function installationFor(dependencies) {
+    const current = snapshot(dependencies);
+    if (current === undefined)
+        return undefined;
+    const key = contextKey(dependencies);
+    const existing = installations.get(key);
+    if (existing !== undefined)
+        return existing;
+    const root = join(dependencies.directory, 'node_modules');
+    const packages = record(current.lock['packages'], 'rule dependency lock packages');
+    const installed = [];
+    for (const location of current.marker['installedLocations']) {
+        if (typeof location !== 'string' || !/^node_modules\/(?:@[^/]+\/)?[^/]+(?:\/node_modules\/(?:@[^/]+\/)?[^/]+)*$/.test(location)) {
+            throw stale(dependencies, 'invalid installed package location');
+        }
+        const packageRoot = join(dependencies.directory, location);
+        if (!inside(root, packageRoot) || realpathSync(packageRoot) !== packageRoot)
+            throw stale(dependencies, `invalid package directory ${packageRoot}`);
+        const manifest = record(packages[location], `lock package ${location}`);
+        const declarations = new Set();
+        for (const field of ['dependencies', 'optionalDependencies', 'peerDependencies']) {
+            if (manifest[field] !== undefined) {
+                for (const name of Object.keys(record(manifest[field], `${location} ${field}`)))
+                    declarations.add(name);
+            }
+        }
+        const segments = location.split('/');
+        const last = segments.at(-1);
+        const scope = segments.at(-2);
+        const name = scope.startsWith('@') ? `${scope}/${last}` : last;
+        const actual = json(join(packageRoot, 'package.json'));
+        if (actual['name'] !== name || actual['version'] !== manifest['version'])
+            throw stale(dependencies, `package ${name} does not match the lock`);
+        installed.push({ root: packageRoot, name, declarations });
+    }
+    installed.sort((left, right) => right.root.length - left.root.length);
+    // Node stops package-scope/self-reference lookup at node_modules. Keep the
+    // synthetic parent there so an ancestor application's exports cannot shadow
+    // a declared dependency; Node still performs normal package/exports lookup.
+    const parentURL = pathToFileURL(join(root, '.coderuler-resolve.cjs')).href;
+    const installation = { dependencies, marker: JSON.stringify(current.marker), root, packages: installed, require: createRequire(parentURL), parentURL };
+    installations.set(key, installation);
+    return installation;
+}
+function managedPackage(installation, path) {
+    return installation.packages.find(pkg => inside(pkg.root, path));
+}
+function packageContext(path) {
+    for (const installation of installations.values()) {
+        if (!inside(installation.root, path))
+            continue;
+        assertRuleDependenciesCurrent(installation.dependencies);
+        const pkg = managedPackage(installation, path);
+        if (pkg !== undefined)
+            return { installation, pkg };
+    }
+    return undefined;
+}
+function conflict(path) {
+    return new Error(`Rule helper ${path} has conflicting dependency contexts; use separate helper directories for rules with different locks`);
+}
+function reserveCommonJS(path, dependencies) {
+    const directory = dirname(path);
+    const previous = commonJSDirectories.get(directory);
+    if (previous !== undefined && previous !== contextKey(dependencies))
+        throw conflict(directory);
+    for (const cached of Object.keys(requireFromHere.cache)) {
+        const physical = filename(pathToFileURL(cached).href);
+        if (dirname(physical) !== directory || sdkModules.has(physical))
+            continue;
+        const owner = contexts.get(physical);
+        if (owner === undefined) {
+            throw new Error(`Rule helper directory ${directory} contains an already-loaded unowned CommonJS module ${physical}; use a separate helper directory`);
+        }
+        if (contextKey(owner) !== contextKey(dependencies))
+            throw conflict(directory);
+    }
+    commonJSDirectories.set(directory, contextKey(dependencies));
+}
+// Absolute public SDK entries are supported too (for example a caller-selected
+// SDK copy). Only the public entry is exempted here, not every file in its
+// containing package, which may itself contain authored rules.
+function sdkEntry(path) {
+    if (sdkModules.has(path))
+        return true;
+    if (path === filename(SDK_ENTRY)) {
+        sdkModules.add(path);
+        return true;
+    }
+    let directory = dirname(path);
+    for (;;) {
+        let manifest;
+        try {
+            manifest = json(join(directory, 'package.json'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            const above = dirname(directory);
+            if (above === directory)
+                return false;
+            directory = above;
+            continue;
+        }
+        if (manifest['name'] !== SDK)
+            return false;
+        const exports = manifest['exports'];
+        const targets = [exports !== null && typeof exports === 'object' && !Array.isArray(exports) && '.' in exports ? exports['.'] : exports ?? manifest['main']];
+        while (targets.length > 0) {
+            const target = targets.pop();
+            if (typeof target === 'string' && filename(pathToFileURL(join(directory, target)).href) === path) {
+                sdkModules.add(path);
+                return true;
+            }
+            if (target !== null && typeof target === 'object')
+                targets.push(...Object.values(target));
+        }
+        return false;
+    }
+}
+function attach(path, dependencies) {
+    const previous = contexts.get(path);
+    if (previous === undefined && (sdkEntry(path) || packageContext(path) !== undefined))
+        return;
+    if (previous !== undefined && contextKey(previous) !== contextKey(dependencies))
+        throw conflict(path);
+    if (previous === undefined && requireFromHere.cache[path] !== undefined) {
+        throw new Error(`Rule helper ${path} is an already-loaded unowned CommonJS module; use a separate helper directory`);
+    }
+    contexts.set(path, dependencies);
+    if (path.endsWith('.cjs') || requireFromHere.cache[path] !== undefined)
+        reserveCommonJS(path, dependencies);
+}
+export function registerRuleDependencies(ruleFile, dependencies) {
+    installationFor(dependencies);
+    attach(realpathSync(ruleFile), dependencies);
+    ownerKeys.set(dependencies.directory, dependencies.key);
+}
+export function getRuleDependencies(ruleFile) {
+    return contexts.get(realpathSync(ruleFile));
+}
+function undeclared(name, dependencies) {
+    return new Error(`Rule dependency ${name} is not declared in ${join(dependencies.directory, 'coderuler.lock')}; run coderuler deps add ${name}`);
+}
+function requireCondition(conditions) {
+    const requiring = conditions.includes('require');
+    if (requiring && conditions.includes('import'))
+        throw new Error('Ambiguous rule dependency resolution: both import and require conditions are active');
+    return requiring;
+}
+const resolveSdk = (specifier, context, nextResolve) => {
+    let result;
+    try {
+        result = nextResolve(specifier, context);
+    }
+    catch (error) {
+        if (error.code !== 'ERR_MODULE_NOT_FOUND' && error.code !== 'MODULE_NOT_FOUND')
+            throw error;
+        // CommonJS nextResolve expects a filename, not a file URL. Only missing
+        // packages use the running SDK fallback; export-condition errors propagate.
+        result = nextResolve(requireCondition(context.conditions) ? fileURLToPath(SDK_ENTRY) : SDK_ENTRY, context);
+    }
+    const path = filename(result.url);
+    if (path !== undefined)
+        sdkModules.add(path);
+    return result;
+};
+// Node, rather than a second implementation of its imports/conditions algorithm,
+// resolves #imports in a package scope with managed dependencies. Source links
+// canonicalize back to the real helpers without modifying the owner.
+function importScope(parent, installation, dependencies) {
+    let directory = dirname(parent);
+    let manifest;
+    for (;;) {
+        try {
+            manifest = json(join(directory, 'package.json'));
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const above = dirname(directory);
+        if (above === directory)
+            return undefined;
+        directory = above;
+    }
+    if (manifest['imports'] === undefined)
+        return undefined;
+    const key = `${directory}\0${contextKey(dependencies)}`;
+    const existing = importScopes.get(key);
+    if (existing !== undefined)
+        return existing;
+    // Resolution metadata is process-owned, including for read-only owners.
+    const scope = mkdtempSync(join(realpathSync(tmpdir()), 'coderuler-resolution-'));
+    temporaryScopes.add(scope);
+    try {
+        const denied = new Map();
+        const sourceRoots = [];
+        const ownName = manifest['exports'] == null ? undefined : manifest['name'];
+        let targetsDirectory;
+        let sdkTarget;
+        const restrictTargets = (value) => {
+            if (typeof value === 'string') {
+                if (value === SDK) {
+                    // Let Node select this exact public target through its normal
+                    // conditions/arrays/patterns, then resolve it from the real importer
+                    // to retain local SDK preference and the source-checkout fallback.
+                    targetsDirectory ??= mkdtempSync(join(scope, '.coderuler-targets-'));
+                    if (sdkTarget === undefined) {
+                        sdkTarget = join(targetsDirectory, 'sdk');
+                        writeFileSync(sdkTarget, '');
+                    }
+                    return `./${relative(scope, sdkTarget).split(sep).join('/')}`;
+                }
+                const name = nameOf(value);
+                if (!bare(value) || isBuiltin(value) || name === ownName || dependencies.directDependencies.includes(name))
+                    return value;
+                try {
+                    const candidate = name.replaceAll('*', 'coderuler-pattern');
+                    const parsed = npa(candidate);
+                    if (parsed.name !== candidate || !parsed.registry || parsed.rawSpec !== '*')
+                        return value;
+                }
+                catch {
+                    return value;
+                }
+                // Preserve Node's condition/array/pattern selection, but turn an
+                // undeclared external target into an identifiable local resolution.
+                // It can never reach application, NODE_PATH, or ancestor packages.
+                targetsDirectory ??= mkdtempSync(join(scope, '.coderuler-targets-'));
+                const marker = join(targetsDirectory, String(denied.size));
+                writeFileSync(marker, '');
+                denied.set(marker, name);
+                return `./${relative(scope, marker).split(sep).join('/')}`;
+            }
+            if (Array.isArray(value))
+                return value.map(restrictTargets);
+            if (value !== null && typeof value === 'object') {
+                return Object.fromEntries(Object.entries(value).map(([name, target]) => [name, restrictTargets(target)]));
+            }
+            return value;
+        };
+        const metadata = {};
+        for (const field of ['name', 'type', 'imports', 'exports']) {
+            if (manifest[field] !== undefined)
+                metadata[field] = field === 'imports' ? restrictTargets(manifest[field]) : manifest[field];
+        }
+        writeFileSync(join(scope, 'package.json'), JSON.stringify(metadata));
+        if (installation === undefined)
+            mkdirSync(join(scope, 'node_modules'));
+        else
+            symlinkSync(installation.root, join(scope, 'node_modules'), 'junction');
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name === 'package.json')
+                continue;
+            // Avoid mirroring process-owned resolution storage back into itself.
+            if (inside(join(directory, entry.name), scope))
+                continue;
+            symlinkSync(join(directory, entry.name), join(scope, entry.name), entry.isDirectory() ? 'junction' : 'file');
+            sourceRoots.push(filename(pathToFileURL(join(directory, entry.name)).href));
+        }
+        const parentURL = pathToFileURL(join(scope, '.coderuler-imports.cjs')).href;
+        const prepared = {
+            parentURL, require: createRequire(parentURL),
+            metadata: join(scope, 'package.json'), sourceMetadata: join(directory, 'package.json'),
+            denied, sdkTarget, sourceRoots,
+        };
+        importScopes.set(key, prepared);
+        return prepared;
+    }
+    catch (error) {
+        rmSync(scope, { recursive: true, force: true });
+        temporaryScopes.delete(scope);
+        throw error;
+    }
+}
+process.once('exit', () => {
+    for (const scope of temporaryScopes) {
+        try {
+            rmSync(scope, { recursive: true, force: true });
+        }
+        catch { /* Best-effort process-owned resolution cleanup. */ }
+    }
+});
+registerHooks({
+    resolve(specifier, context, nextResolve) {
+        const parent = filename(context.parentURL);
+        const dependencies = parent === undefined || sdkModules.has(parent) ? undefined : contexts.get(parent);
+        const owner = parent === undefined || sdkModules.has(parent) ? undefined : packageContext(parent);
+        if (dependencies !== undefined)
+            assertRuleDependenciesCurrent(dependencies);
+        if (isBuiltin(specifier))
+            return nextResolve(specifier, context);
+        if (specifier === SDK)
+            return resolveSdk(specifier, context, nextResolve);
+        if (parent === undefined || (dependencies === undefined && owner === undefined))
+            return nextResolve(specifier, context);
+        const requiring = requireCondition(context.conditions);
+        if (owner !== undefined) {
+            if (bare(specifier)) {
+                const name = nameOf(specifier);
+                if (name !== owner.pkg.name && !owner.pkg.declarations.has(name)) {
+                    throw new Error(`Managed package ${owner.pkg.name} imports undeclared dependency ${name}`);
+                }
+            }
+            const result = nextResolve(specifier, context);
+            const target = filename(result.url);
+            if (target !== undefined && !inside(owner.installation.root, target)) {
+                throw new Error(`Managed package ${owner.pkg.name} resolved ${specifier} outside its rule dependency node_modules`);
+            }
+            if (specifier.startsWith('#') && target !== undefined) {
+                const imported = managedPackage(owner.installation, target);
+                if (imported !== undefined && imported.name !== owner.pkg.name && !owner.pkg.declarations.has(imported.name)) {
+                    throw new Error(`Managed package ${owner.pkg.name} imports undeclared dependency ${imported.name}`);
+                }
+            }
+            return result;
+        }
+        const prepared = dependencies;
+        const installation = installationFor(prepared);
+        let result;
+        if (bare(specifier)) {
+            const name = nameOf(specifier);
+            if (!prepared.directDependencies.includes(name) || installation === undefined)
+                throw undeclared(name, prepared);
+            result = requiring
+                ? nextResolve(installation.require.resolve(specifier), context)
+                : nextResolve(specifier, { ...context, parentURL: installation.parentURL });
+            const target = filename(result.url);
+            if (target === undefined || !inside(installation.root, target))
+                throw new Error(`Rule dependency ${name} resolved outside its prepared node_modules`);
+            return result;
+        }
+        let scope;
+        if (specifier.startsWith('#')) {
+            // Node merges nextResolve's context into this hook's context in place.
+            // Retain the real importer before resolving through the temporary scope.
+            const importerContext = { ...context };
+            scope = importScope(parent, installation, prepared);
+            result = scope === undefined ? nextResolve(specifier, context) : requiring
+                ? nextResolve(scope.require.resolve(specifier), context)
+                : nextResolve(specifier, { ...context, parentURL: scope.parentURL });
+            const denied = scope === undefined ? undefined : scope.denied.get(filename(result.url));
+            if (denied !== undefined)
+                throw undeclared(denied, prepared);
+            if (scope?.sdkTarget !== undefined && filename(result.url) === scope.sdkTarget) {
+                return resolveSdk(SDK, importerContext, nextResolve);
+            }
+            if (scope !== undefined && filename(result.url) === scope.metadata) {
+                result = nextResolve(requiring ? scope.sourceMetadata : pathToFileURL(scope.sourceMetadata).href, context);
+            }
+        }
+        else
+            result = nextResolve(specifier, context);
+        const target = filename(result.url);
+        if (target === undefined)
+            return result;
+        const pkg = installation === undefined ? undefined : managedPackage(installation, target);
+        if (pkg !== undefined) {
+            if (specifier.startsWith('#') && !prepared.directDependencies.includes(pkg.name))
+                throw undeclared(pkg.name, prepared);
+            return result;
+        }
+        if (scope !== undefined && target !== scope.sourceMetadata && !scope.sourceRoots.some(root => inside(root, target))) {
+            throw new Error(`Rule import ${specifier} resolved outside its source helpers and prepared node_modules`);
+        }
+        attach(target, prepared);
+        return result;
+    },
+    load(url, context, nextLoad) {
+        const path = filename(url);
+        const dependencies = path === undefined ? undefined : contexts.get(path);
+        if (dependencies !== undefined)
+            assertRuleDependenciesCurrent(dependencies);
+        if (path !== undefined)
+            packageContext(path);
+        const result = nextLoad(url, context);
+        if (dependencies !== undefined)
+            assertRuleDependenciesCurrent(dependencies);
+        if (path !== undefined && dependencies !== undefined && result.format?.startsWith('commonjs')) {
+            reserveCommonJS(path, dependencies);
+        }
+        return result;
+    },
+});

package/dist/adapter/filesystem/rule-test-worker.d.ts

@@ -0,0 +1,17 @@
+import type { RuleTestCase } from '../../app/rule-tests.js';
+import type { PreparedRuleDependencies } from './dependencies.js';
+export interface RuleTestWorkerRequest {
+    readonly id: number;
+    readonly root: string;
+    readonly ruleFile: string;
+    readonly files: RuleTestCase['files'];
+    readonly ai: boolean;
+    readonly dependencies?: PreparedRuleDependencies;
+}
+export type RuleTestWorkerMessage = {
+    readonly id: number;
+    readonly actual: RuleTestCase['expected'];
+} | {
+    readonly id: number;
+    readonly error: string;
+};

package/dist/adapter/filesystem/rule-test-worker.js

@@ -0,0 +1,47 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve, sep, win32 } from 'node:path';
+import { parentPort } from 'node:worker_threads';
+import { executeRules } from '../../app/execute.js';
+import { createDecisionResolver } from '../../infra/settings.js';
+import { createProject } from './project.js';
+import { createRuleLoader } from './rules.js';
+function fixturePath(root, filepath) {
+    const target = resolve(root, filepath);
+    if (isAbsolute(filepath) || win32.isAbsolute(filepath) || !target.startsWith(`${root}${sep}`)) {
+        throw new Error(`Fixture path "${filepath}" must be relative and stay inside the test project`);
+    }
+    return target;
+}
+async function runCase({ root, ruleFile, files, ai, dependencies }) {
+    for (const [filepath, source] of Object.entries(files)) {
+        const target = fixturePath(root, filepath);
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, typeof source === 'string' ? source : JSON.stringify(source, null, 2), 'utf8');
+    }
+    const rules = await createRuleLoader(dependencies === undefined ? {} : { preparedDependencies: dependencies }).load({ root, explicit: ruleFile, invocationCwd: root });
+    if (rules.length !== 1)
+        throw new Error('Expected exactly one freshly loaded rule');
+    const reports = await executeRules(rules, {
+        project: createProject(root, { excludeFiles: [ruleFile] }),
+        isTarget: () => true,
+        concurrency: 1,
+        resolveDecision: ai ? createDecisionResolver(process.env) : () => {
+            throw new Error('Inline rule tests must not call the decision backend');
+        },
+    });
+    const report = reports[0];
+    if (reports.length !== 1 || report === undefined)
+        throw new Error('Expected exactly one rule report');
+    return report.status;
+}
+const port = parentPort;
+if (port === null)
+    throw new Error('Rule test cases must run in a worker');
+port.start();
+port.ref();
+port.on('message', (request) => {
+    void runCase(request).then(actual => port.postMessage({ id: request.id, actual }), error => port.postMessage({
+        id: request.id,
+        error: error instanceof Error ? error.message : String(error),
+    }));
+});

package/dist/adapter/filesystem/rule-tests.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedRule } from '../../app/ports.js';
+import type { RuleTestResult } from '../../app/rule-tests.js';
+export declare function runRuleTests(rules: readonly LoadedRule[], onResult?: (result: RuleTestResult, lastInRule: boolean) => void, timeoutMs?: number, concurrency?: number, includeAI?: boolean): Promise<readonly RuleTestResult[]>;