@thethracian/oxlint-config 0.2.1 → 0.3.1

package/dist/rules/effect-rule-core.js

@@ -1,18 +1,20 @@
-import { stripComments, stripCommentsAndStrings } from './effect-source-helpers.js';
+/* -------------------------------------------------------------------------- */
+/*      Core runtime for source-backed and AST-backed Effect lint rules.      */
+/* -------------------------------------------------------------------------- */
+import { canonicalizeEffectAPIAliases } from './effect-rule-aliases.js';
+import { effectDiagnosticMessage } from './diagnostic-guidance.js';
 import { readCachedSource } from './source-cache.js';
+import { stripCommentsAndStrings } from './effect-source-helpers.js';
 const LINE_START_CACHE_MAX = 256;
 const TOKEN_GATE_CACHE_MAX = 512;
+const CHAR_CODE_NEWLINE = 10;
 const lineStartCache = new Map();
 const globalPatternCache = new WeakMap();
 const tokenGateCache = new WeakMap();
 const sourceTokenPresenceCache = new Map();
-function readSource(context) {
-    return readCachedSource(context);
-}
-function isCodeAt(strippedSource, index) {
-    return strippedSource[index]?.trim() !== '';
-}
-function hasPattern(source, patterns) {
+const readSource = (context) => readCachedSource(context);
+const isCodeAt = (strippedSource, index) => strippedSource[index]?.trim() !== '';
+const hasPattern = (source, patterns) => {
     let strippedSource = undefined;
     return patterns.some((pattern) => {
         for (const match of source.matchAll(toGlobalRegExp(pattern))) {
@@ -23,41 +25,50 @@ function hasPattern(source, patterns) {
         }
         return false;
     });
-}
-function toGlobalRegExp(pattern) {
+};
+const toGlobalRegExp = (pattern) => {
     const cachedPattern = globalPatternCache.get(pattern);
     if (cachedPattern !== undefined) {
         return cachedPattern;
     }
-    const globalPattern = new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`);
+    let { flags } = pattern;
+    if (!flags.includes('g')) {
+        flags = `${flags}g`;
+    }
+    const globalPattern = new RegExp(pattern.source, flags);
     globalPatternCache.set(pattern, globalPattern);
     return globalPattern;
-}
-function cachedLineStarts(source) {
-    return lineStartCache.get(source);
-}
-function lineStartsFor(source) {
-    const cachedStarts = cachedLineStarts(source);
-    if (cachedStarts !== undefined) {
-        return cachedStarts;
+};
+const cachedLineStarts = (source) => lineStartCache.get(source);
+const evictFirstLineStart = () => {
+    if (lineStartCache.size < LINE_START_CACHE_MAX) {
+        return;
+    }
+    const firstKey = lineStartCache.keys().next().value;
+    if (firstKey !== undefined) {
+        lineStartCache.delete(firstKey);
     }
+};
+const computeLineStarts = (source) => {
     const starts = [0];
     for (let position = 0; position < source.length; position++) {
-        if (source.charCodeAt(position) === 10) {
+        if (source.charCodeAt(position) === CHAR_CODE_NEWLINE) {
             starts.push(position + 1);
         }
     }
-    if (lineStartCache.size >= LINE_START_CACHE_MAX) {
-        const firstKey = lineStartCache.keys().next().value;
-        if (firstKey !== undefined) {
-            lineStartCache.delete(firstKey);
-        }
+    return starts;
+};
+const lineStartsFor = (source) => {
+    const cachedStarts = cachedLineStarts(source);
+    if (cachedStarts !== undefined) {
+        return cachedStarts;
     }
+    const starts = computeLineStarts(source);
+    evictFirstLineStart();
     lineStartCache.set(source, starts);
     return starts;
-}
-function locFromIndex(source, index) {
-    const starts = lineStartsFor(source);
+};
+const lineIndexFor = (starts, index) => {
     let low = 0;
     let high = starts.length - 1;
     while (low <= high) {
@@ -70,50 +81,57 @@ function locFromIndex(source, index) {
             high = middle - 1;
         }
     }
-    const lineIndex = Math.max(0, high);
+    return Math.max(0, high);
+};
+const locFromIndex = (source, index) => {
+    const starts = lineStartsFor(source);
+    const lineIndex = lineIndexFor(starts, index);
     const lineStart = starts[lineIndex] ?? 0;
     const line = lineIndex + 1;
     return { column: index - lineStart, line };
-}
-function firstPatternLoc(source, patterns) {
+};
+const firstPatternLOC = (source, patterns) => {
     let strippedSource = undefined;
     for (const pattern of patterns) {
         for (const match of source.matchAll(toGlobalRegExp(pattern))) {
             strippedSource ??= stripCommentsAndStrings(source);
-            if (!isCodeAt(strippedSource, match.index)) {
-                continue;
+            if (isCodeAt(strippedSource, match.index)) {
+                return locFromIndex(source, match.index);
             }
-            return locFromIndex(source, match.index);
         }
     }
     return undefined;
-}
-function reportPatternMatches(input) {
+};
+const reportPatternMatches = (input) => {
     const { context, node, source, spec } = input;
+    const message = effectDiagnosticMessage(spec.name, spec.message);
     if (!spec.countPatterns) {
         context.report({
-            loc: firstPatternLoc(source, spec.patterns ?? []),
-            message: spec.message,
+            loc: firstPatternLOC(source, spec.patterns ?? []),
+            message,
             node,
         });
         return;
     }
+    reportCountedPatternMatches(input, message);
+};
+const reportCountedPatternMatches = (input, message) => {
+    const { context, node, source, spec } = input;
     let strippedSource = undefined;
-    for (const pattern of spec.countPatterns) {
+    for (const pattern of spec.countPatterns ?? []) {
         for (const match of source.matchAll(toGlobalRegExp(pattern))) {
             strippedSource ??= stripCommentsAndStrings(source);
-            if (!isCodeAt(strippedSource, match.index)) {
-                continue;
+            if (isCodeAt(strippedSource, match.index)) {
+                context.report({
+                    loc: locFromIndex(source, match.index),
+                    message,
+                    node,
+                });
             }
-            context.report({
-                loc: locFromIndex(source, match.index),
-                message: spec.message,
-                node,
-            });
         }
     }
-}
-function checkResultIndex(result) {
+};
+const checkResultIndex = (result) => {
     if (typeof result === 'number') {
         return result;
     }
@@ -121,11 +139,14 @@ function checkResultIndex(result) {
         return result.index;
     }
     return undefined;
-}
-function isCheckViolation(result) {
-    return typeof result === 'boolean' ? result : true;
-}
-function cachedSourceTokenPresence(source) {
+};
+const isCheckViolation = (result) => {
+    if (typeof result === 'boolean') {
+        return result;
+    }
+    return true;
+};
+const cachedSourceTokenPresence = (source) => {
     let tokenPresence = sourceTokenPresenceCache.get(source);
     if (tokenPresence !== undefined) {
         return tokenPresence;
@@ -139,8 +160,8 @@ function cachedSourceTokenPresence(source) {
     tokenPresence = new Map();
     sourceTokenPresenceCache.set(source, tokenPresence);
     return tokenPresence;
-}
-function hasTokenInSourceCached(source, token) {
+};
+const hasTokenInSourceCached = (source, token) => {
     const tokenPresence = cachedSourceTokenPresence(source);
     const cachedValue = tokenPresence.get(token);
     if (cachedValue !== undefined) {
@@ -149,14 +170,10 @@ function hasTokenInSourceCached(source, token) {
     const hasToken = source.includes(token);
     tokenPresence.set(token, hasToken);
     return hasToken;
-}
-function hasAnyToken(source, tokens) {
-    return tokens.some((token) => hasTokenInSourceCached(source, token));
-}
-function cachedTokenGate(source, tokens) {
-    return tokenGateCache.get(tokens)?.get(source);
-}
-function cacheTokenGate(source, tokens, hasToken) {
+};
+const hasAnyToken = (source, tokens) => tokens.some((token) => hasTokenInSourceCached(source, token));
+const cachedTokenGate = (source, tokens) => tokenGateCache.get(tokens)?.get(source);
+const cacheTokenGate = (source, tokens, hasToken) => {
     let sourceCache = tokenGateCache.get(tokens);
     if (!sourceCache) {
         sourceCache = new Map();
@@ -170,77 +187,96 @@ function cacheTokenGate(source, tokens, hasToken) {
     }
     sourceCache.set(source, hasToken);
     return hasToken;
-}
-function hasAnyTokenCached(source, tokens) {
+};
+const hasAnyTokenCached = (source, tokens) => {
     const cachedValue = cachedTokenGate(source, tokens);
     if (cachedValue !== undefined) {
         return cachedValue;
     }
     return cacheTokenGate(source, tokens, hasAnyToken(source, tokens));
-}
-function hasEveryTokenGroup(source, tokenGroups) {
-    return tokenGroups.every((group) => hasAnyTokenCached(source, group));
-}
-function shouldSkipSource(source, requiredTokens, requiredTokenGroups) {
-    return (source === '' ||
-        Boolean(requiredTokens && !hasAnyTokenCached(source, requiredTokens)) ||
-        Boolean(requiredTokenGroups && !hasEveryTokenGroup(source, requiredTokenGroups)));
-}
-function runProgramRule(input) {
+};
+const hasEveryTokenGroup = (source, tokenGroups) => tokenGroups.every((group) => hasAnyTokenCached(source, group));
+const shouldSkipSource = (source, requiredTokens, requiredTokenGroups) => source === '' ||
+    Boolean(requiredTokens && !hasAnyTokenCached(source, requiredTokens)) ||
+    Boolean(requiredTokenGroups && !hasEveryTokenGroup(source, requiredTokenGroups));
+const checkResultLOC = (source, spec, checkResult) => {
+    const index = checkResultIndex(checkResult);
+    if (index !== undefined) {
+        return locFromIndex(source, index);
+    }
+    return firstPatternLOC(source, spec.patterns ?? []);
+};
+const reportCheckResult = (context, node, source, spec, checkResult) => {
+    context.report({
+        loc: checkResultLOC(source, spec, checkResult),
+        message: effectDiagnosticMessage(spec.name, spec.message),
+        node,
+    });
+};
+const guidedContext = (context, spec) => ({
+    get filename() {
+        return context.filename;
+    },
+    get options() {
+        return context.options;
+    },
+    report(descriptor) {
+        context.report({
+            ...descriptor,
+            message: effectDiagnosticMessage(spec.name, descriptor.message),
+        });
+    },
+    get sourceCode() {
+        return context.sourceCode;
+    },
+});
+const runProgramRule = (input) => {
     const { context, node, source, spec } = input;
-    const canonicalSource = canonicalizeEffectApiAliases(source);
+    const canonicalSource = canonicalizeEffectAPIAliases(source);
     const checkResult = spec.check?.(canonicalSource, context);
     if (checkResult !== undefined) {
         if (!isCheckViolation(checkResult)) {
             return;
         }
-        const index = checkResultIndex(checkResult);
-        context.report({
-            loc: index === undefined
-                ? firstPatternLoc(canonicalSource, spec.patterns ?? [])
-                : locFromIndex(canonicalSource, index),
-            message: spec.message,
-            node,
-        });
+        reportCheckResult(context, node, canonicalSource, spec, checkResult);
         return;
     }
     if (hasPattern(canonicalSource, spec.patterns ?? [])) {
         reportPatternMatches({ context, node, source: canonicalSource, spec });
     }
-}
-function makeProgramOnlyRule(spec, options) {
+};
+const makeProgramOnlyRule = (spec, options) => {
     const requiredTokens = spec.tokens ?? options.defaultTokens;
     const requiredTokenGroups = spec.tokenGroups;
-    const rule = makeAstCapableRule(spec, options);
+    const rule = makeASTCapableRule(spec, options);
     return {
         ...rule,
         createOnce(context) {
             let source = '';
             let isSkipped = true;
             return {
-                before() {
-                    source = readSource(context);
-                    isSkipped = shouldSkipSource(source, requiredTokens, requiredTokenGroups);
-                    return isSkipped ? false : undefined;
-                },
                 Program(node) {
                     if (isSkipped) {
                         return;
                     }
                     runProgramRule({ context, node, source, spec });
                 },
+                before() {
+                    source = readSource(context);
+                    isSkipped = shouldSkipSource(source, requiredTokens, requiredTokenGroups);
+                    if (isSkipped) {
+                        return false;
+                    }
+                    return undefined;
+                },
             };
         },
     };
-}
-function makeAstCapableRule(spec, options) {
+};
+const makeASTCapableRule = (spec, options) => {
     const requiredTokens = spec.tokens ?? options.defaultTokens;
     const requiredTokenGroups = spec.tokenGroups;
     const rule = {
-        meta: {
-            schema: options.schema,
-            type: 'problem',
-        },
         create(context) {
             const source = readSource(context);
             if (shouldSkipSource(source, requiredTokens, requiredTokenGroups)) {
@@ -248,7 +284,8 @@ function makeAstCapableRule(spec, options) {
                     Program() { },
                 };
             }
-            const astVisitors = spec.ast?.(context, source) ?? {};
+            const astContext = guidedContext(context, spec);
+            const astVisitors = spec.ast?.(astContext, source) ?? {};
             return {
                 ...astVisitors,
                 Program(node) {
@@ -259,251 +296,27 @@ function makeAstCapableRule(spec, options) {
                 },
             };
         },
+        meta: {
+            docs: {
+                description: effectDiagnosticMessage(spec.name, spec.message),
+            },
+            schema: options.schema,
+            type: 'problem',
+        },
     };
     return rule;
-}
-function makeProgramRule(spec, options) {
-    return spec.ast ? makeAstCapableRule(spec, options) : makeProgramOnlyRule(spec, options);
-}
-function makeRules(specs, options = {}) {
-    return Object.fromEntries(specs.map((spec) => [spec.name, makeProgramRule(spec, options)]));
-}
-function hasEffectSignal(source) {
-    const cachedValue = cachedBoolean(effectSignalCache, source);
-    if (cachedValue !== undefined) {
-        return cachedValue;
-    }
-    if (!source.includes('Effect') && !source.includes('effect')) {
-        return cacheBoolean(effectSignalCache, source, false);
-    }
-    const codeOnly = stripCommentsAndStrings(source);
-    return cacheBoolean(effectSignalCache, source, hasEffectValueImport(source) ||
-        effectImportAliases(source).some((alias) => new RegExp(`\\b${escapeRegExp(alias)}\\.`, 'u').test(codeOnly)));
-}
-const runtimeCallPattern = /\b(?:Effect\.(?:runPromise|runPromiseExit|runSync|runSyncExit|runFork)|[A-Za-z_$][\w$]*Runtime\.runMain)\s*\(/;
-const boundaryFilePattern = /(?:^|\/)src\/(?:main|server|cli)\.ts$|\.entry\.ts$/;
-const testFilePattern = /\.(?:test|spec)\.tsx?$/;
-const ALIAS_CACHE_MAX = 256;
-const BOOLEAN_CACHE_MAX = 512;
-const effectAliasCache = new Map();
-const runtimeFunctionAliasCache = new Map();
-const canonicalSourceCache = new Map();
-const effectSignalCache = new Map();
-const runtimeCallCache = new Map();
-function cachedAliases(cache, source) {
-    return cache.get(source);
-}
-function cacheAliases(cache, source, value) {
-    if (cache.size >= ALIAS_CACHE_MAX) {
-        const firstKey = cache.keys().next().value;
-        if (firstKey !== undefined) {
-            cache.delete(firstKey);
-        }
-    }
-    cache.set(source, value);
-    return value;
-}
-function cachedBoolean(cache, source) {
-    return cache.get(source);
-}
-function cacheBoolean(cache, source, value) {
-    if (cache.size >= BOOLEAN_CACHE_MAX) {
-        const firstKey = cache.keys().next().value;
-        if (firstKey !== undefined) {
-            cache.delete(firstKey);
-        }
-    }
-    cache.set(source, value);
-    return value;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function hasLocalEffectBinding(source) {
-    return /\b(?:const|let|var|function|class|namespace)\s+Effect\b/.test(stripCommentsAndStrings(source));
-}
-function importSpecifierNames(specifier) {
-    const trimmed = specifier.trim();
-    if (trimmed.startsWith('type ')) {
-        return undefined;
-    }
-    const parts = trimmed.split(/\s+as\s+/);
-    const importedName = parts[0]?.trim();
-    const localName = parts[1]?.trim() ?? importedName;
-    return importedName && localName ? { importedName, localName } : undefined;
-}
-function hasAnyEffectImport(source) {
-    return /(?:^|\n)\s*import(?:\s+type)?(?:[\s\S]*?\s+from\s*)?['"](?:effect(?:\/[^'"]+)?|@effect\/[^'"]+)['"]/.test(stripComments(source));
-}
-function hasEffectValueImport(source) {
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        if (match[1]
-            .split(',')
-            .some((specifier) => importSpecifierNames(specifier)?.importedName === 'Effect')) {
-            return true;
-        }
-    }
-    return (/(?:^|\n)\s*import\s+(?!type\b)\*\s+as\s+[A-Za-z_$][\w$]*\s+from\s*['"]effect(?:\/Effect)?['"]/.test(commentFreeSource) || effectFunctionAliases(source, 'Effect').length > 0);
-}
-function effectImportAliases(source) {
-    const cachedValue = cachedAliases(effectAliasCache, source);
-    if (cachedValue) {
-        return cachedValue;
-    }
-    const aliases = new Set();
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            if (!names) {
-                continue;
-            }
-            if (names.importedName === 'Effect') {
-                aliases.add('Effect');
-                aliases.add(names.localName);
-            }
-        }
-    }
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*['"]effect(?:\/Effect)?['"]/g)) {
-        aliases.add('Effect');
-        aliases.add(match[1]);
-    }
-    if (aliases.size === 0 && !hasAnyEffectImport(source) && !hasLocalEffectBinding(source)) {
-        aliases.add('Effect');
-    }
-    return cacheAliases(effectAliasCache, source, [...aliases]);
-}
-function effectApiAliases(source, apiName) {
-    const aliases = new Set();
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            if (names?.importedName === apiName) {
-                aliases.add(names.localName);
-            }
-        }
-    }
-    for (const match of commentFreeSource.matchAll(new RegExp(`(?:^|\\n)\\s*import\\s+(?!type\\b)\\*\\s+as\\s+([A-Za-z_$][\\w$]*)\\s+from\\s*['"]effect/${escapeRegExp(apiName)}['"]`, 'g'))) {
-        aliases.add(match[1]);
-    }
-    if (aliases.size === 0 && !hasAnyEffectImport(source)) {
-        aliases.add(apiName);
-    }
-    return [...aliases];
-}
-function effectFunctionAliases(source, moduleName, functionName) {
-    const aliases = new Set();
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(new RegExp(`(?:^|\\n)\\s*import\\s+(?!type\\b)\\s*{([^}]+)}\\s*from\\s*['"]effect/${escapeRegExp(moduleName)}['"]`, 'g'))) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            if (names && (!functionName || names.importedName === functionName)) {
-                aliases.add(names.localName);
-            }
-        }
-    }
-    return [...aliases];
-}
-function canonicalImportAliases(source) {
-    const aliases = new Map();
-    const commentFreeSource = stripComments(source);
-    const canonicalNames = new Set([
-        'Config',
-        'Context',
-        'Effect',
-        'Fiber',
-        'Layer',
-        'Queue',
-        'Schedule',
-        'Schema',
-        'Scope',
-        'Stream',
-        'TestClock',
-    ]);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            const importedName = names?.importedName;
-            const localName = names?.localName;
-            if (importedName &&
-                localName &&
-                canonicalNames.has(importedName) &&
-                localName !== importedName) {
-                aliases.set(localName, importedName);
-            }
-        }
-    }
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*['"]effect\/([A-Za-z]+)['"]/g)) {
-        const [, localName, moduleName] = match;
-        if (canonicalNames.has(moduleName) && localName !== moduleName) {
-            aliases.set(localName, moduleName);
-        }
-    }
-    return aliases;
-}
-function canonicalizeEffectApiAliases(source) {
-    const cachedValue = canonicalSourceCache.get(source);
-    if (cachedValue !== undefined) {
-        return cachedValue;
-    }
-    let canonicalSource = source;
-    for (const [localName, canonicalName] of canonicalImportAliases(source)) {
-        canonicalSource = canonicalSource.replace(new RegExp(`\\b${escapeRegExp(localName)}\\.`, 'g'), `${canonicalName}.`);
-    }
-    if (canonicalSourceCache.size >= ALIAS_CACHE_MAX) {
-        const firstKey = canonicalSourceCache.keys().next().value;
-        if (firstKey !== undefined) {
-            canonicalSourceCache.delete(firstKey);
-        }
-    }
-    canonicalSourceCache.set(source, canonicalSource);
-    return canonicalSource;
-}
-function effectRuntimeFunctionAliases(source) {
-    const cachedValue = cachedAliases(runtimeFunctionAliasCache, source);
-    if (cachedValue) {
-        return cachedValue;
-    }
-    const aliases = new Set();
-    const runtimeNames = new Set([
-        'runFork',
-        'runPromise',
-        'runPromiseExit',
-        'runSync',
-        'runSyncExit',
-    ]);
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s*{([^}]+)}\s*from\s*['"]effect\/Effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            const importedName = names?.importedName;
-            const localName = names?.localName;
-            if (importedName && localName && runtimeNames.has(importedName)) {
-                aliases.add(localName);
-            }
-        }
-    }
-    return cacheAliases(runtimeFunctionAliasCache, source, [...aliases]);
-}
-function hasRuntimeCall(source) {
-    const cachedValue = cachedBoolean(runtimeCallCache, source);
-    if (cachedValue !== undefined) {
-        return cachedValue;
-    }
-    const code = stripCommentsAndStrings(source);
-    if (runtimeCallPattern.test(code)) {
-        return cacheBoolean(runtimeCallCache, source, true);
-    }
-    return cacheBoolean(runtimeCallCache, source, effectImportAliases(source).some((alias) => new RegExp(`\\b${alias}\\.(?:runPromise|runPromiseExit|runSync|runSyncExit|runFork)\\s*\\(`).test(code)) ||
-        effectRuntimeFunctionAliases(source).some((alias) => new RegExp(`\\b${alias}\\s*\\(`).test(code)));
-}
-function isBoundaryFile(filename) {
-    return Boolean(filename && boundaryFilePattern.test(filename));
-}
-function isTestFile(filename) {
-    return Boolean(filename && testFilePattern.test(filename));
-}
-export { hasEffectSignal, effectApiAliases, effectFunctionAliases, effectImportAliases, hasRuntimeCall, isBoundaryFile, isTestFile, makeRules, runtimeCallPattern, };
+};
+const makeProgramRule = (spec, options) => {
+    if (spec.ast) {
+        return makeASTCapableRule(spec, options);
+    }
+    return makeProgramOnlyRule(spec, options);
+};
+/**
+ * Internal helper exported for package-local composition.
+ *
+ * @internal
+ */
+export const makeRules = (specs, options = {}) => Object.fromEntries(specs.map((spec) => [spec.name, makeProgramRule(spec, options)]));
+export { effectAPIAliases, effectFunctionAliases, effectImportAliases, hasEffectSignal, hasRuntimeCall, isBoundaryFile, isTestFile, runtimeCallPattern, } from './effect-rule-aliases.js';
 //# sourceMappingURL=effect-rule-core.js.map