oxlint-plugin-effect 0.10.0 → 0.11.0

package/README.md

@@ -25,27 +25,38 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 
 ## Recommended Rules
 
-| Rule                               | Contract                                                                                  |
-| ---------------------------------- | ----------------------------------------------------------------------------------------- |
-| `effect/noAs`                      | Bans TypeScript `as` assertions; use `satisfies`                                          |
-| `effect/noAsyncFunction`           | Bans async functions and await expressions                                                |
-| `effect/noTryCatch`                | Bans every try/catch/finally statement                                                    |
-| `effect/noTestLifecycleHooks`      | Bans `beforeEach`, `afterEach`, `beforeAll`, and `afterAll`; use Effect scopes instead    |
-| `effect/noThrowStatement`          | Bans every throw statement                                                                |
-| `effect/noNewPromise`              | Bans new Promise, Promise calls, and Promise static APIs                                  |
-| `effect/noNewError`                | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
-| `effect/noNullish`                 | Bans null and undefined; use Option or a domain enum for richer state                     |
-| `effect/noModuleMocks`             | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
-| `effect/noTernary`                 | Bans conditional expressions while allowing ordinary if statements                        |
-| `effect/noDynamicImports`          | Allows import() only behind a named lazy-loading boundary; bans require()                 |
-| `effect/noEffectDo`                | Bans Effect.Do                                                                            |
-| `effect/noEffectBind`              | Bans Effect.bind                                                                          |
-| `effect/preferCatchTag`            | Replaces manual `_tag` predicates in `Effect.catchIf` with tagged recovery                |
-| `effect/preferEffectFn`            | Requires `Effect.fn` for a generator operation that adds a span                           |
-| `effect/preferMatchTagsExhaustive` | Requires exhaustive `Match` for return-only `_tag` switches                               |
-| `effect/preferPredicateIsTagged`   | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
-| `effect/noGlobals`                 | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
-| `effect/noNodeBuiltinImport`       | Bans fully replaced Node modules and replaced operations from partial modules             |
+| Rule                                   | Contract                                                                                  |
+| -------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `effect/noAs`                          | Bans TypeScript `as` assertions; use `satisfies`                                          |
+| `effect/noAsyncFunction`               | Bans async functions and await expressions                                                |
+| `effect/noTryCatch`                    | Bans every try/catch/finally statement                                                    |
+| `effect/noTestLifecycleHooks`          | Bans `beforeEach`, `afterEach`, `beforeAll`, and `afterAll`; use Effect scopes instead    |
+| `effect/noThrowStatement`              | Bans every throw statement                                                                |
+| `effect/noNewPromise`                  | Bans new Promise, Promise calls, and Promise static APIs                                  |
+| `effect/noNewError`                    | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
+| `effect/noNullish`                     | Bans null and undefined; use Option or a domain enum for richer state                     |
+| `effect/noModuleMocks`                 | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
+| `effect/noTernary`                     | Bans conditional expressions while allowing ordinary if statements                        |
+| `effect/noManagedRuntimeInEffect`      | Keeps ManagedRuntime construction at non-Effect host boundaries                           |
+| `effect/noInlineProvide`               | Keeps dependency provisioning at explicit composition boundaries                          |
+| `effect/noNestedEffectGen`             | Flattens directly yielded nested generators                                               |
+| `effect/noPerCallCacheConstruction`    | Constructs shared caches once in their owning layer                                       |
+| `effect/noRunCollectOnUnboundedStream` | Requires termination before collecting a clearly unbounded Stream                         |
+| `effect/noSequentialEffectAll`         | Uses explicit sequencing when serial aggregation discards its result                      |
+| `effect/noSilentCatchAll`              | Keeps swallowed failures visible or recovers them truthfully                              |
+| `effect/noUnboundedConcurrency`        | Requires finite concurrency for collections that can grow                                 |
+| `effect/noUnboundedRetry`              | Requires an attempt or duration bound on retry schedules                                  |
+| `effect/noDynamicImports`              | Allows import() only behind a named lazy-loading boundary; bans require()                 |
+| `effect/noEffectDo`                    | Bans Effect.Do                                                                            |
+| `effect/noEffectBind`                  | Bans Effect.bind                                                                          |
+| `effect/preferCatchTag`                | Replaces manual `_tag` predicates and `catchAll` dispatch with tagged recovery            |
+| `effect/preferEffectFn`                | Requires `Effect.fn` for a generator operation that adds a span                           |
+| `effect/preferMatchTagsExhaustive`     | Requires exhaustive `Match` for return-only `_tag` switches and if chains                 |
+| `effect/preferPredicateIsTagged`       | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
+| `effect/preferServiceOf`               | Checks inline Layer implementations through `Service.of`                                  |
+| `effect/requireNamedEffectFn`          | Requires stable names for `Effect.fn` operations                                          |
+| `effect/noGlobals`                     | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
+| `effect/noNodeBuiltinImport`           | Bans fully replaced Node modules and replaced operations from partial modules             |
 
 ## Anti-Slop Rules
 

package/dist/presets/recommended.d.ts

@@ -13,19 +13,28 @@ declare const recommended: {
   readonly "effect/noEffectBind": "error";
   readonly "effect/noEffectDo": "error";
   readonly "effect/noGlobals": "error";
+  readonly "effect/noInlineProvide": "error";
   readonly "effect/noKnownValueWidening": "error";
+  readonly "effect/noManagedRuntimeInEffect": "error";
   readonly "effect/noModuleMocks": "error";
+  readonly "effect/noNestedEffectGen": "error";
   readonly "effect/noNewError": "error";
   readonly "effect/noNewPromise": "error";
   readonly "effect/noNodeBuiltinImport": "error";
   readonly "effect/noNullish": "error";
   readonly "effect/noObjectParameters": "error";
+  readonly "effect/noPerCallCacheConstruction": "error";
+  readonly "effect/noRunCollectOnUnboundedStream": "error";
   readonly "effect/noRuntimeTypeof": "error";
+  readonly "effect/noSequentialEffectAll": "error";
   readonly "effect/noShapeInSymbolNames": "error";
+  readonly "effect/noSilentCatchAll": "error";
   readonly "effect/noTernary": "error";
   readonly "effect/noTestLifecycleHooks": "error";
   readonly "effect/noThrowStatement": "error";
   readonly "effect/noTryCatch": "error";
+  readonly "effect/noUnboundedConcurrency": "error";
+  readonly "effect/noUnboundedRetry": "error";
   readonly "effect/noUnknownParameters": "error";
   readonly "effect/noUnknownTypeAliases": "error";
   readonly "effect/noUnsafeDictionaryType": "error";
@@ -34,6 +43,8 @@ declare const recommended: {
   readonly "effect/preferEffectFn": "error";
   readonly "effect/preferMatchTagsExhaustive": "error";
   readonly "effect/preferPredicateIsTagged": "error";
+  readonly "effect/preferServiceOf": "error";
+  readonly "effect/requireNamedEffectFn": "error";
 };
 //#endregion
 export { recommended };

package/dist/presets/recommended.js

@@ -13,19 +13,28 @@ const recommended = {
 	"effect/noEffectBind": "error",
 	"effect/noEffectDo": "error",
 	"effect/noGlobals": "error",
+	"effect/noInlineProvide": "error",
 	"effect/noKnownValueWidening": "error",
+	"effect/noManagedRuntimeInEffect": "error",
 	"effect/noModuleMocks": "error",
+	"effect/noNestedEffectGen": "error",
 	"effect/noNewError": "error",
 	"effect/noNewPromise": "error",
 	"effect/noNodeBuiltinImport": "error",
 	"effect/noNullish": "error",
 	"effect/noObjectParameters": "error",
+	"effect/noPerCallCacheConstruction": "error",
+	"effect/noRunCollectOnUnboundedStream": "error",
 	"effect/noRuntimeTypeof": "error",
+	"effect/noSequentialEffectAll": "error",
 	"effect/noShapeInSymbolNames": "error",
+	"effect/noSilentCatchAll": "error",
 	"effect/noTernary": "error",
 	"effect/noTestLifecycleHooks": "error",
 	"effect/noThrowStatement": "error",
 	"effect/noTryCatch": "error",
+	"effect/noUnboundedConcurrency": "error",
+	"effect/noUnboundedRetry": "error",
 	"effect/noUnknownParameters": "error",
 	"effect/noUnknownTypeAliases": "error",
 	"effect/noUnsafeDictionaryType": "error",
@@ -33,7 +42,9 @@ const recommended = {
 	"effect/preferCatchTag": "error",
 	"effect/preferEffectFn": "error",
 	"effect/preferMatchTagsExhaustive": "error",
-	"effect/preferPredicateIsTagged": "error"
+	"effect/preferPredicateIsTagged": "error",
+	"effect/preferServiceOf": "error",
+	"effect/requireNamedEffectFn": "error"
 };
 //#endregion
 export { recommended };

package/dist/rules/_effect-context.js

@@ -0,0 +1,27 @@
+import { isStaticCall, isStaticMember } from "./_effect-namespaces.js";
+//#region src/rules/_effect-context.ts
+const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const effectProgramKind = (node, effectNamespaces) => {
+	const parent = node.parent;
+	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return void 0;
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "gen")) return "gen";
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fn")) return "fn";
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
+	if (parent.callee.type !== "CallExpression") return void 0;
+	if (isStaticCall(parent.callee, effectNamespaces, "fn")) return "fn";
+	if (isStaticCall(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
+};
+const enclosingEffectProgram = (node, effectNamespaces) => {
+	let current = node.parent;
+	while (current !== void 0 && current !== null) {
+		if (isFunction(current)) {
+			const kind = effectProgramKind(current, effectNamespaces);
+			if (kind === void 0) return void 0;
+			return [current, kind];
+		}
+		current = current.parent;
+	}
+};
+const isInsideEffectProgram = (node, effectNamespaces) => enclosingEffectProgram(node, effectNamespaces) !== void 0;
+//#endregion
+export { enclosingEffectProgram, isInsideEffectProgram };

package/dist/rules/_effect-namespaces.js

@@ -0,0 +1,25 @@
+import { findVariableUp } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+//#region src/rules/_effect-namespaces.ts
+const importedNamespaces = (node, exportName, directModule) => {
+	const source = node.source.value;
+	if (source !== "effect" && source !== directModule) return [];
+	const namespaces = [];
+	for (const specifier of node.specifiers) {
+		if (specifier.type === "ImportNamespaceSpecifier" && source === directModule) {
+			namespaces.push(specifier.local.name);
+			continue;
+		}
+		if (specifier.type === "ImportSpecifier" && source === "effect" && specifier.imported.type === "Identifier" && specifier.imported.name === exportName) namespaces.push(specifier.local.name);
+	}
+	return namespaces;
+};
+const visibleNamespaces = (ctx, node, namespaces) => new Set([...namespaces].filter((namespace) => Option.match(findVariableUp(ctx.sourceCode.getScope(node), namespace), {
+	onNone: () => true,
+	onSome: (variable) => variable.defs.some((definition) => definition.type === "ImportBinding")
+})));
+const isStaticMember = (node, namespaces, property) => node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && namespaces.has(node.object.name) && node.property.type === "Identifier" && node.property.name === property;
+const isStaticCall = (node, namespaces, property) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, namespaces, property);
+//#endregion
+export { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces };

package/dist/rules/_tagged-control-flow.js

@@ -76,4 +76,4 @@ const isInsideCatchAllHandler = (node) => {
 };
 const taggedSwitchSubject = (node) => taggedSubject(node.discriminant);
 //#endregion
-export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparisonsInOr, taggedSwitchSubject };
+export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparison, tagComparisonsInOr, taggedSwitchSubject };

package/dist/rules/index.d.ts

@@ -6,19 +6,28 @@ import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
 import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
+import { noInlineProvide } from "./no-inline-provide.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
+import { noManagedRuntimeInEffect } from "./no-managed-runtime-in-effect.js";
 import { noModuleMocks } from "./no-module-mocks.js";
+import { noNestedEffectGen } from "./no-nested-effect-gen.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
 import { noObjectParameters } from "./no-object-parameters.js";
+import { noPerCallCacheConstruction } from "./no-per-call-cache-construction.js";
+import { noRunCollectOnUnboundedStream } from "./no-run-collect-on-unbounded-stream.js";
 import { noRuntimeTypeof } from "./no-runtime-typeof.js";
+import { noSequentialEffectAll } from "./no-sequential-effect-all.js";
 import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
+import { noSilentCatchAll } from "./no-silent-catch-all.js";
 import { noTernary } from "./no-ternary.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
+import { noUnboundedConcurrency } from "./no-unbounded-concurrency.js";
+import { noUnboundedRetry } from "./no-unbounded-retry.js";
 import { noUnknownParameters } from "./no-unknown-parameters.js";
 import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
 import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
@@ -27,10 +36,12 @@ import { preferCatchTag } from "./prefer-catch-tag.js";
 import { preferEffectFn } from "./prefer-effect-fn.js";
 import { preferMatchTagsExhaustive } from "./prefer-match-tags-exhaustive.js";
 import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
+import { preferServiceOf } from "./prefer-service-of.js";
+import { requireNamedEffectFn } from "./require-named-effect-fn.js";
 
 //#region src/rules/index.d.ts
 declare namespace index_d_exports {
-  export { noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noKnownValueWidening, noModuleMocks, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noRuntimeTypeof, noShapeInSymbolNames, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged };
+  export { noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noInlineProvide, noKnownValueWidening, noManagedRuntimeInEffect, noModuleMocks, noNestedEffectGen, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noPerCallCacheConstruction, noRunCollectOnUnboundedStream, noRuntimeTypeof, noSequentialEffectAll, noShapeInSymbolNames, noSilentCatchAll, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnboundedConcurrency, noUnboundedRetry, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged, preferServiceOf, requireNamedEffectFn };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -7,19 +7,28 @@ import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
 import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
+import { noInlineProvide } from "./no-inline-provide.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
+import { noManagedRuntimeInEffect } from "./no-managed-runtime-in-effect.js";
 import { noModuleMocks } from "./no-module-mocks.js";
+import { noNestedEffectGen } from "./no-nested-effect-gen.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
 import { noObjectParameters } from "./no-object-parameters.js";
+import { noPerCallCacheConstruction } from "./no-per-call-cache-construction.js";
+import { noRunCollectOnUnboundedStream } from "./no-run-collect-on-unbounded-stream.js";
 import { noRuntimeTypeof } from "./no-runtime-typeof.js";
+import { noSequentialEffectAll } from "./no-sequential-effect-all.js";
 import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
+import { noSilentCatchAll } from "./no-silent-catch-all.js";
 import { noTernary } from "./no-ternary.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
+import { noUnboundedConcurrency } from "./no-unbounded-concurrency.js";
+import { noUnboundedRetry } from "./no-unbounded-retry.js";
 import { noUnknownParameters } from "./no-unknown-parameters.js";
 import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
 import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
@@ -28,6 +37,8 @@ import { preferCatchTag } from "./prefer-catch-tag.js";
 import { preferEffectFn } from "./prefer-effect-fn.js";
 import { preferMatchTagsExhaustive } from "./prefer-match-tags-exhaustive.js";
 import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
+import { preferServiceOf } from "./prefer-service-of.js";
+import { requireNamedEffectFn } from "./require-named-effect-fn.js";
 //#region src/rules/index.ts
 var rules_exports = /* @__PURE__ */ __exportAll({
 	noAs: () => noAs,
@@ -38,19 +49,28 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	noEffectBind: () => noEffectBind,
 	noEffectDo: () => noEffectDo,
 	noGlobals: () => noGlobals,
+	noInlineProvide: () => noInlineProvide,
 	noKnownValueWidening: () => noKnownValueWidening,
+	noManagedRuntimeInEffect: () => noManagedRuntimeInEffect,
 	noModuleMocks: () => noModuleMocks,
+	noNestedEffectGen: () => noNestedEffectGen,
 	noNewError: () => noNewError,
 	noNewPromise: () => noNewPromise,
 	noNodeBuiltinImport: () => noNodeBuiltinImport,
 	noNullish: () => noNullish,
 	noObjectParameters: () => noObjectParameters,
+	noPerCallCacheConstruction: () => noPerCallCacheConstruction,
+	noRunCollectOnUnboundedStream: () => noRunCollectOnUnboundedStream,
 	noRuntimeTypeof: () => noRuntimeTypeof,
+	noSequentialEffectAll: () => noSequentialEffectAll,
 	noShapeInSymbolNames: () => noShapeInSymbolNames,
+	noSilentCatchAll: () => noSilentCatchAll,
 	noTernary: () => noTernary,
 	noTestLifecycleHooks: () => noTestLifecycleHooks,
 	noThrowStatement: () => noThrowStatement,
 	noTryCatch: () => noTryCatch,
+	noUnboundedConcurrency: () => noUnboundedConcurrency,
+	noUnboundedRetry: () => noUnboundedRetry,
 	noUnknownParameters: () => noUnknownParameters,
 	noUnknownTypeAliases: () => noUnknownTypeAliases,
 	noUnsafeDictionaryType: () => noUnsafeDictionaryType,
@@ -58,7 +78,9 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	preferCatchTag: () => preferCatchTag,
 	preferEffectFn: () => preferEffectFn,
 	preferMatchTagsExhaustive: () => preferMatchTagsExhaustive,
-	preferPredicateIsTagged: () => preferPredicateIsTagged
+	preferPredicateIsTagged: () => preferPredicateIsTagged,
+	preferServiceOf: () => preferServiceOf,
+	requireNamedEffectFn: () => requireNamedEffectFn
 });
 //#endregion
 export { rules_exports };

package/dist/rules/no-inline-provide.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-inline-provide.d.ts
+declare const noInlineProvide: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noInlineProvide };

package/dist/rules/no-inline-provide.js

@@ -0,0 +1,39 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isInsideEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-inline-provide.ts
+/** Keep Effect provisioning at explicit composition boundaries. */
+const noInlineProvide = define({
+	name: "no-inline-provide",
+	meta: meta({
+		type: "problem",
+		description: "Keep Effect provisioning outside domain Effect operations."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticMember(node.callee, namespaces, "provide")) return Effect.void;
+				if (!isInsideEffectProgram(node, namespaces)) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Do not provide dependencies inside an Effect operation. Provide the layer once at the application, handler, command, or test boundary."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noInlineProvide };

package/dist/rules/no-managed-runtime-in-effect.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-managed-runtime-in-effect.d.ts
+declare const noManagedRuntimeInEffect: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noManagedRuntimeInEffect };

package/dist/rules/no-managed-runtime-in-effect.js

@@ -0,0 +1,41 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isInsideEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-managed-runtime-in-effect.ts
+/** Keep ManagedRuntime construction at non-Effect host boundaries. */
+const noManagedRuntimeInEffect = define({
+	name: "no-managed-runtime-in-effect",
+	meta: meta({
+		type: "problem",
+		description: "Create ManagedRuntime only at a non-Effect host boundary."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		const managedRuntimeNamespaces = new Set(["ManagedRuntime"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "ManagedRuntime", "effect/ManagedRuntime")) managedRuntimeNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const runtimes = visibleNamespaces(ctx, node, managedRuntimeNamespaces);
+				if (!isStaticMember(node.callee, runtimes, "make")) return Effect.void;
+				if (!isInsideEffectProgram(node, visibleNamespaces(ctx, node, effectNamespaces))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Create ManagedRuntime only at a non-Effect host boundary. Use the current Effect environment inside Effect programs."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noManagedRuntimeInEffect };

package/dist/rules/no-nested-effect-gen.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-nested-effect-gen.d.ts
+declare const noNestedEffectGen: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noNestedEffectGen };

package/dist/rules/no-nested-effect-gen.js

@@ -0,0 +1,39 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isInsideEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-nested-effect-gen.ts
+const isDirectYield = (node) => node.parent?.type === "YieldExpression";
+const noNestedEffectGen = define({
+	name: "no-nested-effect-gen",
+	meta: meta({
+		type: "suggestion",
+		description: "Flatten directly yielded nested Effect.gen programs."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticMember(node.callee, namespaces, "gen") || !isDirectYield(node)) return Effect.void;
+				if (!isInsideEffectProgram(node, namespaces)) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Flatten this directly yielded Effect.gen into the owning Effect operation."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noNestedEffectGen };

package/dist/rules/no-per-call-cache-construction.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-per-call-cache-construction.d.ts
+declare const noPerCallCacheConstruction: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noPerCallCacheConstruction };

package/dist/rules/no-per-call-cache-construction.js

@@ -0,0 +1,52 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { enclosingEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-per-call-cache-construction.ts
+const cachedEffectOperations = new Set([
+	"cached",
+	"cachedInvalidateWithTTL",
+	"cachedWithTTL"
+]);
+const cacheConstructors = new Set(["make", "makeWith"]);
+const isOperation = (node, namespaces, operations) => {
+	for (const operation of operations) if (isStaticMember(node, namespaces, operation)) return true;
+	return false;
+};
+const noPerCallCacheConstruction = define({
+	name: "no-per-call-cache-construction",
+	meta: meta({
+		type: "suggestion",
+		description: "Construct shared caches once in their owning layer."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		const cacheNamespaces = new Set(["Cache"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Cache", "effect/Cache")) cacheNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const effects = visibleNamespaces(ctx, node, effectNamespaces);
+				const program = enclosingEffectProgram(node, effects);
+				if (program === void 0 || program[1] === "gen") return Effect.void;
+				const caches = visibleNamespaces(ctx, node, cacheNamespaces);
+				if (!(isOperation(node.callee, effects, cachedEffectOperations) || isOperation(node.callee, caches, cacheConstructors))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Construct this cache once in its owning layer. Creating it inside an Effect operation creates new cache state on every call."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noPerCallCacheConstruction };

package/dist/rules/no-run-collect-on-unbounded-stream.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-run-collect-on-unbounded-stream.d.ts
+declare const noRunCollectOnUnboundedStream: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noRunCollectOnUnboundedStream };

package/dist/rules/no-run-collect-on-unbounded-stream.js

@@ -0,0 +1,81 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-run-collect-on-unbounded-stream.ts
+const unboundedSources = new Set([
+	"fromPubSub",
+	"fromPubSubTake",
+	"fromQueue",
+	"repeat"
+]);
+const collectOperations = new Set(["runCollect"]);
+const terminatingOperations = new Set([
+	"take",
+	"takeUntil",
+	"takeUntilEffect",
+	"takeWhile",
+	"takeWhileEffect",
+	"timeout",
+	"timeoutOrElse"
+]);
+const staticOperation = (node, streamNamespaces, operations) => {
+	if (node.type === "SpreadElement") return false;
+	const candidate = node.type === "CallExpression" && node.callee.type !== "Super" ? node.callee : node;
+	for (const operation of operations) if (isStaticMember(candidate, streamNamespaces, operation)) return true;
+	return false;
+};
+const unboundedRoot = (node, streamNamespaces) => {
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
+	for (const source of unboundedSources) if (isStaticMember(node.callee, streamNamespaces, source)) return node;
+	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
+	const root = unboundedRoot(node.callee.object, streamNamespaces);
+	if (root === void 0) return void 0;
+	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
+	return root;
+};
+const collectedSource = (node, streamNamespaces) => {
+	if (node.callee.type === "Super") return void 0;
+	if (isStaticMember(node.callee, streamNamespaces, "runCollect")) {
+		const source = node.arguments[0];
+		if (source !== void 0 && source.type !== "SpreadElement") return source;
+		return;
+	}
+	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
+	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
+	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, collectOperations)) return node.callee.object;
+};
+const noRunCollectOnUnboundedStream = define({
+	name: "no-run-collect-on-unbounded-stream",
+	meta: meta({
+		type: "problem",
+		description: "Do not collect a clearly unbounded Stream without a terminating operation."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const streamNamespaces = new Set(["Stream"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Stream", "effect/Stream")) streamNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, streamNamespaces);
+				const source = collectedSource(node, namespaces);
+				if (source === void 0) return Effect.void;
+				const root = unboundedRoot(source, namespaces);
+				if (root === void 0) return Effect.void;
+				return ctx.report(make({
+					node: root,
+					message: "Do not collect a clearly unbounded Stream. Add a terminating operation or consume it with runForEach or runDrain."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noRunCollectOnUnboundedStream };

package/dist/rules/no-sequential-effect-all.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-sequential-effect-all.d.ts
+declare const noSequentialEffectAll: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noSequentialEffectAll };

package/dist/rules/no-sequential-effect-all.js

@@ -0,0 +1,61 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-sequential-effect-all.ts
+const propertyLiteral = (node, name) => {
+	if (node?.type !== "ObjectExpression") return void 0;
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if ((property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) && property.value.type === "Literal") {
+			const value = property.value.value;
+			if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+		}
+	}
+};
+const pipedToAsVoid = (node, effectNamespaces) => {
+	const member = node.parent;
+	if (member?.type !== "MemberExpression" || member.object !== node || member.computed || member.property.type !== "Identifier" || member.property.name !== "pipe") return false;
+	const pipe = member.parent;
+	if (pipe?.type !== "CallExpression") return false;
+	for (const operation of pipe.arguments) {
+		if (operation.type === "SpreadElement") continue;
+		if (isStaticMember(operation, effectNamespaces, "asVoid")) return true;
+	}
+	return false;
+};
+const noSequentialEffectAll = define({
+	name: "no-sequential-effect-all",
+	meta: meta({
+		type: "suggestion",
+		description: "Use explicit sequencing instead of a serial Effect.all whose result is discarded."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticMember(node.callee, namespaces, "all")) return Effect.void;
+				if (node.arguments[0]?.type !== "ArrayExpression") return Effect.void;
+				const options = node.arguments[1];
+				if (propertyLiteral(options, "concurrency") !== 1) return Effect.void;
+				if (!(propertyLiteral(options, "discard") === true || pipedToAsVoid(node, namespaces))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Use Effect.andThen or one flat generator for sequential steps. Reserve Effect.all for value aggregation or real concurrency."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noSequentialEffectAll };

package/dist/rules/no-silent-catch-all.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-silent-catch-all.d.ts
+declare const noSilentCatchAll: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noSilentCatchAll };

package/dist/rules/no-silent-catch-all.js

@@ -0,0 +1,51 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-silent-catch-all.ts
+const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const isEffectVoid = (node, effectNamespaces) => isStaticMember(node, effectNamespaces, "void");
+const silentlyReturnsVoid = (node, effectNamespaces) => {
+	if (node.params.length !== 0 || node.body === null) return false;
+	if (node.body.type !== "BlockStatement") return isEffectVoid(node.body, effectNamespaces);
+	if (node.body.body.length !== 1) return false;
+	const statement = node.body.body[0];
+	return statement?.type === "ReturnStatement" && statement.argument !== null && isEffectVoid(statement.argument, effectNamespaces);
+};
+const handlerArgument = (node) => {
+	if (node.arguments.length === 1) return node.arguments[0];
+	return node.arguments[1];
+};
+const noSilentCatchAll = define({
+	name: "no-silent-catch-all",
+	meta: meta({
+		type: "problem",
+		description: "Do not silently erase every failure with Effect.void."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!(isStaticMember(node.callee, namespaces, "catchAll") || isStaticMember(node.callee, namespaces, "catchAllCause"))) return Effect.void;
+				const handler = handlerArgument(node);
+				if (!isFunction(handler) || !silentlyReturnsVoid(handler, namespaces)) return Effect.void;
+				return ctx.report(make({
+					node: handler,
+					message: "Do not erase every failure with Effect.void. Recover a typed failure truthfully or record the unexpected failure before recovery."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noSilentCatchAll };

package/dist/rules/no-unbounded-concurrency.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unbounded-concurrency.d.ts
+declare const noUnboundedConcurrency: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnboundedConcurrency };

package/dist/rules/no-unbounded-concurrency.js

@@ -0,0 +1,50 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-unbounded-concurrency.ts
+const unboundedConcurrency = (node) => {
+	if (node?.type !== "ObjectExpression") return void 0;
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if (!(property.key.type === "Identifier" && property.key.name === "concurrency" || property.key.type === "Literal" && property.key.value === "concurrency")) continue;
+		if (property.value.type === "Literal" && property.value.value === "unbounded") return property.value;
+	}
+};
+const fixedCollection = (node) => node?.type === "ArrayExpression" || node?.type === "ObjectExpression";
+const noUnboundedConcurrency = define({
+	name: "no-unbounded-concurrency",
+	meta: meta({
+		type: "problem",
+		description: "Require finite concurrency for Effect operations over collections that can grow."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				let optionsIndex;
+				if (isStaticMember(node.callee, namespaces, "all")) optionsIndex = 1;
+				if (isStaticMember(node.callee, namespaces, "forEach")) optionsIndex = 2;
+				if (optionsIndex === void 0 || fixedCollection(node.arguments[0])) return Effect.void;
+				const unbounded = unboundedConcurrency(node.arguments[optionsIndex]);
+				if (unbounded === void 0) return Effect.void;
+				return ctx.report(make({
+					node: unbounded,
+					message: "Bound concurrency for a collection that can grow. Use a finite concurrency value."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noUnboundedConcurrency };

package/dist/rules/no-unbounded-retry.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unbounded-retry.d.ts
+declare const noUnboundedRetry: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnboundedRetry };

package/dist/rules/no-unbounded-retry.js

@@ -0,0 +1,114 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-unbounded-retry.ts
+const unboundedConstructors = new Set([
+	"exponential",
+	"fibonacci",
+	"spaced"
+]);
+const boundedCombinators = new Set(["take"]);
+const staticPropertyName = (node) => {
+	if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier") return;
+	return node.property.name;
+};
+const hasOwnProperty = (node, name) => {
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if (property.key.type === "Identifier" && property.key.name === name) return true;
+		if (property.key.type === "Literal" && property.key.value === name) return true;
+	}
+	return false;
+};
+const propertyValue = (node, name) => {
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		if (property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) return property.value;
+	}
+};
+const isBoundedOperation = (node, scheduleNamespaces) => {
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return false;
+	const property = staticPropertyName(node.callee);
+	if (property === void 0) return false;
+	if (boundedCombinators.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return true;
+	if (!isStaticMember(node.callee, scheduleNamespaces, "both")) return false;
+	const bound = node.arguments[0];
+	return bound !== void 0 && bound.type !== "SpreadElement" && isStaticCall(bound, scheduleNamespaces, "recurs");
+};
+const unboundedSchedule = (node, scheduleNamespaces) => {
+	if (node.type === "MemberExpression" && isStaticMember(node, scheduleNamespaces, "forever")) return node;
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
+	const property = staticPropertyName(node.callee);
+	if (property !== void 0 && unboundedConstructors.has(property) && isStaticMember(node.callee, scheduleNamespaces, property)) return node;
+	if (property !== "pipe" || node.callee.type !== "MemberExpression") return void 0;
+	const root = unboundedSchedule(node.callee.object, scheduleNamespaces);
+	if (root === void 0) return void 0;
+	for (const operation of node.arguments) if (isBoundedOperation(operation, scheduleNamespaces)) return void 0;
+	return root;
+};
+const retryPolicy = (node, effectNamespaces, streamNamespaces, httpClientNamespaces) => {
+	if (node.callee.type === "Super") return void 0;
+	let policyIndex;
+	if (isStaticMember(node.callee, effectNamespaces, "retry")) {
+		if (node.arguments.length === 1) policyIndex = 0;
+		if (node.arguments.length >= 2) policyIndex = 1;
+	}
+	if (isStaticMember(node.callee, effectNamespaces, "retryOrElse")) {
+		if (node.arguments.length === 2) policyIndex = 0;
+		if (node.arguments.length >= 3) policyIndex = 1;
+	}
+	if (isStaticMember(node.callee, streamNamespaces, "retry")) {
+		if (node.arguments.length === 1) policyIndex = 0;
+		if (node.arguments.length >= 2) policyIndex = 1;
+	}
+	if (isStaticMember(node.callee, httpClientNamespaces, "retryTransient")) {
+		if (node.arguments.length === 1) policyIndex = 0;
+		if (node.arguments.length >= 2) policyIndex = 1;
+	}
+	if (policyIndex === void 0) return void 0;
+	const policy = node.arguments[policyIndex];
+	if (policy?.type === "SpreadElement") return void 0;
+	if (policy?.type !== "ObjectExpression") return policy;
+	if (hasOwnProperty(policy, "times")) return void 0;
+	return propertyValue(policy, "schedule");
+};
+const noUnboundedRetry = define({
+	name: "no-unbounded-retry",
+	meta: meta({
+		type: "problem",
+		description: "Require retry policies to have an explicit attempt or duration bound."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		const httpClientNamespaces = new Set(["HttpClient"]);
+		const scheduleNamespaces = new Set(["Schedule"]);
+		const streamNamespaces = new Set(["Stream"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "HttpClient", "effect/unstable/http/HttpClient")) httpClientNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Schedule", "effect/Schedule")) scheduleNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Stream", "effect/Stream")) streamNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression") return Effect.void;
+				const policy = retryPolicy(node, visibleNamespaces(ctx, node, effectNamespaces), visibleNamespaces(ctx, node, streamNamespaces), visibleNamespaces(ctx, node, httpClientNamespaces));
+				if (policy === void 0) return Effect.void;
+				const unbounded = unboundedSchedule(policy, visibleNamespaces(ctx, node, scheduleNamespaces));
+				if (unbounded === void 0) return Effect.void;
+				return ctx.report(make({
+					node: unbounded,
+					message: "Bound retry attempts or elapsed time. Add times or compose the schedule with Schedule.recurs or Schedule.take."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noUnboundedRetry };

package/dist/rules/prefer-catch-tag.js

@@ -2,7 +2,7 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
-import { isEffectCall, tagComparisonsInOr } from "./_tagged-control-flow.js";
+import { isEffectCall, tagComparisonsInOr, taggedSwitchSubject } from "./_tagged-control-flow.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-catch-tag.ts
 const returnedExpression = (fn) => {
@@ -23,6 +23,32 @@ const hasManualTagPredicate = (argument) => {
 	if (comparisons === null || comparisons.length === 0) return false;
 	return comparisons.every((comparison) => comparison.subject === parameter.name);
 };
+const isFunction = (argument) => argument?.type === "ArrowFunctionExpression" || argument?.type === "FunctionExpression";
+const hasTagCondition = (node, parameter) => {
+	const comparisons = tagComparisonsInOr(node.test);
+	if (comparisons === null || comparisons.length === 0) return false;
+	return comparisons.every((comparison) => comparison.subject === parameter);
+};
+const hasTagSwitch = (node, parameter) => {
+	if (taggedSwitchSubject(node) !== parameter) return false;
+	return node.cases.some((switchCase) => switchCase.test?.type === "Literal" && typeof switchCase.test.value === "string");
+};
+const hasManualTagDispatch = (argument) => {
+	if (!isFunction(argument) || argument.body?.type !== "BlockStatement") return false;
+	const parameter = argument.params[0];
+	if (parameter?.type !== "Identifier") return false;
+	return argument.body.body.some((statement) => {
+		if (statement.type === "IfStatement") return hasTagCondition(statement, parameter.name);
+		if (statement.type === "SwitchStatement") return hasTagSwitch(statement, parameter.name);
+		return false;
+	});
+};
+const catchAllHandler = (node) => {
+	if (!isEffectCall(node, "catchAll")) return void 0;
+	let handlerIndex = 1;
+	if (node.arguments.length === 1) handlerIndex = 0;
+	return node.arguments[handlerIndex];
+};
 const preferCatchTag = define({
 	name: "prefer-catch-tag",
 	meta: meta({
@@ -32,11 +58,12 @@ const preferCatchTag = define({
 	create: function* () {
 		const context = yield* RuleContext;
 		return { CallExpression: (node) => {
-			if (!isEffectCall(node, "catchIf")) return Effect.void;
-			let predicateIndex = 1;
-			if (node.arguments.length === 2) predicateIndex = 0;
-			const predicate = node.arguments[predicateIndex];
-			if (!hasManualTagPredicate(predicate)) return Effect.void;
+			if (isEffectCall(node, "catchIf")) {
+				let predicateIndex = 1;
+				if (node.arguments.length === 2) predicateIndex = 0;
+				const predicate = node.arguments[predicateIndex];
+				if (!hasManualTagPredicate(predicate)) return Effect.void;
+			} else if (!hasManualTagDispatch(catchAllHandler(node))) return Effect.void;
 			return context.report(make({
 				node,
 				message: "Use Effect.catchTag for one tagged failure or Effect.catchTags for multiple tagged failures."

package/dist/rules/prefer-match-tags-exhaustive.js

@@ -2,7 +2,7 @@ import { make } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
-import { isInsideCatchAllHandler, taggedSwitchSubject } from "./_tagged-control-flow.js";
+import { isInsideCatchAllHandler, tagComparison, taggedSwitchSubject } from "./_tagged-control-flow.js";
 import * as Effect from "effect/Effect";
 //#region src/rules/prefer-match-tags-exhaustive.ts
 const statementReturns = (statement) => {
@@ -25,6 +25,51 @@ const isCompleteTransformationShape = (node) => {
 	}
 	return true;
 };
+const isElseIf = (node) => node.parent?.type === "IfStatement" && node.parent.alternate === node;
+const isTerminalStatement = (node) => {
+	if (node.parent?.type !== "BlockStatement") return true;
+	return node.parent.body.at(-1) === node;
+};
+const isCompleteIfTransformationShape = (node) => {
+	if (isElseIf(node) || !isTerminalStatement(node)) return false;
+	let current = node;
+	let subject;
+	const tags = /* @__PURE__ */ new Set();
+	let branchCount = 0;
+	while (true) {
+		const comparison = tagComparison(current.test);
+		if (comparison === null || !statementReturns(current.consequent)) return false;
+		if (subject !== void 0 && comparison.subject !== subject) return false;
+		if (tags.has(comparison.tag)) return false;
+		subject = comparison.subject;
+		tags.add(comparison.tag);
+		branchCount += 1;
+		if (current.alternate === null) break;
+		if (current.alternate.type !== "IfStatement") return false;
+		current = current.alternate;
+	}
+	return branchCount >= 2;
+};
+const isCompleteSequentialIfTransformationShape = (node) => {
+	if (node.alternate !== null || node.parent?.type !== "BlockStatement") return false;
+	const statements = node.parent.body;
+	const index = statements.indexOf(node);
+	if (index < 0) return false;
+	const comparison = tagComparison(node.test);
+	if (comparison === null || !statementReturns(node.consequent)) return false;
+	const previous = statements[index - 1];
+	if (previous?.type === "IfStatement" && previous.alternate === null) {
+		if (tagComparison(previous.test)?.subject === comparison.subject && statementReturns(previous.consequent)) return false;
+	}
+	const tags = new Set([comparison.tag]);
+	for (const statement of statements.slice(index + 1)) {
+		if (statement.type !== "IfStatement" || statement.alternate !== null) return false;
+		const next = tagComparison(statement.test);
+		if (next === null || next.subject !== comparison.subject || tags.has(next.tag) || !statementReturns(statement.consequent)) return false;
+		tags.add(next.tag);
+	}
+	return tags.size >= 2;
+};
 const preferMatchTagsExhaustive = define({
 	name: "prefer-match-tags-exhaustive",
 	meta: meta({
@@ -33,13 +78,22 @@ const preferMatchTagsExhaustive = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { SwitchStatement: (node) => {
-			if (!isCompleteTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
-			return context.report(make({
-				node,
-				message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new case."
-			}));
-		} };
+		return {
+			SwitchStatement: (node) => {
+				if (!isCompleteTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				return context.report(make({
+					node,
+					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new case."
+				}));
+			},
+			IfStatement: (node) => {
+				if (!isCompleteIfTransformationShape(node) && !isCompleteSequentialIfTransformationShape(node) || isInsideCatchAllHandler(node)) return Effect.void;
+				return context.report(make({
+					node,
+					message: "Use Match.type with Match.tagsExhaustive so a new tagged variant requires a new branch."
+				}));
+			}
+		};
 	}
 });
 //#endregion

package/dist/rules/prefer-service-of.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/prefer-service-of.d.ts
+declare const preferServiceOf: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { preferServiceOf };

package/dist/rules/prefer-service-of.js

@@ -0,0 +1,65 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/prefer-service-of.ts
+const returnedObject = (node) => {
+	if (node?.type !== "ArrowFunctionExpression" && node?.type !== "FunctionExpression") return;
+	if (node.body === null) return void 0;
+	if (node.body.type === "ObjectExpression") return node.body;
+	if (node.body.type !== "BlockStatement") return void 0;
+	for (const statement of node.body.body) if (statement.type === "ReturnStatement" && statement.argument?.type === "ObjectExpression") return statement.argument;
+};
+const implementationObject = (node, layerNamespaces, effectNamespaces) => {
+	if (node.callee.type === "Super" || node.arguments.length < 2) return void 0;
+	const implementation = node.arguments[1];
+	if (implementation === void 0 || implementation.type === "SpreadElement") return void 0;
+	if (isStaticMember(node.callee, layerNamespaces, "succeed")) {
+		if (implementation.type === "ObjectExpression") return implementation;
+		return;
+	}
+	if (isStaticMember(node.callee, layerNamespaces, "sync")) return returnedObject(implementation);
+	if (!isStaticMember(node.callee, layerNamespaces, "effect")) return void 0;
+	if (implementation.type !== "CallExpression" || implementation.callee.type === "Super") return;
+	if (isStaticMember(implementation.callee, effectNamespaces, "succeed")) {
+		const value = implementation.arguments[0];
+		if (value?.type === "ObjectExpression") return value;
+		return;
+	}
+	if (isStaticCall(implementation, effectNamespaces, "gen")) return returnedObject(implementation.arguments[0]);
+};
+const preferServiceOf = define({
+	name: "prefer-service-of",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Service.of to check inline Layer implementations against the service interface."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const layerNamespaces = new Set(["Layer"]);
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Layer", "effect/Layer")) layerNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression") return Effect.void;
+				const service = node.arguments[0];
+				if (service?.type !== "Identifier") return Effect.void;
+				const implementation = implementationObject(node, visibleNamespaces(ctx, node, layerNamespaces), visibleNamespaces(ctx, node, effectNamespaces));
+				if (implementation === void 0) return Effect.void;
+				return ctx.report(make({
+					node: implementation,
+					message: `Wrap this implementation with ${service.name}.of(...) so it stays checked against the service interface.`
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { preferServiceOf };

package/dist/rules/require-named-effect-fn.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/require-named-effect-fn.d.ts
+declare const requireNamedEffectFn: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { requireNamedEffectFn };

package/dist/rules/require-named-effect-fn.js

@@ -0,0 +1,37 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/require-named-effect-fn.ts
+const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const requireNamedEffectFn = define({
+	name: "require-named-effect-fn",
+	meta: meta({
+		type: "suggestion",
+		description: "Require a stable operation name for Effect.fn."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticMember(node.callee, namespaces, "fn") || !isFunction(node.arguments[0])) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Name this operation with Effect.fn(\"Domain.operation\") for stable tracing and diagnostics."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { requireNamedEffectFn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
   "repository": {