@kamaal111/oxlint-plugin-anti-slop 0.0.2 → 0.0.4

package/README.md

@@ -4,7 +4,69 @@
 
 Opinionated Oxlint rules that reject low-evidence and low-signal TypeScript and JavaScript patterns.
 
-This project is meant to be vendored, not treated as a fixed npm dependency. Copy the rules into your repository, read them, and change them to match your team's standards. The bundled agent skill handles the initial copy and configuration; after that, the vendored files are yours to maintain and make your own.
+> **Fork and attribution:** This is an independently maintained fork by [Kamaal](https://github.com/kamaal111) of [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop). Credit for the original project remains with [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop).
+
+The upstream project is designed to be vendored. This fork is published as `@kamaal111/oxlint-plugin-anti-slop` for teams that prefer to track upstream releases as an npm dependency; its compatibility and release lifecycle belong to this fork's maintainer.
+
+## Install as an npm dependency
+
+```bash
+npm install --save-dev @kamaal111/oxlint-plugin-anti-slop
+```
+
+Register it in `oxlint.config.ts`:
+
+```ts
+import { defineConfig } from "oxlint";
+
+export default defineConfig({
+  jsPlugins: [
+    { name: "anti-slop", specifier: "@kamaal111/oxlint-plugin-anti-slop" },
+  ],
+  rules: {
+    "oxc/no-accumulating-spread": "error",
+    "anti-slop/no-array-filter-map": "error",
+    "anti-slop/no-reduce-accumulator-copy": "error",
+    "anti-slop/no-chained-type-assertions": "error",
+    "anti-slop/no-conditional-empty-object-spread": "error",
+    "anti-slop/no-known-value-widening": "error",
+    "anti-slop/no-module-mocking": "error",
+    "anti-slop/no-object-parameters": "error",
+    "anti-slop/no-reflect-apply": "error",
+    "anti-slop/no-reflect-get": "error",
+    "anti-slop/no-runtime-typeof": "error",
+    "anti-slop/no-shape-in-symbol-names": "error",
+    "anti-slop/no-unknown-parameters": "error",
+    "anti-slop/no-unknown-returns": "error",
+    "anti-slop/no-unknown-type-aliases": "error",
+    "anti-slop/no-unsafe-dictionary-type": "error",
+    "anti-slop/no-widen-then-assert": "error",
+    "anti-slop/require-readable-spacing": "error",
+    "anti-slop/require-safety-comment-for-type-assertion": "error"
+  }
+});
+```
+
+The optional Effect rules live at the `@kamaal111/oxlint-plugin-anti-slop/effect` subpath:
+
+```ts
+export default defineConfig({
+  jsPlugins: [
+    { name: "anti-slop", specifier: "@kamaal111/oxlint-plugin-anti-slop" },
+    { name: "anti-slop-effect", specifier: "@kamaal111/oxlint-plugin-anti-slop/effect" }
+  ],
+  rules: {
+    "anti-slop-effect/no-manual-effect-error-tag": "error",
+    "anti-slop-effect/no-manual-tag-comparison": "error",
+    "anti-slop-effect/no-manual-tagged-construction": "error",
+    "anti-slop-effect/no-service-constructor-imports": "error",
+    "anti-slop-effect/prefer-effect-match": "error"
+  }
+});
+```
+Anti-slop is first and foremost the ruleset I use with my work, projects, and team. It reflects my preferences and taste rather than attempting to be a universal coding standard.
+
+**This project is meant to be vendored**, not treated as a fixed npm dependency. There is no official npm package. Copy the rules into your repository, read them, and change them to match your team's standards. The bundled agent skill handles the initial copy and configuration; after that, the vendored files are yours to maintain and make your own. Community-maintained forks and packages are welcome, but their compatibility and release lifecycle belong to their maintainers.
 
 ## Install with an agent skill
 
@@ -12,7 +74,13 @@ This project is meant to be vendored, not treated as a fixed npm dependency. Cop
 npx skills add dmmulroy/anti-slop --skill install-anti-slop
 ```
 
-Then ask your coding agent to install or configure anti-slop in the current repository. The skill copies the plugin, installs current Oxlint dependencies, merges the plugin into the existing lint configuration, enables every generic rule, and validates the result. In repositories that depend on Effect, it also enables the opt-in Effect rule group.
+Then ask your coding agent to install or configure anti-slop in the current repository. The skill copies the plugin, installs compatible Oxlint dependencies—matching an existing Oxlint version when present—merges the plugin into the existing lint configuration, enables every generic rule, and validates the result. In repositories that depend directly on Effect, it also enables the opt-in Effect rule group.
+
+### Update an existing installation
+
+Ask your agent to **update anti-slop while preserving local customizations**, optionally naming an upstream revision or selected fixes. The same skill stages incoming source separately, uses a three-way merge when the original upstream snapshot is recoverable, and otherwise ports reviewed changes conservatively. It preserves local rules and configuration, asks about conflicting policy and enabling new rules, and records provenance for future updates. It does not force-replace the vendored directory.
+
+For latest upstream, ask the agent to retrieve and identify that revision; an already-installed skill bundle may be older. The copy script itself does not fetch or merge updates.
 
 To inspect available skills first:
 
@@ -22,7 +90,7 @@ npx skills add dmmulroy/anti-slop --list
 
 ## Manual local installation
 
-Copy `src/` into the target repository, for example at `tools/oxlint/anti-slop/`, and install matching current versions of `oxlint` and `@oxlint/plugins`.
+Copy `src/` into the target repository, for example at `tools/oxlint/anti-slop/`. If the repository already uses `oxlint`, install `@oxlint/plugins` at exactly the resolved Oxlint version. Otherwise, install the same current version of both packages. Keep both versions exact so upgrades move them together.
 
 Register the copied entry point in `oxlint.config.ts`:
 
@@ -48,6 +116,9 @@ export default defineConfig({
     { name: "anti-slop", specifier: "./tools/oxlint/anti-slop/index.ts" },
   ],
   rules: {
+    "oxc/no-accumulating-spread": "error",
+    "anti-slop/no-array-filter-map": "error",
+    "anti-slop/no-reduce-accumulator-copy": "error",
     "anti-slop/no-chained-type-assertions": "error",
     "anti-slop/no-conditional-empty-object-spread": "error",
     "anti-slop/no-known-value-widening": "error",
@@ -62,6 +133,7 @@ export default defineConfig({
     "anti-slop/no-unknown-type-aliases": "error",
     "anti-slop/no-unsafe-dictionary-type": "error",
     "anti-slop/no-widen-then-assert": "error",
+    "anti-slop/require-readable-spacing": "error",
     "anti-slop/require-safety-comment-for-type-assertion": "error"
   }
 });
@@ -83,7 +155,11 @@ export default defineConfig({
     }
   ],
   rules: {
-    "anti-slop-effect/no-service-constructor-imports": "error"
+    "anti-slop-effect/no-manual-effect-error-tag": "error",
+    "anti-slop-effect/no-manual-tag-comparison": "error",
+    "anti-slop-effect/no-manual-tagged-construction": "error",
+    "anti-slop-effect/no-service-constructor-imports": "error",
+    "anti-slop-effect/prefer-effect-match": "error"
   }
 });
 ```
@@ -92,30 +168,89 @@ export default defineConfig({
 
 ### Generic rules
 
-- `no-chained-type-assertions` — rejects nested type assertions that fabricate evidence.
-- `no-conditional-empty-object-spread` — rejects conditional spreads that use `{}` to omit fields.
-- `no-known-value-widening` — rejects explicit broad target types that discard known value evidence.
-- `no-module-mocking` — rejects Vitest and Jest module mocks in favor of real dependency seams.
-- `no-object-parameters` — rejects the broad `object` type on function inputs.
-- `no-reflect-apply` — rejects `Reflect.apply` in favor of typed function calls.
-- `no-reflect-get` — rejects `Reflect.get` in favor of typed property access or boundary parsing.
-- `no-runtime-typeof` — requires boundary parsing instead of ad hoc `typeof` narrowing.
-- `no-shape-in-symbol-names` — rejects `shape` in symbol names.
-- `no-unknown-parameters` — rejects `unknown` inputs except the explicit `cause` convention.
-- `no-unknown-returns` — rejects function contracts that return `unknown` or `Promise<unknown>`.
-- `no-unknown-type-aliases` — rejects aliases that merely conceal `unknown`.
-- `no-unsafe-dictionary-type` — rejects dictionary value contracts based on `unknown`, `any`, `object`, `{}`, and semantic equivalents.
-- `no-widen-then-assert` — rejects local flows that widen known values and later assert them back.
-- `require-safety-comment-for-type-assertion` — requires each non-const assertion to document its checked invariant.
+- `no-array-filter-map` — rejects adjacent eager array filter/map passes while allowing lazy iterator pipelines.
+- `no-reduce-accumulator-copy` — rejects non-spread accumulator copies inside reducers; complements native `oxc/no-accumulating-spread`.
+- `no-chained-type-assertions` — rejects nested `as` and angle-bracket assertions that fabricate evidence; chains made only of `as const` remain valid.
+- `no-conditional-empty-object-spread` — reports object spreads that use a conditional `{}` branch to omit fields. It intentionally has no autofix because omission is not equivalent to assigning `undefined`.
+- `no-known-value-widening` — rejects known expressions flowing into explicit `unknown`, `object`, anonymous-object, or open-dictionary targets, including known arguments passed to local `unknown` type predicates. Empty dictionary accumulators and finite-key `Record` targets remain valid.
+- `no-module-mocking` — rejects Vitest and Jest `mock`, `doMock`, and `unstable_mockModule` calls in favor of real dependency seams.
+- `no-object-parameters` — rejects `object`, unions containing it, and scoped or transparent generic aliases that resolve to it on function inputs.
+- `no-reflect-apply` — rejects global `Reflect.apply` in favor of typed function calls.
+- `no-reflect-get` — rejects global `Reflect.get` in favor of typed property access or boundary parsing.
+- `no-runtime-typeof` — requires boundary parsing instead of ad hoc `typeof` narrowing. Existence probes against the string `"undefined"` are allowed, and type predicates can be enabled explicitly.
+- `no-shape-in-symbol-names` — rejects the case-insensitive substring `shape` in locally owned symbol names while allowing static member names such as Zod's `schema.shape` that cannot be renamed locally.
+- `no-unknown-parameters` — rejects `unknown` and unions containing it on function inputs except the explicit `cause` convention and the exact subject of a type predicate.
+- `no-unknown-returns` — rejects explicit function contracts that resolve to `unknown`, `Promise<unknown>`, or `PromiseLike<unknown>`, including scoped and transparent generic aliases.
+- `no-unknown-type-aliases` — rejects scoped and transparent generic aliases whose resolved type is `unknown`.
+- `no-unsafe-dictionary-type` — rejects dictionary value contracts based on `unknown`, `any`, `object`, `{}`, and semantic equivalents. Generic constraints such as `T extends Record<string, unknown>` are allowed.
+- `no-widen-then-assert` — rejects immutable local flows that widen known evidence to `unknown`, `any`, `object`, or a broad record and later assert it back to a narrower type.
+- `require-readable-spacing` — autofixes missing blank lines between top-level declarations, around multiline bindings, before control flow/returns, and after blocks; preserves compact local bindings, imports, and overload groups.
+- `require-safety-comment-for-type-assertion` — requires each non-const assertion to have a nearby, non-empty invariant justification. Marker prefixes are configurable and default to `SAFETY`.
 
 ### Effect rules
 
-- `no-service-constructor-imports` — rejects relative project imports of exported `make<CapabilityName>` constructors outside `*.test.*` and `*.spec.*` files. Runtime callers should import the owning Layer and yield the contextual service instead. Package imports and static constructors such as `WorkspaceName.make` are outside the rule.
+- `no-manual-effect-error-tag` — rejects manual `_tag` comparisons and switches inside broad `Effect.catch`, `Effect.catchAll`, and `Effect.catchIf` handlers in favor of tagged error handlers.
+- `no-manual-tag-comparison` — rejects direct `_tag` comparisons and `_tag` switches in favor of `Match`, `Predicate.isTagged`, or tagged-enum matching.
+- `no-manual-tagged-construction` — rejects literal `_tag` object construction in favor of Schema, tagged class/error, or `Data.taggedEnum` constructors. `Match.when` and `Match.not` patterns remain allowed.
+- `no-service-constructor-imports` — rejects named `make<CapabilityName>` imports from relative project modules outside `*.test.*` and `*.spec.*` files. Runtime callers should import the owning Layer and yield the contextual service instead. Package and path-alias imports, default imports, and static constructors such as `WorkspaceName.make` are outside the rule.
+- `prefer-effect-match` — rejects chained literal ternaries over the same value in favor of Effect's `Match` API.
+
+### Analysis boundaries
+
+The rules use Oxlint's ESTree and lexical-scope APIs rather than a TypeScript type checker. They resolve same-file aliases—including block-scoped aliases, forward references, and transparent generic aliases—but do not infer imported type definitions or cross-file call signatures. Rules that inspect calls therefore document when enforcement is intentionally local.
 
 ## Violation examples
 
 Each snippet below is rejected by the named rule.
 
+### `no-array-filter-map`
+
+```ts
+const users: User[] = loadUsers();
+const emails = users.filter(user => user.active).map(user => user.email);
+const found = users.map(lookup).filter(value => value !== undefined);
+```
+
+Prefer lazy iterator helpers where the target runtime supports them:
+
+```ts
+const emails = users.values()
+  .filter(user => user.active)
+  .map(user => user.email)
+  .toArray();
+```
+
+A single `flatMap(user => user.active ? [user.email] : [])` or a reducer that pushes into a fresh local array is also allowed. Iterator helpers avoid intermediate arrays and per-item wrapper arrays, but are not guaranteed to be faster. Check runtime support; TypeScript library declarations do not polyfill them.
+
+This AST/scope rule recognizes array literals, direct array/tuple annotations, immutable local aliases, and supported array-preserving method chains. Unknown receivers (including imported factory results and unannotated parameters), type aliases, and property-based array types are not inferred. Iterator pipelines are not flagged. Both `filter().map()` and `map().filter()` are covered, regardless of predicate. There is no autofix: callback ordering, indexes, `thisArg`, sparse arrays, and truthiness filtering must be reviewed before changing APIs.
+
+### `no-reduce-accumulator-copy`
+
+```ts
+items.reduce((acc, item) => Object.assign({}, acc, { [item.id]: item }), {});
+items.reduce((acc, item) => acc.concat([item]), []);
+items.reduce((acc, item) => {
+  const next = acc.slice();
+  next.push(item);
+  return next;
+}, []);
+```
+
+Instead, mutate a fresh, locally owned accumulator and return it:
+
+```ts
+items.reduce((acc, item) => {
+  acc.push(item);
+  return acc;
+}, []);
+```
+
+`Object.assign(acc, item)` is also allowed. Copying individual input items is not copying accumulated state.
+
+The rule covers inline `reduce`/`reduceRight` callbacks, including index parameters, and immutable local accumulator aliases. It detects global `Object.assign` with an object-literal target and the accumulator as a source, global `Array.from(acc)`, and array accumulator calls to `concat`, `slice`, `toSpliced`, `toSorted`, `toReversed`, and `with`. Array copy methods require local array evidence for the initial value so string concatenation and unknown custom collections are not flagged. Like the native rule, reducer method names are syntactic evidence, not proof of the receiver's runtime type. Named callbacks, nested functions, indirect copy helpers, nested accumulator properties, and reassigned aliases are outside its scope. Copying a bounded accumulator is not necessarily quadratic, but these patterns are rejected because growing accumulators can be.
+
+Enable native `oxc/no-accumulating-spread` alongside it for array/object spreads in reducers and supported loops. Neither rule proves that every possible quadratic reduction is absent. No automatic mutation rewrite is provided because accumulator ownership cannot be established syntactically.
+
 ### `no-chained-type-assertions`
 
 ```ts
@@ -140,6 +275,19 @@ const handlers: Record<string, Handler> = {
 
 This discards the known `start` key. Preserve inference or use `satisfies Record<string, Handler>` instead.
 
+Known values must not be widened back to `unknown` through a local type predicate:
+
+```ts
+function isUser(value: unknown): value is User {
+  return UserSchema.safeParse(value).success;
+}
+
+declare const user: User;
+isUser(user);
+```
+
+Call the predicate at the unparsed boundary, while the argument is still `unknown`.
+
 ### `no-module-mocking`
 
 ```ts
@@ -184,7 +332,7 @@ assertion functions while continuing to reject ad hoc checks elsewhere:
 }
 ```
 
-The option defaults to `false`.
+The option defaults to `false`. Existence probes such as `typeof document === "undefined"` are always allowed because they establish whether a binding exists rather than narrow its representation.
 
 ### `no-shape-in-symbol-names`
 
@@ -194,6 +342,8 @@ interface UserShape {
 }
 ```
 
+Static member reads such as `schema.shape` are allowed because the member name belongs to the value's owner and cannot be renamed locally.
+
 ### Effect: `no-service-constructor-imports`
 
 ```ts
@@ -202,12 +352,73 @@ import { makeIssueService } from "./issue-service.ts";
 
 Import the owning Layer and yield `IssueService` instead. Focused `*.test.*` and `*.spec.*` files may import the constructor directly.
 
+### Effect: tagged values and matching
+
+Direct tag checks are rejected by `no-manual-tag-comparison`:
+
+```ts
+if (result._tag === "Ready") useReady(result);
+```
+
+Use `Predicate.isTagged` for a predicate or `Match` for branching:
+
+```ts
+if (Predicate.isTagged("Ready")(result)) useReady(result);
+```
+
+Literal tag objects are rejected by `no-manual-tagged-construction`:
+
+```ts
+const result = { _tag: "Ready", value };
+```
+
+Use the existing Schema, tagged class/error, or `Data.taggedEnum` constructor instead, such as `Ready.make({ value })`. Object patterns passed directly to `Match.when` and `Match.not` remain allowed.
+
+Manual tag branching in broad catch handlers is rejected by `no-manual-effect-error-tag`:
+
+```ts
+program.pipe(
+  Effect.catch((error) =>
+    error._tag === "NotFound" ? recover : Effect.fail(error)
+  )
+);
+```
+
+Use the selective error operator:
+
+```ts
+program.pipe(Effect.catchTag("NotFound", () => recover));
+```
+
+For a tagged `error.reason`, use `Effect.catchReason` or `Effect.catchReasons`.
+
+Repeated literal ternaries over the same value are rejected by `prefer-effect-match`:
+
+```ts
+const label = kind === "a" ? "A" : kind === "b" ? "B" : "Other";
+```
+
+Use `Match`:
+
+```ts
+const label = Match.value(kind).pipe(
+  Match.when("a", () => "A"),
+  Match.when("b", () => "B"),
+  Match.orElse(() => "Other")
+);
+```
+
+These rules are syntactic. They recognize direct `Effect.catch*` and `Match.when`/`Match.not` calls under those exact identifiers and do not resolve import aliases or verify that similarly named objects came from Effect. `prefer-effect-match` compares the source text of the repeatedly tested expression; it does not infer its type or prove exhaustiveness.
+
 ### `no-unknown-parameters`
 
 ```ts
 function handle(input: unknown) {}
 ```
 
+A type predicate may accept `unknown` for the parameter it narrows; other `unknown`
+parameters on the same function remain rejected.
+
 ### `no-unknown-returns`
 
 ```ts
@@ -237,6 +448,20 @@ const stored: unknown = loaded;
 const user = stored as User;
 ```
 
+### `require-readable-spacing`
+
+```ts
+export const first = 1;
+/** Documentation stays attached to second. */
+export const second = 2;
+```
+
+Autofix inserts a blank line before the documentation. Inside functions, adjacent short variable declarations stay grouped, while multiline bindings and control-flow boundaries receive spacing. Adjacent function overload signatures and their implementation remain grouped. Existing blank lines are never removed. The rule takes no options; edit the vendored policy if your team's preferences differ.
+
+Run `oxlint --fix` (or `vp lint --fix`), then your formatter, then lint again. The rule inserts whitespace only; it does not add braces, wrap expressions, sort imports, or infer every logical group. Keep indentation and wrapping with the formatter rather than enabling a competing stylistic preset.
+
+The comment-aware engine is [vendored from ESLint Stylistic](src/vendor/eslint-stylistic/UPSTREAM.md) under MIT. Copy its `LICENSE` and provenance along with the code; no third-party plugin dependency is needed.
+
 ### `require-safety-comment-for-type-assertion`
 
 ```ts
@@ -250,6 +475,17 @@ Add a specific justification immediately before a necessary assertion:
 const userId = value as UserId;
 ```
 
+`SAFETY` remains the default marker. Comments immediately above exported declarations are recognized. Repositories with an established convention can configure one or more alternatives; every marker must still be followed by a colon and a non-empty justification:
+
+```json
+{
+  "anti-slop/require-safety-comment-for-type-assertion": [
+    "error",
+    { "markers": ["INVARIANT", "SAFETY"] }
+  ]
+}
+```
+
 ## Development
 
 ```bash
@@ -257,7 +493,7 @@ pnpm install
 pnpm check
 ```
 
-`src/` is canonical. After changing production source, run `pnpm sync:skill-assets`; CI checks that the skill's bundled copy remains identical.
+`src/` is canonical. After changing production source, run `pnpm sync:skill-assets`; CI checks that the skill's bundled copy remains identical. `pnpm check` runs Oxlint, every RuleTester suite, TypeScript typechecking, and the skill-asset drift check.
 
 ## License
 

package/dist/effect/index.d.ts

@@ -0,0 +1,4 @@
+/** Opt-in Oxlint rules for Effect service and Layer architecture. */
+declare const antiSlopEffectPlugin: import("@oxlint/plugins").Plugin;
+export default antiSlopEffectPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/effect/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/effect/index.ts"],"names":[],"mappings":"AAQA,qEAAqE;AACrE,QAAA,MAAM,oBAAoB,kCASxB,CAAC;eAEY,oBAAoB"}

package/dist/effect/index.js

@@ -0,0 +1,19 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { noManualEffectErrorTagRule } from "./rules/no-manual-effect-error-tag.js";
+import { noManualTagComparisonRule } from "./rules/no-manual-tag-comparison.js";
+import { noManualTaggedConstructionRule } from "./rules/no-manual-tagged-construction.js";
+import { noServiceConstructorImportsRule } from "./rules/no-service-constructor-imports.js";
+import { preferEffectMatchRule } from "./rules/prefer-effect-match.js";
+/** Opt-in Oxlint rules for Effect service and Layer architecture. */
+const antiSlopEffectPlugin = eslintCompatPlugin({
+    meta: { name: "anti-slop-effect" },
+    rules: {
+        "no-manual-effect-error-tag": noManualEffectErrorTagRule,
+        "no-manual-tag-comparison": noManualTagComparisonRule,
+        "no-manual-tagged-construction": noManualTaggedConstructionRule,
+        "no-service-constructor-imports": noServiceConstructorImportsRule,
+        "prefer-effect-match": preferEffectMatchRule,
+    },
+});
+export default antiSlopEffectPlugin;
+//# sourceMappingURL=index.js.map

package/dist/effect/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/effect/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,EAAE,8BAA8B,EAAE,MAAM,0CAA0C,CAAC;AAC1F,OAAO,EAAE,+BAA+B,EAAE,MAAM,2CAA2C,CAAC;AAC5F,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,qEAAqE;AACrE,MAAM,oBAAoB,GAAG,kBAAkB,CAAC;IAC/C,IAAI,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE;IAClC,KAAK,EAAE;QACN,4BAA4B,EAAE,0BAA0B;QACxD,0BAA0B,EAAE,yBAAyB;QACrD,+BAA+B,EAAE,8BAA8B;QAC/D,gCAAgC,EAAE,+BAA+B;QACjE,qBAAqB,EAAE,qBAAqB;KAC5C;CACD,CAAC,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/dist/effect/rules/no-manual-effect-error-tag.d.ts

@@ -0,0 +1,2 @@
+export declare const noManualEffectErrorTagRule: import("@oxlint/plugins").Rule;
+//# sourceMappingURL=no-manual-effect-error-tag.d.ts.map

package/dist/effect/rules/no-manual-effect-error-tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-manual-effect-error-tag.d.ts","sourceRoot":"","sources":["../../../src/effect/rules/no-manual-effect-error-tag.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,0BAA0B,gCA0CrC,CAAC"}

package/dist/effect/rules/no-manual-effect-error-tag.js

@@ -0,0 +1,40 @@
+import { defineRule } from "@oxlint/plugins";
+import { isInsideBroadEffectHandler, isReasonTagMember, isTagMember, tagMemberFromComparison, } from "../shared/tagged-values.js";
+export const noManualEffectErrorTagRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use Effect tagged error handlers instead of manually branching on `_tag` in a catch handler.",
+        },
+        messages: {
+            tag: "Use Effect.catchTag or Effect.catchTags instead of manually discriminating a tagged error in a broad Effect catch handler.",
+            reason: "Use Effect.catchReason or Effect.catchReasons instead of manually discriminating a tagged `reason` in a broad Effect catch handler.",
+        },
+    },
+    createOnce(context) {
+        return {
+            BinaryExpression(node) {
+                const tagMember = tagMemberFromComparison(node);
+                if (tagMember === undefined ||
+                    !isInsideBroadEffectHandler(node)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: isReasonTagMember(tagMember) ? "reason" : "tag",
+                });
+            },
+            SwitchStatement(node) {
+                if (!isTagMember(node.discriminant) ||
+                    !isInsideBroadEffectHandler(node)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: isReasonTagMember(node.discriminant) ? "reason" : "tag",
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-manual-effect-error-tag.js.map

package/dist/effect/rules/no-manual-effect-error-tag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-manual-effect-error-tag.js","sourceRoot":"","sources":["../../../src/effect/rules/no-manual-effect-error-tag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EACN,0BAA0B,EAC1B,iBAAiB,EACjB,WAAW,EACX,uBAAuB,GACvB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,CAAC,MAAM,0BAA0B,GAAG,UAAU,CAAC;IACpD,IAAI,EAAE;QACL,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACL,WAAW,EACV,8FAA8F;SAC/F;QACD,QAAQ,EAAE;YACT,GAAG,EAAE,4HAA4H;YACjI,MAAM,EACL,qIAAqI;SACtI;KACD;IACD,UAAU,CAAC,OAAO;QACjB,OAAO;YACN,gBAAgB,CAAC,IAAI;gBACpB,MAAM,SAAS,GAAG,uBAAuB,CAAC,IAAI,CAAC,CAAC;gBAChD,IACC,SAAS,KAAK,SAAS;oBACvB,CAAC,0BAA0B,CAAC,IAAI,CAAC,EAChC,CAAC;oBACF,OAAO;gBACR,CAAC;gBACD,OAAO,CAAC,MAAM,CAAC;oBACd,IAAI;oBACJ,SAAS,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK;iBAC1D,CAAC,CAAC;YACJ,CAAC;YACD,eAAe,CAAC,IAAI;gBACnB,IACC,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;oBAC/B,CAAC,0BAA0B,CAAC,IAAI,CAAC,EAChC,CAAC;oBACF,OAAO;gBACR,CAAC;gBACD,OAAO,CAAC,MAAM,CAAC;oBACd,IAAI;oBACJ,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK;iBAClE,CAAC,CAAC;YACJ,CAAC;SACD,CAAC;IACH,CAAC;CACD,CAAC,CAAC"}

package/dist/effect/rules/no-manual-tag-comparison.d.ts

@@ -0,0 +1,2 @@
+export declare const noManualTagComparisonRule: import("@oxlint/plugins").Rule;
+//# sourceMappingURL=no-manual-tag-comparison.d.ts.map

package/dist/effect/rules/no-manual-tag-comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-manual-tag-comparison.d.ts","sourceRoot":"","sources":["../../../src/effect/rules/no-manual-tag-comparison.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,yBAAyB,gCAoCpC,CAAC"}

package/dist/effect/rules/no-manual-tag-comparison.js

@@ -0,0 +1,33 @@
+import { defineRule } from "@oxlint/plugins";
+import { isInsideBroadEffectHandler, isTagMember, tagMemberFromComparison, } from "../shared/tagged-values.js";
+export const noManualTagComparisonRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use Effect Match or Predicate helpers instead of manually branching on `_tag`.",
+        },
+        messages: {
+            manualComparison: "Use Match.tag/Match.tags for tagged-value branching, or Predicate.isTagged for a simple reusable predicate.",
+            manualSwitch: "Use Match.value(value).pipe(Match.tag/Match.tags/Match.tagsExhaustive) or the tagged enum `$match` helper instead of switching on `_tag`.",
+        },
+    },
+    createOnce(context) {
+        return {
+            BinaryExpression(node) {
+                if (tagMemberFromComparison(node) === undefined ||
+                    isInsideBroadEffectHandler(node)) {
+                    return;
+                }
+                context.report({ node, messageId: "manualComparison" });
+            },
+            SwitchStatement(node) {
+                if (!isTagMember(node.discriminant) ||
+                    isInsideBroadEffectHandler(node)) {
+                    return;
+                }
+                context.report({ node, messageId: "manualSwitch" });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-manual-tag-comparison.js.map

package/dist/effect/rules/no-manual-tag-comparison.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-manual-tag-comparison.js","sourceRoot":"","sources":["../../../src/effect/rules/no-manual-tag-comparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EACN,0BAA0B,EAC1B,WAAW,EACX,uBAAuB,GACvB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;IACnD,IAAI,EAAE;QACL,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACL,WAAW,EACV,gFAAgF;SACjF;QACD,QAAQ,EAAE;YACT,gBAAgB,EACf,6GAA6G;YAC9G,YAAY,EACX,2IAA2I;SAC5I;KACD;IACD,UAAU,CAAC,OAAO;QACjB,OAAO;YACN,gBAAgB,CAAC,IAAI;gBACpB,IACC,uBAAuB,CAAC,IAAI,CAAC,KAAK,SAAS;oBAC3C,0BAA0B,CAAC,IAAI,CAAC,EAC/B,CAAC;oBACF,OAAO;gBACR,CAAC;gBACD,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,kBAAkB,EAAE,CAAC,CAAC;YACzD,CAAC;YACD,eAAe,CAAC,IAAI;gBACnB,IACC,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;oBAC/B,0BAA0B,CAAC,IAAI,CAAC,EAC/B,CAAC;oBACF,OAAO;gBACR,CAAC;gBACD,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC,CAAC;YACrD,CAAC;SACD,CAAC;IACH,CAAC;CACD,CAAC,CAAC"}

package/dist/effect/rules/no-manual-tagged-construction.d.ts

@@ -0,0 +1,2 @@
+export declare const noManualTaggedConstructionRule: import("@oxlint/plugins").Rule;
+//# sourceMappingURL=no-manual-tagged-construction.d.ts.map

package/dist/effect/rules/no-manual-tagged-construction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-manual-tagged-construction.d.ts","sourceRoot":"","sources":["../../../src/effect/rules/no-manual-tagged-construction.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,8BAA8B,gCA4BzC,CAAC"}

package/dist/effect/rules/no-manual-tagged-construction.js

@@ -0,0 +1,28 @@
+import { defineRule } from "@oxlint/plugins";
+import { isMatchPatternObject, isStringLiteral, propertyName, } from "../shared/tagged-values.js";
+export const noManualTaggedConstructionRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Construct tagged values with their existing Effect constructor instead of writing `_tag` manually.",
+        },
+        messages: {
+            manualConstruction: "Use the existing Schema tagged `.make`, tagged class/error constructor, or Data.taggedEnum variant constructor instead of writing a literal `_tag` object.",
+        },
+    },
+    createOnce(context) {
+        return {
+            ObjectExpression(node) {
+                if (isMatchPatternObject(node))
+                    return;
+                const tag = node.properties.find((property) => property.type === "Property" &&
+                    propertyName(property) === "_tag" &&
+                    isStringLiteral(property.value));
+                if (tag !== undefined) {
+                    context.report({ node: tag, messageId: "manualConstruction" });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-manual-tagged-construction.js.map

package/dist/effect/rules/no-manual-tagged-construction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-manual-tagged-construction.js","sourceRoot":"","sources":["../../../src/effect/rules/no-manual-tagged-construction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EACN,oBAAoB,EACpB,eAAe,EACf,YAAY,GACZ,MAAM,4BAA4B,CAAC;AAEpC,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC;IACxD,IAAI,EAAE;QACL,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACL,WAAW,EACV,oGAAoG;SACrG;QACD,QAAQ,EAAE;YACT,kBAAkB,EACjB,4JAA4J;SAC7J;KACD;IACD,UAAU,CAAC,OAAO;QACjB,OAAO;YACN,gBAAgB,CAAC,IAAI;gBACpB,IAAI,oBAAoB,CAAC,IAAI,CAAC;oBAAE,OAAO;gBACvC,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAC/B,CAAC,QAAQ,EAAE,EAAE,CACZ,QAAQ,CAAC,IAAI,KAAK,UAAU;oBAC5B,YAAY,CAAC,QAAQ,CAAC,KAAK,MAAM;oBACjC,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,CAChC,CAAC;gBACF,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;oBACvB,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,oBAAoB,EAAE,CAAC,CAAC;gBAChE,CAAC;YACF,CAAC;SACD,CAAC;IACH,CAAC;CACD,CAAC,CAAC"}

package/dist/effect/rules/no-service-constructor-imports.d.ts

@@ -0,0 +1,3 @@
+/** Keep dependency-bearing Effect service constructors local to their owning capability modules. */
+export declare const noServiceConstructorImportsRule: import("@oxlint/plugins").Rule;
+//# sourceMappingURL=no-service-constructor-imports.d.ts.map

package/dist/effect/rules/no-service-constructor-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-service-constructor-imports.d.ts","sourceRoot":"","sources":["../../../src/effect/rules/no-service-constructor-imports.ts"],"names":[],"mappings":"AAgBA,oGAAoG;AACpG,eAAO,MAAM,+BAA+B,gCAkC1C,CAAC"}

package/dist/effect/rules/no-service-constructor-imports.js

@@ -0,0 +1,45 @@
+import { defineRule } from "@oxlint/plugins";
+const SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
+const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+function isProjectLocalImport(source) {
+    return source.startsWith("./") || source.startsWith("../");
+}
+function getImportedName(specifier) {
+    if (specifier.imported.type === "Identifier")
+        return specifier.imported.name;
+    return specifier.imported.value;
+}
+/** Keep dependency-bearing Effect service constructors local to their owning capability modules. */
+export const noServiceConstructorImportsRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow project-local make<CapabilityName> imports outside test and spec files.",
+        },
+        messages: {
+            serviceConstructorImport: 'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
+        },
+    },
+    create(context) {
+        const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
+        return {
+            ImportDeclaration(node) {
+                if (isTestFile || !isProjectLocalImport(node.source.value))
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportSpecifier")
+                        continue;
+                    const importedName = getImportedName(specifier);
+                    if (!SERVICE_CONSTRUCTOR_NAME.test(importedName))
+                        continue;
+                    context.report({
+                        node: specifier,
+                        messageId: "serviceConstructorImport",
+                        data: { name: importedName },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-service-constructor-imports.js.map

package/dist/effect/rules/no-service-constructor-imports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-service-constructor-imports.js","sourceRoot":"","sources":["../../../src/effect/rules/no-service-constructor-imports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI7C,MAAM,wBAAwB,GAAG,aAAa,CAAC;AAC/C,MAAM,SAAS,GAAG,iCAAiC,CAAC;AAEpD,SAAS,oBAAoB,CAAC,MAAc;IAC3C,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;AAC5D,CAAC;AAED,SAAS,eAAe,CAAC,SAAiC;IACzD,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;QAAE,OAAO,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC7E,OAAO,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;AACjC,CAAC;AAED,oGAAoG;AACpG,MAAM,CAAC,MAAM,+BAA+B,GAAG,UAAU,CAAC;IACzD,IAAI,EAAE;QACL,IAAI,EAAE,SAAS;QACf,IAAI,EAAE;YACL,WAAW,EACV,kFAAkF;SACnF;QACD,QAAQ,EAAE;YACT,wBAAwB,EACvB,gMAAgM;SACjM;KACD;IACD,MAAM,CAAC,OAAO;QACb,MAAM,UAAU,GAAG,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC;QAE1E,OAAO;YACN,iBAAiB,CAAC,IAAI;gBACrB,IAAI,UAAU,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;oBAAE,OAAO;gBAEnE,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;oBACzC,IAAI,SAAS,CAAC,IAAI,KAAK,iBAAiB;wBAAE,SAAS;oBAEnD,MAAM,YAAY,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;oBAChD,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,YAAY,CAAC;wBAAE,SAAS;oBAE3D,OAAO,CAAC,MAAM,CAAC;wBACd,IAAI,EAAE,SAAS;wBACf,SAAS,EAAE,0BAA0B;wBACrC,IAAI,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE;qBAC5B,CAAC,CAAC;gBACJ,CAAC;YACF,CAAC;SACD,CAAC;IACH,CAAC;CACD,CAAC,CAAC"}

package/dist/effect/rules/prefer-effect-match.d.ts

@@ -0,0 +1,2 @@
+export declare const preferEffectMatchRule: import("@oxlint/plugins").Rule;
+//# sourceMappingURL=prefer-effect-match.d.ts.map