@thethracian/oxlint-config 0.2.0 → 0.2.1

package/dist/rules/effect-default.js

@@ -4,6 +4,24 @@ import { hasForkBeforeTestClockAdjust, hasRealSleepWithoutTestClock, hasTestCloc
 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';
+const effectDefaultRuleTokens = [
+    'Effect',
+    'Schema',
+    'Config',
+    'Context',
+    'Queue',
+    'Stream',
+    'TestClock',
+    'from "effect"',
+    "from 'effect'",
+    '@effect/',
+    '"effect/',
+    "'effect/",
+    'it.effect',
+    'describe.effect',
+    'JSON.parse',
+    'response.json',
+];
 function reportAst(context, message, node) {
     context.report({ message, node });
 }
@@ -36,17 +54,18 @@ function memberParts(node) {
         propertyName: identifierName(member.property),
     };
 }
-function isEffectMember(node, source, methods) {
-    const { objectName, propertyName } = memberParts(node);
-    return Boolean(objectName &&
-        propertyName &&
-        effectImportAliases(source).includes(objectName) &&
-        methods.has(propertyName));
-}
-function isEffectFunctionCall(callee, source, names) {
-    const calleeName = identifierName(callee);
-    return Boolean(calleeName &&
-        [...names].some((name) => effectFunctionAliases(source, 'Effect', name).includes(calleeName)));
+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);
@@ -179,128 +198,152 @@ const effectDefaultSpecs = [
     {
         name: 'effect-require-yield-star',
         message: 'Use yield* inside Effect.gen so generator composition unwraps the Effect value.',
+        tokenGroups: [['gen'], ['yield']],
         check: hasYieldWithoutStarInGen,
     },
     {
         name: 'effect-require-return-yield-star',
         message: 'Do not return an Effect from Effect.gen; return a value or return yield* the Effect.',
+        tokenGroups: [['gen'], ['return']],
         check: hasReturnEffectInGen,
     },
     {
         name: 'effect-prefer-gen-for-nested-flatmap',
         message: 'Replace nested Effect.flatMap callbacks with Effect.gen for readable sequencing.',
+        tokens: ['flatMap'],
         check: hasNestedFlatMap,
     },
     {
         name: 'effect-no-function-returning-gen',
         message: 'Use Effect.fn for exported effectful functions instead of returning Effect.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',
         message: 'Exported effectful functions should use Effect.fn for tracing and stable contracts.',
+        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']],
         patterns: [/Effect\.gen\s*\(\s*function\*\s*\([^)]*\)\s*{\s*return\s+yield\*\s+Effect\./],
     },
     {
         name: 'effect-no-effect-in-array-foreach',
         message: 'Use Effect.forEach instead of Array.forEach with Effect-returning callbacks.',
+        tokens: ['forEach'],
         check: hasEffectInArrayForEach,
     },
     {
         name: 'effect-no-effect-in-promise-callback',
         message: 'Do not create Effect values inside Promise callbacks; compose at the Effect boundary.',
+        tokens: ['.then', '.catch'],
         check: hasEffectInPromiseCallback,
     },
     {
         name: 'effect-no-floating-fiber',
         message: 'Forked fibers must be joined, interrupted, scoped, supervised, or returned.',
+        tokens: ['fork'],
         check: hasUnobservedFork,
     },
     {
         name: 'effect-require-suspend-for-recursion',
         message: 'Recursive Effect construction must be wrapped in Effect.suspend.',
+        tokens: ['function', '=>'],
         check: hasRecursiveEffectWithoutSuspend,
     },
     {
         name: 'effect-require-suspend-for-lazy-evaluation',
         message: 'Use Effect.suspend when Effect construction must defer eager JavaScript work.',
+        tokens: ['Date.now', 'Math.random', 'new Date', 'JSON.parse'],
         check: hasUnsafeLazyEvaluation,
     },
     {
         name: 'effect-no-async-await-in-effect',
         message: 'Use Effect.tryPromise or Effect.promise boundaries instead of async/await in Effect code.',
+        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.',
-        ast: (context, source) => ({
-            CallExpression(node) {
-                if (!hasEffectSignal(source)) {
-                    return;
-                }
-                const { callee } = node;
-                const { propertyName } = memberParts(callee);
-                if (propertyName === 'then' || propertyName === 'catch') {
-                    reportAst(context, 'Use Effect combinators instead of Promise then/catch chains in Effect modules.', node);
-                }
-            },
-        }),
+        tokens: ['.then', '.catch'],
+        ast: (context, source) => {
+            const isEffectModule = hasEffectSignal(source);
+            return {
+                CallExpression(node) {
+                    if (!isEffectModule) {
+                        return;
+                    }
+                    const { callee } = node;
+                    const { propertyName } = memberParts(callee);
+                    if (propertyName === 'then' || propertyName === 'catch') {
+                        reportAst(context, 'Use Effect combinators instead of Promise then/catch chains in Effect modules.', node);
+                    }
+                },
+            };
+        },
     },
     {
         name: 'effect-no-throw',
         message: 'Use typed Effect failures instead of throw inside Effect workflows.',
+        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) => ({
-            CallExpression(node) {
-                const call = node;
-                if ((isEffectMember(call.callee, source, new Set(['fail'])) ||
-                    isEffectFunctionCall(call.callee, source, new Set(['fail']))) &&
-                    isStringLikeLiteral(call.arguments?.[0])) {
-                    reportAst(context, 'Use structured tagged errors instead of string failures.', node);
-                }
-            },
-        }),
+        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);
+                    }
+                },
+            };
+        },
     },
     {
         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) => ({
-            CallExpression(node) {
-                const call = node;
-                const firstArg = call.arguments?.[0];
-                if (!isEffectMember(call.callee, source, new Set(['fail'])) &&
-                    !isEffectFunctionCall(call.callee, source, new Set(['fail']))) {
-                    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);
-                }
-            },
-        }),
+        ast: (context, source) => {
+            const isEffectFail = effectCallPredicate(source, ['fail']);
+            return {
+                CallExpression(node) {
+                    const call = node;
+                    const firstArg = call.arguments?.[0];
+                    if (!isEffectFail(call.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);
+                    }
+                },
+            };
+        },
     },
     {
         name: 'effect-no-silent-error-swallowing',
         message: 'Do not erase Effect failures without recovery, logging, or explicit typed replacement.',
+        tokens: ['catchAll', 'ignore'],
         patterns: [
             /Effect\.(?:catchAll|ignore)\s*\([\s\S]*?(?:Effect\.void|Effect\.succeed\s*\(\s*undefined|undefined)/,
         ],
@@ -308,129 +351,162 @@ const effectDefaultSpecs = [
     {
         name: 'effect-require-typed-error-in-trypromise',
         message: 'Use Effect.tryPromise({ try, catch }) so Promise failures become typed Effect errors.',
+        tokens: ['tryPromise'],
         check: hasTryPromiseWithoutTypedCatch,
     },
     {
         name: 'effect-prefer-catchTag-over-catchAll',
         message: 'Prefer catchTag or catchTags over broad catchAll recovery.',
+        tokens: ['catchAll'],
         check: hasBroadCatchAllWithoutRethrow,
     },
     {
         name: 'effect-no-catchAll-with-mapError',
         message: 'Use mapError directly instead of catchAll when only transforming the error.',
+        tokens: ['catchAll'],
         patterns: [/Effect\.catchAll\s*\([\s\S]*?=>\s*Effect\.fail\s*\(/],
     },
     {
         name: 'effect-prefer-mapError-over-catchAll-rethrow',
         message: 'Use Effect.mapError instead of catchAll followed by fail.',
+        tokens: ['catchAll'],
         patterns: [/(?:^|[^\w$.])catchAll\s*\([\s\S]*?=>\s*Effect\.fail\s*\(/],
     },
     {
         name: 'effect-require-error-cause-preserved',
         message: 'Preserve the original cause when mapping or wrapping Effect errors.',
+        tokens: ['mapError', 'catchAll'],
         check: hasErrorMappingWithoutCause,
     },
     {
         name: 'effect-prefer-ignore-logged',
         message: 'Ignored Effect failures must be logged or otherwise observable.',
+        tokens: ['ignore'],
         check: hasUnloggedIgnore,
     },
     {
         name: 'effect-prefer-catchTags-for-multiple-tags',
         message: 'Use Effect.catchTags for multiple tagged Effect recoveries.',
+        tokens: ['catchTag'],
         check: hasMultipleCatchTagsInOnePipe,
     },
     {
         name: 'effect-no-error-channel-widening-to-unknown',
         message: 'Do not widen Effect error channels to unknown.',
+        tokens: ['unknown'],
         patterns: [/Effect\s*<[^>]*,\s*unknown\b/, /Effect\.fail\s*<\s*unknown\b/],
     },
     {
         name: 'effect-no-run-inside-effect',
         message: 'Do not run an Effect from inside another Effect; yield or compose it instead.',
+        tokens: ['run'],
         check: hasRuntimeInEffect,
     },
     {
         name: 'effect-no-runpromise-in-exported-api',
         message: 'Exported APIs should expose Effect values instead of hiding execution behind Promise.',
+        tokens: ['runPromise'],
         check: (source) => exportedDeclarationSegments(source).some((segment) => /Effect\.runPromise\s*\(/.test(segment)),
     },
     {
         name: 'effect-no-runfork-without-observer',
         message: 'Do not call runFork without explicit observation, supervision, or interruption.',
+        tokens: ['runFork'],
         check: hasRunForkWithoutObserver,
     },
     {
         name: 'effect-no-sync-for-promise',
         message: 'Use Effect.tryPromise for Promise-returning code instead of Effect.sync.',
+        tokenGroups: [['sync'], ['async', 'fetch', 'Promise.']],
         check: hasSyncForPromise,
     },
     {
         name: 'effect-no-sync-for-throwing-ops',
         message: 'Use Effect.try for synchronous code that can throw instead of Effect.sync.',
+        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.',
-        ast: (context, source) => ({
-            CallExpression(node) {
-                const { objectName, propertyName } = memberParts(node.callee);
-                if (hasEffectSignal(source) &&
-                    objectName === 'console' &&
-                    propertyName &&
-                    ['debug', 'error', 'info', 'log', 'warn'].includes(propertyName)) {
-                    reportAst(context, 'Use Effect logging APIs instead of console logging in Effect code.', node);
-                }
-            },
-        }),
+        tokens: ['console'],
+        ast: (context, source) => {
+            const isEffectModule = hasEffectSignal(source);
+            return {
+                CallExpression(node) {
+                    const { objectName, propertyName } = memberParts(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.',
-        ast: (context, source) => ({
-            MemberExpression(node) {
-                const { objectName, propertyName } = memberParts(node);
-                const processEnv = objectName === 'process' && propertyName === 'env';
-                if (hasEffectSignal(source) && !isConfiguredPath(context, 'configLayers') && processEnv) {
-                    reportAst(context, 'Use Effect Config instead of process.env in Effect code.', node);
-                }
-            },
-        }),
+        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.',
-        ast: (context, source) => ({
-            CallExpression(node) {
-                const { objectName, propertyName } = memberParts(node.callee);
-                if (hasEffectSignal(source) &&
-                    !isConfiguredPath(context, 'adapterLayers') &&
-                    objectName === 'Date' &&
-                    propertyName === 'now') {
-                    reportAst(context, 'Use Effect Clock instead of Date.now in Effect code.', node);
-                }
-            },
-        }),
+        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.',
-        ast: (context, source) => ({
-            CallExpression(node) {
-                const { objectName, propertyName } = memberParts(node.callee);
-                if (hasEffectSignal(source) &&
-                    !isConfiguredPath(context, 'adapterLayers') &&
-                    objectName === 'Math' &&
-                    propertyName === 'random') {
-                    reportAst(context, 'Use Effect Random instead of Math.random in Effect code.', node);
-                }
-            },
-        }),
+        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$]*/,
@@ -439,71 +515,85 @@ const effectDefaultSpecs = [
     {
         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/,
         ],
@@ -511,26 +601,31 @@ const effectDefaultSpecs = [
     {
         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/,
         ],
@@ -538,11 +633,13 @@ const effectDefaultSpecs = [
     {
         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)),
@@ -550,22 +647,26 @@ const effectDefaultSpecs = [
     {
         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)) &&
@@ -574,48 +675,57 @@ const effectDefaultSpecs = [
     {
         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*\)/,
@@ -624,11 +734,13 @@ const effectDefaultSpecs = [
     {
         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*\)/,
@@ -637,16 +749,19 @@ const effectDefaultSpecs = [
     {
         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;
@@ -663,43 +778,56 @@ const effectDefaultSpecs = [
     {
         name: 'effect-no-new-promise',
         message: 'Use Effect.async, Effect.promise, or Effect.tryPromise instead of new Promise.',
-        ast: (context, source) => ({
-            NewExpression(node) {
-                if (hasEffectSignal(source) && identifierName(node.callee) === 'Promise') {
-                    reportAst(context, 'Use Effect.async, Effect.promise, or Effect.tryPromise instead of new Promise.', node);
-                }
-            },
-        }),
+        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.',
-        ast: (context, source) => ({
-            CallExpression(node) {
-                const calleeName = identifierName(node.callee);
-                if (hasEffectSignal(source) &&
-                    calleeName &&
-                    ['clearInterval', 'clearTimeout', 'setInterval', 'setTimeout'].includes(calleeName)) {
-                    reportAst(context, 'Use Effect.sleep, Schedule, or Clock instead of global timers in Effect modules.', node);
-                }
-            },
-        }),
+        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) => ({
-            ClassDeclaration(node) {
-                if (hasEffectSignal(source) && identifierName(node.superClass) === 'Error') {
-                    reportAst(context, 'Use tagged/data/schema errors instead of classes extending native Error.', node);
-                }
-            },
-        }),
+        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) {
@@ -712,6 +840,7 @@ const effectDefaultSpecs = [
     {
         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) {
@@ -726,21 +855,28 @@ const effectDefaultSpecs = [
     {
         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) => ({
-            CallExpression(node) {
-                const outerCallee = node.callee;
-                const middleCallee = outerCallee?.callee;
-                const innerCallee = middleCallee?.callee;
-                if (nodeType(outerCallee) === 'CallExpression' &&
-                    nodeType(middleCallee) === 'CallExpression' &&
-                    isEffectMember(innerCallee, source, new Set(['fn', 'fnUntraced', 'fnUntracedEager']))) {
-                    reportAst(context, 'Do not call Effect.fn as an IIFE; use Effect.gen for local one-shot workflows.', node);
-                }
-            },
-        }),
+        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);
+                    }
+                },
+            };
+        },
     },
 ];
-const effectDefaultRules = makeRules(effectDefaultSpecs, { schema: strictPathOptionsSchema });
+const effectDefaultRules = makeRules(effectDefaultSpecs, {
+    defaultTokens: effectDefaultRuleTokens,
+    schema: strictPathOptionsSchema,
+});
 export default effectDefaultRules;
 //# sourceMappingURL=effect-default.js.map