@thethracian/oxlint-config 0.2.1 → 0.3.1

package/dist/rules/effect-default.js

@@ -1,9 +1,13 @@
-import { hasBroadCatchAllWithoutRethrow, hasEffectInArrayForEach, hasEffectInPromiseCallback, hasForkDaemonWithoutCleanup, hasForkInUninterruptibleWithoutRestore, hasErrorMappingWithoutCause, hasCastAfterSchemaDecode, hasExternalJsonWithoutDecodeUnknown, hasFloatingEffect, hasJsonParsedBeforeSchemaStringDecode, hasMultipleCatchTagsInOnePipe, hasNestedFlatMap, hasParsedJsonNumberFromString, hasRecursiveEffectWithoutSuspend, hasReturnEffectInGen, hasRunForkWithoutObserver, hasRuntimeInEffect, hasSchemaPromiseDecode, hasSchemaSyncDecodeInEffectWorkflow, hasSyncForPromise, hasSyncForThrowingOps, hasTryPromiseWithoutTypedCatch, hasUnhandledSchemaEffectDecode, hasUnboundedEffectConcurrency, hasUnboundedFlatMapConcurrency, hasUnloggedIgnore, hasUnobservedFork, hasAsyncAwaitInEffect, hasThrowInEffect, hasUnsafeLazyEvaluation, hasYieldWithoutStarInGen, } from './effect-default-helpers.js';
-import { hasUnreleasedAcquire, hasUnscopedAcquireRelease, hasUnscopedResourceWorkflow, } from './effect-default-resource-helpers.js';
-import { hasForkBeforeTestClockAdjust, hasRealSleepWithoutTestClock, hasTestClockWithoutEffectContext, } from './effect-default-test-helpers.js';
-import { isConfiguredPath, isEffectTestPath, strictPathOptionsSchema, } from './effect-path-options.js';
-import { effectImportAliases, effectFunctionAliases, hasEffectSignal, hasRuntimeCall, makeRules, } from './effect-rule-core.js';
-import { exportedCallableDeclarationSegments, exportedDeclarationSegments, findBalancedCallEnd, stripCommentsAndStrings, } from './effect-source-helpers.js';
+/* -------------------------------------------------------------------------- */
+/*               Always-on custom Effect lint rule definitions.               */
+/* -------------------------------------------------------------------------- */
+import { arrayValue, effectCallPredicate, identifierName, isStringLikeLiteral, memberParts, nodeType, objectValue, propertyKeyName, reportAST, } from './effect-default-ast.js';
+import { exportedCallableDeclarationSegments, exportedDeclarationSegments, stripCommentsAndStrings, } from './effect-source-helpers.js';
+import { hasAsyncAwaitInEffect, hasBroadCatchAllWithoutRethrow, hasEffectInArrayForEach, hasEffectInPromiseCallback, hasErrorMappingWithoutCause, hasFloatingEffect, hasMultipleCatchTagsInOnePipe, hasNestedFlatMap, hasRecursiveEffectWithoutSuspend, hasReturnEffectInGen, hasRunForkWithoutObserver, hasRuntimeInEffect, hasSyncForPromise, hasSyncForThrowingOPS, hasThrowInEffect, hasTryPromiseWithoutTypedCatch, hasUnloggedIgnore, hasUnobservedFork, hasUnsafeLazyEvaluation, hasYieldWithoutStarInGen, } from './effect-default-helpers.js';
+import { hasEffectSignal, makeRules } from './effect-rule-core.js';
+import { effectDefaultCompatibilitySpecs } from './effect-default-compat-rules.js';
+import { effectDefaultEnvironmentSpecs } from './effect-default-env-rules.js';
+import { strictPathOptionsSchema } from './effect-path-options.js';
 const effectDefaultRuleTokens = [
     'Effect',
     'Schema',
@@ -22,130 +26,11 @@ const effectDefaultRuleTokens = [
     'JSON.parse',
     'response.json',
 ];
-function reportAst(context, message, node) {
-    context.report({ message, node });
-}
-function nodeType(node) {
-    return typeof node === 'object' && node !== null ? node.type : undefined;
-}
-function identifierName(node) {
-    return nodeType(node) === 'Identifier' ? node.name : undefined;
-}
-function literalValue(node) {
-    return nodeType(node) === 'Literal' ? node.value : undefined;
-}
-function isStringLikeLiteral(node) {
-    if (typeof literalValue(node) === 'string') {
-        return true;
-    }
-    if (nodeType(node) !== 'TemplateLiteral') {
-        return false;
-    }
-    const { expressions } = node;
-    return expressions?.length === 0;
-}
-function memberParts(node) {
-    if (nodeType(node) !== 'MemberExpression') {
-        return {};
-    }
-    const member = node;
-    return {
-        objectName: identifierName(member.object),
-        propertyName: identifierName(member.property),
-    };
-}
-function effectCallPredicate(source, names) {
-    const memberNames = new Set(names);
-    const importAliases = new Set(effectImportAliases(source));
-    const functionAliases = new Set(names.flatMap((name) => effectFunctionAliases(source, 'Effect', name)));
-    return (callee) => {
-        const { objectName, propertyName } = memberParts(callee);
-        if (objectName && propertyName) {
-            return importAliases.has(objectName) && memberNames.has(propertyName);
-        }
-        const calleeName = identifierName(callee);
-        return Boolean(calleeName && functionAliases.has(calleeName));
-    };
-}
-function propertyKeyName(node) {
-    const value = literalValue(node);
-    return identifierName(node) ?? (typeof value === 'string' ? value : undefined);
-}
-function typeReferenceName(node) {
-    if (nodeType(node) !== 'TSTypeReference') {
-        return undefined;
-    }
-    const { typeName } = node;
-    if (nodeType(typeName) === 'Identifier') {
-        return identifierName(typeName);
-    }
-    if (nodeType(typeName) !== 'TSQualifiedName') {
-        return undefined;
-    }
-    const qualified = typeName;
-    const leftName = identifierName(qualified.left);
-    const rightName = identifierName(qualified.right);
-    return leftName && rightName ? `${leftName}.${rightName}` : undefined;
-}
-function firstTypeArgumentName(node) {
-    const params = node.typeArguments?.params;
-    return typeReferenceName(params?.[0]);
-}
-function effectServiceSelfName(superClass, source) {
-    if (nodeType(superClass) !== 'CallExpression') {
-        return undefined;
-    }
-    const outer = superClass;
-    const outerSelf = typeReferenceName(outer.typeArguments?.params?.[0]);
-    const inner = outer.callee;
-    if (nodeType(inner) !== 'CallExpression') {
-        return undefined;
-    }
-    const innerCall = inner;
-    const { objectName, propertyName } = memberParts(innerCall.callee);
-    if (objectName === 'Context' && propertyName === 'Tag') {
-        return outerSelf;
-    }
-    if (objectName &&
-        propertyName === 'Service' &&
-        effectImportAliases(source).includes(objectName)) {
-        return firstTypeArgumentName(inner);
-    }
-    return undefined;
-}
-function hasMixedEffectImportStyles(source) {
-    const hasNamedRootEffectImport = /import\s*{[^}]*\bEffect\b[^}]*}\s*from\s*['"]effect['"]/.test(source);
-    const hasNamespaceEffectImport = /import\s+\*\s+as\s+[A-Za-z_$][\w$]*\s+from\s*['"]effect(?:\/Effect)?['"]/.test(source);
-    return hasNamedRootEffectImport && hasNamespaceEffectImport;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function hasTryCatchInEffectGen(source) {
-    const code = stripCommentsAndStrings(source);
-    const aliases = effectImportAliases(source).map(escapeRegExp).join('|');
-    if (!aliases) {
-        return false;
-    }
-    for (const match of code.matchAll(new RegExp(`\\b(?:${aliases})\\.gen\\s*\\(`, 'g'))) {
-        const openParenIndex = code.indexOf('(', match.index);
-        if (openParenIndex === -1) {
-            continue;
-        }
-        const bodyStart = openParenIndex + 1;
-        const body = code.slice(bodyStart, findBalancedCallEnd(code, openParenIndex));
-        const tryCatchMatch = /\btry\s*{[\s\S]*?\bcatch\s*\(/.exec(body);
-        if (tryCatchMatch?.index !== undefined) {
-            return bodyStart + tryCatchMatch.index;
-        }
-    }
-    return false;
-}
-function hasStringErrorFailure(source) {
+const hasStringErrorFailure = (source) => {
     const match = /\bEffect\.fail\s*\(\s*["'`]/.exec(stripCommentsAndStrings(source));
     return match?.index ?? false;
-}
-function hasUntaggedErrorFailure(source) {
+};
+const hasUntaggedErrorFailure = (source) => {
     const code = stripCommentsAndStrings(source);
     const nativeErrorMatch = /\bEffect\.fail\s*\(\s*new\s+Error\s*\(/.exec(code);
     if (nativeErrorMatch) {
@@ -153,124 +38,94 @@ function hasUntaggedErrorFailure(source) {
     }
     const objectErrorMatch = /\bEffect\.fail\s*\(\s*{(?![^}]*\b_tag\s*:)/.exec(code);
     return objectErrorMatch?.index ?? false;
-}
-function hasNativeErrorClassInEffectModule(source) {
-    if (!hasEffectSignal(source)) {
-        return false;
-    }
-    const match = /\bclass\s+[A-Z][\w$]*\s+extends\s+Error\b/.exec(stripCommentsAndStrings(source));
-    return match?.index ?? false;
-}
-function hasUnsafeEffectTypeAssertion(source) {
-    const code = stripCommentsAndStrings(source);
-    const match = /\bas\s+Effect\.Effect\s*<[^>]*>/.exec(code);
-    return match?.index ?? false;
-}
-function hasServiceSelfMismatch(source) {
-    const code = stripCommentsAndStrings(source);
-    const legacyPattern = /\bclass\s+([A-Z][\w$]*)\s+extends\s+(?:Context\.Tag|Effect\.Service|Effect\.Tag)\s*\([^)]*\)\s*<\s*([A-Z][\w$]*)\b/g;
-    for (const match of code.matchAll(legacyPattern)) {
-        const [, className, selfName] = match;
-        if (className !== selfName) {
-            return match.index;
-        }
-    }
-    const servicePattern = /\bclass\s+([A-Z][\w$]*)\s+extends\s+Effect\.Service\s*<\s*([A-Z][\w$]*)\s*>\s*\(\s*\)/g;
-    for (const match of code.matchAll(servicePattern)) {
-        const [, className, selfName] = match;
-        if (className !== selfName) {
-            return match.index;
-        }
+};
+const isUntaggedErrorFailureArgument = (firstArg) => {
+    if (nodeType(firstArg) === 'NewExpression' &&
+        identifierName(objectValue(firstArg, 'callee')) === 'Error') {
+        return true;
     }
-    return false;
-}
-function hasEffectFnIife(source) {
-    const code = stripCommentsAndStrings(source);
-    const match = /\bEffect\.fn(?:Untraced|UntracedEager)?\s*\([\s\S]*?\)\s*\([\s\S]*?\)\s*\(/.exec(code);
-    return match?.index ?? false;
-}
+    return (nodeType(firstArg) === 'ObjectExpression' &&
+        !arrayValue(objectValue(firstArg, 'properties')).some((property) => propertyKeyName(objectValue(property, 'key')) === '_tag'));
+};
 const effectDefaultSpecs = [
     {
-        name: 'effect-no-floating-effect',
-        message: 'Return, yield, assign, or compose Effect values; bare Effect calls never execute.',
         check: hasFloatingEffect,
+        message: 'Return, yield, assign, or compose Effect values; bare Effect calls never execute.',
+        name: 'effect-no-floating-effect',
     },
     {
-        name: 'effect-require-yield-star',
+        check: hasYieldWithoutStarInGen,
         message: 'Use yield* inside Effect.gen so generator composition unwraps the Effect value.',
+        name: 'effect-require-yield-star',
         tokenGroups: [['gen'], ['yield']],
-        check: hasYieldWithoutStarInGen,
     },
     {
-        name: 'effect-require-return-yield-star',
+        check: hasReturnEffectInGen,
         message: 'Do not return an Effect from Effect.gen; return a value or return yield* the Effect.',
+        name: 'effect-require-return-yield-star',
         tokenGroups: [['gen'], ['return']],
-        check: hasReturnEffectInGen,
     },
     {
-        name: 'effect-prefer-gen-for-nested-flatmap',
+        check: hasNestedFlatMap,
         message: 'Replace nested Effect.flatMap callbacks with Effect.gen for readable sequencing.',
+        name: 'effect-prefer-gen-for-nested-flatmap',
         tokens: ['flatMap'],
-        check: hasNestedFlatMap,
     },
     {
-        name: 'effect-no-function-returning-gen',
+        check: (source) => exportedCallableDeclarationSegments(source).some((segment) => /(?:^|\breturn\s+)Effect\.gen\s*\(/.test(segment.trim())),
         message: 'Use Effect.fn for exported effectful functions instead of returning Effect.gen.',
+        name: 'effect-no-function-returning-gen',
         tokens: ['gen'],
-        check: (source) => exportedCallableDeclarationSegments(source).some((segment) => /(?:^|\breturn\s+)Effect\.gen\s*\(/.test(segment.trim())),
     },
     {
-        name: 'effect-prefer-effect-fn-for-exported-effects',
+        check: (source) => exportedCallableDeclarationSegments(source).some((segment) => /(?:^|\breturn\s+)Effect\.(?!fn\b|gen\b|isEffect\b|serviceFunction\b|runPromise\b)/.test(segment.trim())),
         message: 'Exported effectful functions should use Effect.fn for tracing and stable contracts.',
+        name: 'effect-prefer-effect-fn-for-exported-effects',
         tokens: ['export'],
-        check: (source) => exportedCallableDeclarationSegments(source).some((segment) => /(?:^|\breturn\s+)Effect\.(?!fn\b|gen\b|isEffect\b|serviceFunction\b|runPromise\b)/.test(segment.trim())),
     },
     {
-        name: 'effect-no-unnecessary-gen',
         message: 'Do not wrap a single Effect in Effect.gen when direct composition is clearer.',
-        tokenGroups: [['gen'], ['yield']],
+        name: 'effect-no-unnecessary-gen',
         patterns: [/Effect\.gen\s*\(\s*function\*\s*\([^)]*\)\s*{\s*return\s+yield\*\s+Effect\./],
+        tokenGroups: [['gen'], ['yield']],
     },
     {
-        name: 'effect-no-effect-in-array-foreach',
+        check: hasEffectInArrayForEach,
         message: 'Use Effect.forEach instead of Array.forEach with Effect-returning callbacks.',
+        name: 'effect-no-effect-in-array-foreach',
         tokens: ['forEach'],
-        check: hasEffectInArrayForEach,
     },
     {
-        name: 'effect-no-effect-in-promise-callback',
+        check: hasEffectInPromiseCallback,
         message: 'Do not create Effect values inside Promise callbacks; compose at the Effect boundary.',
+        name: 'effect-no-effect-in-promise-callback',
         tokens: ['.then', '.catch'],
-        check: hasEffectInPromiseCallback,
     },
     {
-        name: 'effect-no-floating-fiber',
+        check: hasUnobservedFork,
         message: 'Forked fibers must be joined, interrupted, scoped, supervised, or returned.',
+        name: 'effect-no-floating-fiber',
         tokens: ['fork'],
-        check: hasUnobservedFork,
     },
     {
-        name: 'effect-require-suspend-for-recursion',
+        check: hasRecursiveEffectWithoutSuspend,
         message: 'Recursive Effect construction must be wrapped in Effect.suspend.',
+        name: 'effect-require-suspend-for-recursion',
         tokens: ['function', '=>'],
-        check: hasRecursiveEffectWithoutSuspend,
     },
     {
-        name: 'effect-require-suspend-for-lazy-evaluation',
+        check: hasUnsafeLazyEvaluation,
         message: 'Use Effect.suspend when Effect construction must defer eager JavaScript work.',
+        name: 'effect-require-suspend-for-lazy-evaluation',
         tokens: ['Date.now', 'Math.random', 'new Date', 'JSON.parse'],
-        check: hasUnsafeLazyEvaluation,
     },
     {
-        name: 'effect-no-async-await-in-effect',
+        check: hasAsyncAwaitInEffect,
         message: 'Use Effect.tryPromise or Effect.promise boundaries instead of async/await in Effect code.',
+        name: 'effect-no-async-await-in-effect',
         tokens: ['async', 'await'],
-        check: hasAsyncAwaitInEffect,
     },
     {
-        name: 'effect-no-promise-then-in-effect',
-        message: 'Use Effect combinators instead of Promise then/catch chains in Effect modules.',
-        tokens: ['.then', '.catch'],
         ast: (context, source) => {
             const isEffectModule = hasEffectSignal(source);
             return {
@@ -278,601 +133,171 @@ const effectDefaultSpecs = [
                     if (!isEffectModule) {
                         return;
                     }
-                    const { callee } = node;
-                    const { propertyName } = memberParts(callee);
+                    const { propertyName } = memberParts(objectValue(node, 'callee'));
                     if (propertyName === 'then' || propertyName === 'catch') {
-                        reportAst(context, 'Use Effect combinators instead of Promise then/catch chains in Effect modules.', node);
+                        reportAST(context, 'Use Effect combinators instead of Promise then/catch chains in Effect modules.', node);
                     }
                 },
             };
         },
+        message: 'Use Effect combinators instead of Promise then/catch chains in Effect modules.',
+        name: 'effect-no-promise-then-in-effect',
+        tokens: ['.then', '.catch'],
     },
     {
-        name: 'effect-no-throw',
+        check: hasThrowInEffect,
         message: 'Use typed Effect failures instead of throw inside Effect workflows.',
+        name: 'effect-no-throw',
         tokens: ['throw'],
-        check: hasThrowInEffect,
     },
     {
-        name: 'effect-no-string-errors',
-        message: 'Use structured tagged errors instead of string failures.',
-        tokens: ['fail'],
-        check: hasStringErrorFailure,
         ast: (context, source) => {
             const isEffectFail = effectCallPredicate(source, ['fail']);
             return {
                 CallExpression(node) {
-                    const call = node;
-                    if (isEffectFail(call.callee) && isStringLikeLiteral(call.arguments?.[0])) {
-                        reportAst(context, 'Use structured tagged errors instead of string failures.', node);
+                    const callArguments = arrayValue(objectValue(node, 'arguments'));
+                    if (isEffectFail(objectValue(node, 'callee')) && isStringLikeLiteral(callArguments[0])) {
+                        reportAST(context, 'Use structured tagged errors instead of string failures.', node);
                     }
                 },
             };
         },
+        check: hasStringErrorFailure,
+        message: 'Use structured tagged errors instead of string failures.',
+        name: 'effect-no-string-errors',
+        tokens: ['fail'],
     },
     {
-        name: 'effect-no-untagged-errors',
-        message: 'Use tagged/data/schema errors in Effect.fail instead of global Error values.',
-        tokens: ['fail'],
-        check: hasUntaggedErrorFailure,
         ast: (context, source) => {
             const isEffectFail = effectCallPredicate(source, ['fail']);
             return {
                 CallExpression(node) {
-                    const call = node;
-                    const firstArg = call.arguments?.[0];
-                    if (!isEffectFail(call.callee)) {
+                    const callArguments = arrayValue(objectValue(node, 'arguments'));
+                    const [firstArg] = callArguments;
+                    if (!isEffectFail(objectValue(node, 'callee'))) {
                         return;
                     }
                     if (!firstArg) {
                         return;
                     }
-                    if (nodeType(firstArg) === 'NewExpression' &&
-                        identifierName(firstArg.callee) === 'Error') {
-                        reportAst(context, 'Use tagged/data/schema errors in Effect.fail instead of global Error values.', node);
-                        return;
-                    }
-                    if (nodeType(firstArg) === 'ObjectExpression' &&
-                        !firstArg.properties?.some((property) => propertyKeyName(property.key) === '_tag')) {
-                        reportAst(context, 'Use tagged/data/schema errors in Effect.fail instead of global Error values.', node);
+                    if (isUntaggedErrorFailureArgument(firstArg)) {
+                        reportAST(context, 'Use tagged/data/schema errors in Effect.fail instead of global Error values.', node);
                     }
                 },
             };
         },
+        check: hasUntaggedErrorFailure,
+        message: 'Use tagged/data/schema errors in Effect.fail instead of global Error values.',
+        name: 'effect-no-untagged-errors',
+        tokens: ['fail'],
     },
     {
-        name: 'effect-no-silent-error-swallowing',
         message: 'Do not erase Effect failures without recovery, logging, or explicit typed replacement.',
-        tokens: ['catchAll', 'ignore'],
+        name: 'effect-no-silent-error-swallowing',
         patterns: [
             /Effect\.(?:catchAll|ignore)\s*\([\s\S]*?(?:Effect\.void|Effect\.succeed\s*\(\s*undefined|undefined)/,
         ],
+        tokens: ['catchAll', 'ignore'],
     },
     {
-        name: 'effect-require-typed-error-in-trypromise',
+        check: hasTryPromiseWithoutTypedCatch,
         message: 'Use Effect.tryPromise({ try, catch }) so Promise failures become typed Effect errors.',
+        name: 'effect-require-typed-error-in-trypromise',
         tokens: ['tryPromise'],
-        check: hasTryPromiseWithoutTypedCatch,
     },
     {
-        name: 'effect-prefer-catchTag-over-catchAll',
+        check: hasBroadCatchAllWithoutRethrow,
         message: 'Prefer catchTag or catchTags over broad catchAll recovery.',
+        name: 'effect-prefer-catchTag-over-catchAll',
         tokens: ['catchAll'],
-        check: hasBroadCatchAllWithoutRethrow,
     },
     {
-        name: 'effect-no-catchAll-with-mapError',
         message: 'Use mapError directly instead of catchAll when only transforming the error.',
-        tokens: ['catchAll'],
+        name: 'effect-no-catchAll-with-mapError',
         patterns: [/Effect\.catchAll\s*\([\s\S]*?=>\s*Effect\.fail\s*\(/],
+        tokens: ['catchAll'],
     },
     {
-        name: 'effect-prefer-mapError-over-catchAll-rethrow',
         message: 'Use Effect.mapError instead of catchAll followed by fail.',
-        tokens: ['catchAll'],
+        name: 'effect-prefer-mapError-over-catchAll-rethrow',
         patterns: [/(?:^|[^\w$.])catchAll\s*\([\s\S]*?=>\s*Effect\.fail\s*\(/],
+        tokens: ['catchAll'],
     },
     {
-        name: 'effect-require-error-cause-preserved',
+        check: hasErrorMappingWithoutCause,
         message: 'Preserve the original cause when mapping or wrapping Effect errors.',
+        name: 'effect-require-error-cause-preserved',
         tokens: ['mapError', 'catchAll'],
-        check: hasErrorMappingWithoutCause,
     },
     {
-        name: 'effect-prefer-ignore-logged',
+        check: hasUnloggedIgnore,
         message: 'Ignored Effect failures must be logged or otherwise observable.',
+        name: 'effect-prefer-ignore-logged',
         tokens: ['ignore'],
-        check: hasUnloggedIgnore,
     },
     {
-        name: 'effect-prefer-catchTags-for-multiple-tags',
+        check: hasMultipleCatchTagsInOnePipe,
         message: 'Use Effect.catchTags for multiple tagged Effect recoveries.',
+        name: 'effect-prefer-catchTags-for-multiple-tags',
         tokens: ['catchTag'],
-        check: hasMultipleCatchTagsInOnePipe,
     },
     {
-        name: 'effect-no-error-channel-widening-to-unknown',
         message: 'Do not widen Effect error channels to unknown.',
-        tokens: ['unknown'],
+        name: 'effect-no-error-channel-widening-to-unknown',
         patterns: [/Effect\s*<[^>]*,\s*unknown\b/, /Effect\.fail\s*<\s*unknown\b/],
+        tokens: ['unknown'],
     },
     {
-        name: 'effect-no-run-inside-effect',
+        check: hasRuntimeInEffect,
         message: 'Do not run an Effect from inside another Effect; yield or compose it instead.',
+        name: 'effect-no-run-inside-effect',
         tokens: ['run'],
-        check: hasRuntimeInEffect,
     },
     {
-        name: 'effect-no-runpromise-in-exported-api',
+        check: (source) => exportedDeclarationSegments(source).some((segment) => /Effect\.runPromise\s*\(/.test(segment)),
         message: 'Exported APIs should expose Effect values instead of hiding execution behind Promise.',
+        name: 'effect-no-runpromise-in-exported-api',
         tokens: ['runPromise'],
-        check: (source) => exportedDeclarationSegments(source).some((segment) => /Effect\.runPromise\s*\(/.test(segment)),
     },
     {
-        name: 'effect-no-runfork-without-observer',
+        check: hasRunForkWithoutObserver,
         message: 'Do not call runFork without explicit observation, supervision, or interruption.',
+        name: 'effect-no-runfork-without-observer',
         tokens: ['runFork'],
-        check: hasRunForkWithoutObserver,
     },
     {
-        name: 'effect-no-sync-for-promise',
+        check: hasSyncForPromise,
         message: 'Use Effect.tryPromise for Promise-returning code instead of Effect.sync.',
+        name: 'effect-no-sync-for-promise',
         tokenGroups: [['sync'], ['async', 'fetch', 'Promise.']],
-        check: hasSyncForPromise,
     },
     {
-        name: 'effect-no-sync-for-throwing-ops',
+        check: hasSyncForThrowingOPS,
         message: 'Use Effect.try for synchronous code that can throw instead of Effect.sync.',
+        name: 'effect-no-sync-for-throwing-ops',
         tokenGroups: [['sync'], ['throw', 'JSON.parse']],
-        check: hasSyncForThrowingOps,
     },
     {
-        name: 'effect-no-console-log-in-effect-code',
-        message: 'Use Effect logging APIs instead of console logging in Effect code.',
-        tokens: ['console'],
         ast: (context, source) => {
             const isEffectModule = hasEffectSignal(source);
             return {
                 CallExpression(node) {
-                    const { objectName, propertyName } = memberParts(node.callee);
+                    const { objectName, propertyName } = memberParts(objectValue(node, 'callee'));
                     if (isEffectModule &&
                         objectName === 'console' &&
                         propertyName &&
                         ['debug', 'error', 'info', 'log', 'warn'].includes(propertyName)) {
-                        reportAst(context, 'Use Effect logging APIs instead of console logging in Effect code.', node);
-                    }
-                },
-            };
-        },
-    },
-    {
-        name: 'effect-no-process-env-in-effect-code',
-        message: 'Use Effect Config instead of process.env in Effect code.',
-        tokens: ['process'],
-        ast: (context, source) => {
-            const isEffectModule = hasEffectSignal(source);
-            const isConfigLayer = isConfiguredPath(context, 'configLayers');
-            return {
-                MemberExpression(node) {
-                    const { objectName, propertyName } = memberParts(node);
-                    const processEnv = objectName === 'process' && propertyName === 'env';
-                    if (isEffectModule && !isConfigLayer && processEnv) {
-                        reportAst(context, 'Use Effect Config instead of process.env in Effect code.', node);
-                    }
-                },
-            };
-        },
-    },
-    {
-        name: 'effect-no-date-now-in-effect-code',
-        message: 'Use Effect Clock instead of Date.now in Effect code.',
-        tokens: ['Date'],
-        ast: (context, source) => {
-            const isEffectModule = hasEffectSignal(source);
-            const isAdapterLayer = isConfiguredPath(context, 'adapterLayers');
-            return {
-                CallExpression(node) {
-                    const { objectName, propertyName } = memberParts(node.callee);
-                    if (isEffectModule &&
-                        !isAdapterLayer &&
-                        objectName === 'Date' &&
-                        propertyName === 'now') {
-                        reportAst(context, 'Use Effect Clock instead of Date.now in Effect code.', node);
-                    }
-                },
-            };
-        },
-    },
-    {
-        name: 'effect-no-math-random-in-effect-code',
-        message: 'Use Effect Random instead of Math.random in Effect code.',
-        tokens: ['Math'],
-        ast: (context, source) => {
-            const isEffectModule = hasEffectSignal(source);
-            const isAdapterLayer = isConfiguredPath(context, 'adapterLayers');
-            return {
-                CallExpression(node) {
-                    const { objectName, propertyName } = memberParts(node.callee);
-                    if (isEffectModule &&
-                        !isAdapterLayer &&
-                        objectName === 'Math' &&
-                        propertyName === 'random') {
-                        reportAst(context, 'Use Effect Random instead of Math.random in Effect code.', node);
-                    }
-                },
-            };
-        },
-    },
-    {
-        name: 'effect-no-json-parse-cast',
-        message: 'Decode external JSON with Schema instead of casting parsed unknown data.',
-        tokenGroups: [[' as '], ['JSON.parse', '.json']],
-        patterns: [
-            /\bJSON\.parse\s*\([^)]*\)\s+as\s+[A-Za-z_$][\w$]*/,
-            /\.json\s*\(\s*\)\s+as\s+[A-Za-z_$][\w$]*/,
-        ],
-    },
-    {
-        name: 'effect-schema-prefer-decodeUnknown-effect',
-        message: 'Use Schema.decodeUnknown to decode unknown input into the Effect error channel.',
-        tokens: ['decode'],
-        check: hasSchemaPromiseDecode,
-    },
-    {
-        name: 'effect-schema-require-parse-error-handling',
-        message: 'Schema parsing must expose parse errors through typed Effect handling.',
-        tokens: ['decode'],
-        check: hasUnhandledSchemaEffectDecode,
-    },
-    {
-        name: 'effect-schema-use-decodeUnknown-for-external-data',
-        message: 'External data must enter through Schema.decodeUnknown.',
-        tokens: ['.json'],
-        check: hasExternalJsonWithoutDecodeUnknown,
-    },
-    {
-        name: 'effect-schema-no-unsafe-sync-decode-in-effect-code',
-        message: 'Do not use throwing synchronous Schema decoders in Effect modules.',
-        tokens: ['decodeSync', 'decodeUnknownSync'],
-        check: hasSchemaSyncDecodeInEffectWorkflow,
-    },
-    {
-        name: 'effect-schema-require-parseJson-for-json-strings',
-        message: 'Use Schema.parseJson when decoding JSON strings with Schema.',
-        tokens: ['JSON.parse'],
-        check: hasJsonParsedBeforeSchemaStringDecode,
-    },
-    {
-        name: 'effect-schema-correct-number-type-for-parsed-json',
-        message: 'Use the correct Schema number type for already-parsed JSON numbers.',
-        tokens: ['JSON.parse'],
-        check: hasParsedJsonNumberFromString,
-    },
-    {
-        name: 'effect-schema-prefer-taggedClass-over-manual-tag',
-        message: 'Prefer Schema.TaggedClass over hand-written _tag fields.',
-        tokens: ['_tag'],
-        patterns: [/Schema\.Struct\s*\(\s*{[\s\S]*?_tag\s*:\s*Schema\.Literal/],
-    },
-    {
-        name: 'effect-schema-avoid-old-type-names',
-        message: 'Use current Effect Schema API names instead of obsolete lowercase helpers.',
-        tokens: ['Schema.'],
-        patterns: [/\bSchema\.(?:string|number|boolean|array|object)\s*\(/],
-    },
-    {
-        name: 'effect-schema-no-cast-after-decode',
-        message: 'Do not cast after Schema decoding; let the schema provide the type.',
-        tokenGroups: [['Schema.decode'], [' as ']],
-        check: hasCastAfterSchemaDecode,
-    },
-    {
-        name: 'effect-require-acquire-release',
-        message: 'Resource acquisition must use acquireRelease, scoped, or equivalent finalization.',
-        tokens: ['open', 'connect', 'subscribe', 'listen'],
-        check: hasUnreleasedAcquire,
-    },
-    {
-        name: 'effect-require-scoped-for-acquireRelease',
-        message: 'Use Effect.scoped around acquireRelease when exposing acquired resources.',
-        tokens: ['acquireRelease'],
-        check: hasUnscopedAcquireRelease,
-    },
-    {
-        name: 'effect-require-scoped-for-resources',
-        message: 'Resourceful workflows must be scoped.',
-        tokens: ['Socket.', 'Connection.'],
-        check: hasUnscopedResourceWorkflow,
-    },
-    {
-        name: 'effect-no-fork-daemon-without-cleanup',
-        message: 'Daemon fibers must have cleanup, interruption, or supervision.',
-        tokens: ['forkDaemon'],
-        check: hasForkDaemonWithoutCleanup,
-    },
-    {
-        name: 'effect-prefer-fork-scoped-for-listeners',
-        message: 'Long-running listeners should use forkScoped so they follow Scope lifetime.',
-        tokens: ['fork'],
-        patterns: [
-            /Effect\.fork\s*\([\s\S]*?\b(?:listen[A-Z]\w*|subscribe[A-Z]\w*|watch[A-Z]\w*|listen|subscribe|watch)\b/,
-        ],
-    },
-    {
-        name: 'effect-require-restore-for-fork-in-uninterruptible',
-        message: 'Use restore when forking inside uninterruptible regions.',
-        tokenGroups: [['uninterruptible'], ['fork']],
-        check: hasForkInUninterruptibleWithoutRestore,
-    },
-    {
-        name: 'effect-require-bounded-concurrency',
-        message: 'Concurrent Effect traversal must declare an explicit concurrency bound.',
-        tokens: ['concurrency'],
-        check: hasUnboundedEffectConcurrency,
-    },
-    {
-        name: 'effect-require-bounded-flatMap-concurrency',
-        message: 'Concurrent Effect.flatMap usage must declare a bounded concurrency value.',
-        tokenGroups: [['flatMap'], ['concurrency']],
-        check: hasUnboundedFlatMapConcurrency,
-    },
-    {
-        name: 'effect-no-unbounded-queue',
-        message: 'Use bounded, sliding, or dropping queues instead of unbounded queues.',
-        tokens: ['unbounded'],
-        patterns: [/\bQueue\.unbounded\s*\(/],
-    },
-    {
-        name: 'effect-no-unbounded-stream-buffer',
-        message: 'Stream buffers must be explicitly bounded.',
-        tokens: ['unbounded', 'Infinity'],
-        patterns: [
-            /\bStream\.(?:buffer|fromQueue|async|asyncPush)\s*\([^)]*\b(?:Infinity|unbounded)\b/,
-        ],
-    },
-    {
-        name: 'effect-test-no-runpromise',
-        message: 'Use @effect/vitest it.effect instead of manually running Effects in tests.',
-        tokens: ['run'],
-        check: (source, context) => isEffectTestPath(context) && hasRuntimeCall(source),
-    },
-    {
-        name: 'effect-prefer-it-effect-for-unit-tests',
-        message: 'Use it.effect for tests that exercise Effect programs.',
-        tokens: ['it('],
-        check: (source, context) => isEffectTestPath(context) &&
-            !hasRuntimeCall(source) &&
-            /\bit\s*\([\s\S]*?Effect\./.test(stripCommentsAndStrings(source)),
-    },
-    {
-        name: 'effect-testClock-requires-fork',
-        message: 'Fork time-dependent work before adjusting TestClock.',
-        tokens: ['TestClock.adjust'],
-        check: (source) => /TestClock\.adjust\s*\(/.test(stripCommentsAndStrings(source)) &&
-            !hasForkBeforeTestClockAdjust(source),
-    },
-    {
-        name: 'effect-testClock-requires-testContext',
-        message: 'Use Effect test context when using TestClock.',
-        tokens: ['TestClock'],
-        check: (source, context) => isEffectTestPath(context) && hasTestClockWithoutEffectContext(source),
-    },
-    {
-        name: 'effect-no-real-sleep-in-tests',
-        message: 'Use TestClock instead of real sleeps in Effect tests.',
-        tokens: ['sleep'],
-        check: (source, context) => isEffectTestPath(context) && hasRealSleepWithoutTestClock(source),
-    },
-    {
-        name: 'effect-use-exit-for-failure-tests',
-        message: 'Use Effect.exit inside it.effect when asserting Effect failures.',
-        tokens: ['rejects', 'toThrow'],
-        check: (source, context) => isEffectTestPath(context) &&
-            !hasRuntimeCall(source) &&
-            /\b(?:rejects|toThrow)\b/.test(stripCommentsAndStrings(source)) &&
-            /\bEffect\./.test(stripCommentsAndStrings(source)),
-    },
-    {
-        name: 'effect-no-focused-effect-tests',
-        message: 'Focused Effect tests must not be committed.',
-        tokens: ['.only'],
-        check: (source, context) => isEffectTestPath(context) &&
-            /\b(?:it|describe)\.effect\.only\s*\(/.test(stripCommentsAndStrings(source)),
-    },
-    {
-        name: 'effect-no-skipped-effect-tests',
-        message: 'Skipped Effect tests must not be committed.',
-        tokens: ['.skip'],
-        check: (source, context) => isEffectTestPath(context) &&
-            /\b(?:it|describe)\.effect\.skip\s*\(/.test(stripCommentsAndStrings(source)),
-    },
-    {
-        name: 'effect-no-obsolete-imports',
-        message: 'Import Effect APIs from the main effect package; deprecated split packages are blocked.',
-        tokens: ['@effect/io', '@effect/data'],
-        patterns: [/from\s+['"]@effect\/(?:io|data)['"]/],
-    },
-    {
-        name: 'effect-no-known-fake-api',
-        message: 'This is not a known Effect API for the configured version.',
-        tokens: ['fromPromise', 'tryCatch', 'bracket', 'fromEither'],
-        check: (source) => /\bEffect\.(?:fromPromise|tryCatch|bracket|fromEither)\s*\(/.test(stripCommentsAndStrings(source)),
-    },
-    {
-        name: 'effect-prefer-gen-over-do',
-        message: 'Prefer Effect.gen over Effect.Do for agent-readable sequential workflows.',
-        tokens: ['Effect.Do'],
-        patterns: [/\bEffect\.Do\b/],
-    },
-    {
-        name: 'effect-prefer-direct-yield-star',
-        message: 'Use direct yield* effect style instead of adapter-style Effect.gen helpers.',
-        tokenGroups: [['gen'], ['$']],
-        patterns: [/Effect\.gen\s*\(\s*function\*\s*\(\s*\$\s*\)/],
-    },
-    {
-        name: 'effect-prefer-config-redacted',
-        message: 'Use Config.redacted for sensitive config values so secrets stay redacted in logs and errors.',
-        tokens: ['secret', 'Secret'],
-        patterns: [/Config\.(?:secret|Secret)\s*\(/],
-    },
-    {
-        name: 'effect-no-deprecated-schema-package',
-        message: 'Use Schema from effect/Schema instead of @effect/schema.',
-        tokens: ['@effect/schema'],
-        patterns: [/from\s+['"]@effect\/schema['"]/],
-    },
-    {
-        name: 'effect-no-deprecated-context-tag-function',
-        message: 'Use the current Context.Tag class/service pattern instead of deprecated tag helpers.',
-        tokens: ['Context.Tag'],
-        patterns: [
-            /\b(?:const|let|var)\s+[A-Z][\w$]*\s*=\s*Context\.Tag(?:<[^>]+>)?\s*\(\s*['"][^'"]+['"]\s*\)/,
-            /(?:^|[;\n]\s*)Context\.Tag(?:<[^>]+>)?\s*\(\s*['"][^'"]+['"]\s*\)/,
-        ],
-    },
-    {
-        name: 'effect-no-global-error-channel',
-        message: 'Use domain-specific tagged errors instead of the global Error type channel.',
-        tokenGroups: [['Effect.Effect'], ['Error']],
-        patterns: [/Effect\.Effect\s*<[^,>]+,\s*Error\s*[,>]/],
-    },
-    {
-        name: 'effect-use-duration-constructors',
-        message: 'Use Duration constructors or string durations instead of naked millisecond numbers.',
-        tokens: ['sleep', 'timeout', 'delay'],
-        patterns: [
-            /Effect\.(?:sleep|timeout|delay)\s*\(\s*\d+\s*\)/,
-            /Effect\.(?:timeout|delay)\s*\([^,]+,\s*\d+\s*\)/,
-        ],
-    },
-    {
-        name: 'effect-no-mixed-effect-import-styles',
-        message: 'Use one Effect import style per file.',
-        tokens: ['import'],
-        check: hasMixedEffectImportStyles,
-    },
-    {
-        name: 'effect-prefer-effect-is',
-        message: 'Use Effect.isEffect for Effect type checks.',
-        tokens: ['instanceof', '_op'],
-        patterns: [/\b[A-Za-z_$][\w$]*\s+instanceof\s+Effect\b/, /\._op\s*===\s*['"]Effect['"]/],
-    },
-    {
-        name: 'effect-no-try-catch-in-effect-gen',
-        message: 'Use Effect error combinators instead of try/catch inside Effect.gen.',
-        tokenGroups: [['gen'], ['try']],
-        ast: (context, source) => ({
-            TryStatement(node) {
-                const { start } = node;
-                if (typeof start !== 'number') {
-                    return;
-                }
-                const index = hasTryCatchInEffectGen(source);
-                if (typeof index === 'number' && index === start) {
-                    reportAst(context, 'Use Effect error combinators instead of try/catch inside Effect.gen.', node);
-                }
-            },
-        }),
-    },
-    {
-        name: 'effect-no-new-promise',
-        message: 'Use Effect.async, Effect.promise, or Effect.tryPromise instead of new Promise.',
-        tokenGroups: [['Promise'], ['Effect', 'effect']],
-        ast: (context, source) => {
-            const isEffectModule = hasEffectSignal(source);
-            return {
-                NewExpression(node) {
-                    if (isEffectModule && identifierName(node.callee) === 'Promise') {
-                        reportAst(context, 'Use Effect.async, Effect.promise, or Effect.tryPromise instead of new Promise.', node);
-                    }
-                },
-            };
-        },
-    },
-    {
-        name: 'effect-no-global-timers',
-        message: 'Use Effect.sleep, Schedule, or Clock instead of global timers in Effect modules.',
-        tokens: ['setTimeout', 'setInterval', 'clearTimeout', 'clearInterval'],
-        ast: (context, source) => {
-            const isEffectModule = hasEffectSignal(source);
-            return {
-                CallExpression(node) {
-                    const calleeName = identifierName(node.callee);
-                    if (isEffectModule &&
-                        calleeName &&
-                        ['clearInterval', 'clearTimeout', 'setInterval', 'setTimeout'].includes(calleeName)) {
-                        reportAst(context, 'Use Effect.sleep, Schedule, or Clock instead of global timers in Effect modules.', node);
-                    }
-                },
-            };
-        },
-    },
-    {
-        name: 'effect-no-native-error-classes',
-        message: 'Use tagged/data/schema errors instead of classes extending native Error.',
-        tokens: ['Error'],
-        check: hasNativeErrorClassInEffectModule,
-        ast: (context, source) => {
-            const isEffectModule = hasEffectSignal(source);
-            return {
-                ClassDeclaration(node) {
-                    if (isEffectModule && identifierName(node.superClass) === 'Error') {
-                        reportAst(context, 'Use tagged/data/schema errors instead of classes extending native Error.', node);
-                    }
-                },
-            };
-        },
-    },
-    {
-        name: 'effect-no-unsafe-effect-type-assertion',
-        message: 'Do not assert Effect error or requirement channels with type casts.',
-        tokenGroups: [[' as '], ['Effect.Effect']],
-        check: hasUnsafeEffectTypeAssertion,
-        ast: (context) => ({
-            TSAsExpression(node) {
-                if (typeReferenceName(node.typeAnnotation) === 'Effect.Effect') {
-                    reportAst(context, 'Do not assert Effect error or requirement channels with type casts.', node);
-                }
-            },
-        }),
-    },
-    {
-        name: 'effect-require-service-self-match',
-        message: 'Effect service/tag self type must match the declaring class name.',
-        tokenGroups: [['class'], ['extends'], ['Context', 'Service', 'Tag']],
-        check: hasServiceSelfMismatch,
-        ast: (context, source) => ({
-            ClassDeclaration(node) {
-                const className = identifierName(node.id);
-                const selfName = effectServiceSelfName(node.superClass, source);
-                if (className && selfName && className !== selfName) {
-                    reportAst(context, 'Effect service/tag self type must match the declaring class name.', node);
-                }
-            },
-        }),
-    },
-    {
-        name: 'effect-no-effect-fn-iife',
-        message: 'Do not call Effect.fn as an IIFE; use Effect.gen for local one-shot workflows.',
-        tokenGroups: [['fn'], ['Effect', 'effect']],
-        check: hasEffectFnIife,
-        ast: (context, source) => {
-            const isEffectFn = effectCallPredicate(source, ['fn', 'fnUntraced', 'fnUntracedEager']);
-            return {
-                CallExpression(node) {
-                    const outerCallee = node.callee;
-                    const middleCallee = outerCallee?.callee;
-                    const innerCallee = middleCallee?.callee;
-                    if (nodeType(outerCallee) === 'CallExpression' &&
-                        nodeType(middleCallee) === 'CallExpression' &&
-                        isEffectFn(innerCallee)) {
-                        reportAst(context, 'Do not call Effect.fn as an IIFE; use Effect.gen for local one-shot workflows.', node);
+                        reportAST(context, 'Use Effect logging APIs instead of console logging in Effect code.', node);
                     }
                 },
             };
         },
+        message: 'Use Effect logging APIs instead of console logging in Effect code.',
+        name: 'effect-no-console-log-in-effect-code',
+        tokens: ['console'],
     },
+    ...effectDefaultEnvironmentSpecs,
+    ...effectDefaultCompatibilitySpecs,
 ];
 const effectDefaultRules = makeRules(effectDefaultSpecs, {
     defaultTokens: effectDefaultRuleTokens,