oxlint-plugin-effect 0.10.0 → 0.12.0

package/dist/rules/index.js

@@ -1,25 +1,36 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { noEffectBind } from "./no-effect-bind.js";
 import { noEffectDo } from "./no-effect-do.js";
+import { maxCognitiveComplexity } from "./max-cognitive-complexity.js";
+import { maxHalsteadDifficulty } from "./max-halstead-difficulty.js";
 import { noAs } from "./no-as.js";
 import { noAsyncFunction } from "./no-async-function.js";
 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,8 +39,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.ts
 var rules_exports = /* @__PURE__ */ __exportAll({
+	maxCognitiveComplexity: () => maxCognitiveComplexity,
+	maxHalsteadDifficulty: () => maxHalsteadDifficulty,
 	noAs: () => noAs,
 	noAsyncFunction: () => noAsyncFunction,
 	noChainedTypeAssertions: () => noChainedTypeAssertions,
@@ -38,19 +53,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 +82,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/max-cognitive-complexity.d.ts

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

package/dist/rules/max-cognitive-complexity.js

@@ -0,0 +1,43 @@
+import { fromId } 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 { cognitiveComplexity, isFunctionNode } from "./_function-metrics.js";
+import { MaxOptions, maxOptionsMeta, resolveMax } from "./_max-option.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/max-cognitive-complexity.ts
+const DEFAULT_MAX = 21;
+const maxCognitiveComplexity = define({
+	name: "max-cognitive-complexity",
+	meta: meta({
+		type: "suggestion",
+		description: "Keep every function below the cognitive complexity limit.",
+		messages: { tooComplex: "Function has a cognitive complexity of {{value}}. Maximum allowed is {{max}}. Split it into named operations." },
+		...maxOptionsMeta(DEFAULT_MAX)
+	}),
+	options: MaxOptions,
+	create: function* (options) {
+		const context = yield* RuleContext;
+		const max = resolveMax(options, DEFAULT_MAX);
+		const check = (node) => {
+			if (!isFunctionNode(node)) return Effect.void;
+			const value = cognitiveComplexity(node);
+			if (value <= max) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "tooComplex",
+				data: {
+					value: String(value),
+					max: String(max)
+				}
+			}));
+		};
+		return {
+			ArrowFunctionExpression: check,
+			FunctionDeclaration: check,
+			FunctionExpression: check
+		};
+	}
+});
+//#endregion
+export { maxCognitiveComplexity };

package/dist/rules/max-halstead-difficulty.d.ts

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

package/dist/rules/max-halstead-difficulty.js

@@ -0,0 +1,44 @@
+import { fromId } 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 { halstead, halsteadDifficulty, isFunctionNode } from "./_function-metrics.js";
+import { MaxOptions, maxOptionsMeta, resolveMax } from "./_max-option.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/max-halstead-difficulty.ts
+const DEFAULT_MAX = 79;
+const formatDifficulty = (value) => String(Math.round(value * 10) / 10);
+const maxHalsteadDifficulty = define({
+	name: "max-halstead-difficulty",
+	meta: meta({
+		type: "suggestion",
+		description: "Keep every function below the Halstead difficulty limit.",
+		messages: { tooDifficult: "Function has a Halstead difficulty of {{value}}. Maximum allowed is {{max}}. Extract repeated expressions into named values." },
+		...maxOptionsMeta(DEFAULT_MAX)
+	}),
+	options: MaxOptions,
+	create: function* (options) {
+		const context = yield* RuleContext;
+		const max = resolveMax(options, DEFAULT_MAX);
+		const check = (node) => {
+			if (!isFunctionNode(node)) return Effect.void;
+			const value = halsteadDifficulty(halstead(node));
+			if (value <= max) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "tooDifficult",
+				data: {
+					value: formatDifficulty(value),
+					max: String(max)
+				}
+			}));
+		};
+		return {
+			ArrowFunctionExpression: check,
+			FunctionDeclaration: check,
+			FunctionExpression: check
+		};
+	}
+});
+//#endregion
+export { maxHalsteadDifficulty };

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 };