@commonplaces/oxlint-plugin 0.4.0 → 0.6.0

package/README.md

@@ -1,19 +1,26 @@
 # @commonplaces/oxlint-plugin
 
-106 custom Oxlint rules for strict Effect TypeScript, Alchemy and general code
-checks. This package supports **Oxlint 1.80.0, 1.85.0 or 1.86.0** and **Node 22.14 or newer**.
+107 custom Oxlint rules for strict Effect TypeScript, Alchemy and general code
+checks. Version 0.6.0 supports **Oxlint 1.87.0, 1.88.0 or 1.89.0** and **Node 22.14 or newer**.
 Oxlint's JavaScript plugin API is experimental, so upgrade it only after running
-the rule tests. The development tools use 1.80.0; consuming projects may use any supported version.
+the rule tests. The development tools use 1.89.0; consuming projects may use any supported version.
 All three exact versions are checked with independently installed archives. ESLint is not a supported host.
 
+Version 0.6.0 adds native Effect correctness and immutable accumulation checks.
+When upgrading from 0.5.0, use a supported Oxlint version and run the native
+Effect setup below after dependency installation.
+
 ## Install
 
-Install the latest npm release and save its exact version:
+Install version 0.6.0 and save its exact version:
 
 ```sh
-npm install --save-dev --save-exact @commonplaces/oxlint-plugin@latest oxlint@1.80.0
+npm install --save-dev --save-exact @commonplaces/oxlint-plugin@0.6.0 oxlint@1.89.0
 ```
 
+Version 0.6.0 supports exactly Oxlint 1.87.0, 1.88.0 or 1.89.0. Older releases
+keep their earlier host lists. Consumer adoption is a separate step.
+
 The manifest and lockfile retain the resolved version. Historical GitHub release
 archives remain separate distribution artefacts; a GitHub release does not publish
 an npm version.
@@ -46,7 +53,7 @@ project facts.
 `defineConfig({ extends: [strict, projectPolicy] })`. It adds no project paths
 or source ignores. Keep exact ownership settings in the consuming project.
 
-The root exports these six groups and the `strict` composition. Individual plugins use
+The root exports these six groups, the optional `style` preset and the `strict` composition. Individual plugins use
 the subpaths below. For example, a JSON configuration can enable one rule:
 
 ```json
@@ -56,6 +63,161 @@ the subpaths below. For example, a JSON configuration can enable one rule:
 }
 ```
 
+## Native Effect correctness
+
+Both `effect` and `strict` include every check in the pinned
+`@effect/tsgo` **0.55.0** correctness preset, all at error level. This catches
+forgotten Effect programs, incorrect generator yields, unhandled errors and
+requirements, unchecked Effect type assertions, missing Schema class brands and
+unstable APIs. Type-aware checking is enabled by the group itself; consumers
+do not need to import another preset. Upstream's unrelated style and maintainer
+preferences are not added to the public group.
+
+The package installs `@effect/tsgo` and `oxlint-tsgolint` **7.0.2004** as exact
+regular dependencies. After installing the package,
+prepare the locally installed Oxlint binaries:
+
+```sh
+npx --no-install effect-tsgo patch --no-typescript --oxlint
+npx --no-install oxlint --deny-warnings .
+```
+
+Repeat the patch after dependency installation, normally in the consuming
+project's existing `prepare` command. `--no-typescript` keeps this setup focused
+on Oxlint; a separate TypeScript compiler installation is not needed for the
+patch. Missing native setup causes a configuration error. It never silently
+falls back to the custom syntax checks. The checker supports exactly the three
+Oxlint versions above; 1.86.0 is no longer supported in version 0.6.0.
+
+Keep a normal `tsconfig.json` covering the checked files. Native diagnostic
+options, such as exact unstable APIs approved for particular test files, live
+under the `@effect/language-service` compiler plugin configuration. Leave its
+`diagnostics` option false when Oxlint owns reporting. The archive tests prove
+that forgotten work fails even without `--deny-warnings` and without a caller
+adding `--type-aware`.
+
+## Optional style preset
+
+Add `style` before `strict`, then keep the project's own policy last:
+
+```ts
+import { style, strict } from "@commonplaces/oxlint-plugin";
+import { defineConfig } from "oxlint";
+import project from "./tools/oxlint/project.config.ts";
+
+export default defineConfig({ extends: [style, strict, project] });
+```
+
+Run `oxlint --type-aware --deny-warnings .`. `style` also works alone and is
+available as the default export of `@commonplaces/oxlint-plugin/style`.
+It never imports or extends `strict`; `strict` still contains only its original
+six groups. Adding `style` leaves strict settings unchanged. This preset includes more than formatting preferences: Ultracite
+also supplies accessibility, test and correctness checks, browser globals,
+shared ignores and test-file overrides. Its ignores can reduce which files are
+checked; keep the project's own file policy explicit.
+
+Ultracite **8.0.1** is an exact regular dependency, selected at the owner's
+request to use the latest releases. It requires no separate consumer install. A peer would
+make consumers choose and install a second package, and could make imports of
+the root package fail when it is missing. The dependency also installs
+Ultracite's CLI dependencies; only the three Oxlint configuration modules run
+when importing this preset. No Ultracite CLI, formatter or Effect runtime runs.
+
+### Shared overrides
+
+These eleven rules are off in both historical root configurations: Common
+Practice at `3b6beef^` and Site at `dda3820`. File-specific permissions and
+size limits remain in each consumer's project policy.
+
+| Rule set to `off`                     | Reason                                                                                                                           |
+| ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `unicorn/no-array-for-each`           | Allow Effect's immutable `Array.forEach`; strict collection checks cover native mutation.                                        |
+| `unicorn/no-array-sort`               | Allow Effect's immutable `Array.sort`; strict collection checks cover native mutation.                                           |
+| `unicorn/throw-new-error`             | Allow the `Schema.TaggedError` factory; `strict-effect/error-constructor-new` checks error construction when strict is selected. |
+| `no-redeclare`                        | Allow TypeScript overloads and merged declarations.                                                                              |
+| `react/function-component-definition` | Allow the project's existing component declaration forms.                                                                        |
+| `sort-keys`                           | Keep related object fields in meaningful order.                                                                                  |
+| `func-names`                          | Allow unnamed library callbacks and Effect generators.                                                                           |
+| `func-style`                          | Allow function declarations and functions stored in constants.                                                                   |
+| `no-use-before-define`                | Allow declarations to refer to later declarations.                                                                               |
+| `no-inline-comments`                  | Allow short explanations beside the code they describe.                                                                          |
+| `typescript/consistent-return`        | Leave return types and Effect generator branches to TypeScript.                                                                  |
+
+### Effect compatibility
+
+Style must accept the code required by strict Effect. Putting `strict` last
+only resolves two settings for the same rule; it cannot stop a different style
+rule asking for forbidden code. For example, `typescript/promise-function-async`
+asks for `async` on a host callback that returns `Effect.runPromise(...)`, while
+both strict async checks reject the added keyword. Return the Promise directly
+at the approved host boundary. Keep ordinary application work in Effect.
+
+The preset turns off these additional style rules, including when used alone:
+
+| Rules set to `off`                                                              | Reason                                                                                         |
+| ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| `require-await`, `typescript/promise-function-async`, `typescript/return-await` | Do not ask for `async` or `await`. Strict rules own Promise boundaries.                        |
+| `promise/prefer-await-to-callbacks`, `promise/prefer-await-to-then`             | Do not replace callbacks or Promise chains with `await`; use Effect at the owning adapter.     |
+| `typescript/prefer-for-of`, `unicorn/no-array-reduce`                           | Do not suggest loops. Allow Effect's immutable `Array.reduce`, including renamed imports.      |
+| `oxc/no-accumulating-spread`                                                    | Its mutation advice is replaced by `strict-effect/no-copying-accumulator` in the Effect group. |
+| `unicorn/prefer-at`                                                             | Use checked Effect collection access instead of native `.at`.                                  |
+| `unicorn/prefer-date-now`                                                       | Use Effect's clock instead of `Date.now`.                                                      |
+| `unicorn/prefer-reflect-apply`                                                  | Do not suggest `Reflect.apply`, which strict rejects.                                          |
+| `unicorn/prefer-set-has`                                                        | Use Effect collections instead of suggesting a native mutable `Set`.                           |
+| `typescript/non-nullable-type-assertion-style`                                  | Do not replace a type assertion with `!`; strict rejects both unchecked forms.                 |
+| `unicorn/prefer-ternary`                                                        | Do not request ternaries while strict's `no-ternary` is enabled.                               |
+| `max-classes-per-file`                                                          | Keep related Schema error classes or service contracts in their owning module.                 |
+
+These changes do not grant runtime, SDK or Promise permissions. Keep exact host
+files in the project's policy. Strict still rejects async/await, raw Promises,
+loops, mutation, unchecked access, thrown failures and unapproved runtime calls.
+The collection convention accepts `Array.reduce(initial, callback)(values)`;
+its three-argument form `Array.reduce(values, initial, callback)` still fails.
+
+### Supported-host adjustments
+
+The imported configurations need two small adjustments; these are separate
+from the eleven shared overrides above:
+
+- React's explicit disables for `jsx-a11y/no-autofocus` and
+  `react/forward-ref-uses-ref` are omitted. This lets the host's correctness
+  settings apply: selecting `strict` keeps both at error level. Merely putting
+  `strict` last would not overcome an explicit upstream disable when strict
+  enables a rule through its correctness category.
+- Vitest's file override disabling `vitest/valid-title` is also omitted, so
+  strict's correctness setting still applies inside test files.
+
+The tests install the packed archive on every supported host and compare
+every resolved strict rule, including its options, with `[style, strict]`.
+They also check inherited file overrides. Type-aware archive tests compile and
+lint approved host callbacks, SDK adapters, Effect programs, immutable
+collections and related error classes. Restoring the async style rule makes the
+host example fail, proving the type-aware check runs. Forbidden examples must
+retain every strict diagnostic after style is added. The adjustments import no
+strict settings; other upstream settings remain intact.
+
+### Ultracite 8.0.1 comparison
+
+The installed npm archives were compared, including rule options and file
+patterns, rather than relying on release notes. For the three selected presets:
+
+| Preset | Rules in 7.12.0 | Rules in 8.0.1 | Change                                                        |
+| ------ | --------------: | -------------: | ------------------------------------------------------------- |
+| Core   |             536 |            537 | Adds `typescript/no-generated-empty-object-type` as an error. |
+| React  |             124 |            124 | `react/jsx-no-target-blank` adds `{ forms: true }`.           |
+| Vitest |              74 |             75 | Adds `vitest/consistent-test-it` as an error.                 |
+
+Counts include entries explicitly set to off and entries in file overrides.
+No rule is removed and no other rule severity or option changes. Core's shared
+test overrides and Vitest's test rules also start matching `.mts`, `.cts`,
+`.mjs` and `.cjs` files. Shared ignores, globals and plugin lists are unchanged.
+Both versions contain `no-unmodified-loop-condition` with
+`checkConditionalExpressions: true`; the supported hosts accept that option.
+Ultracite 8 requires Oxlint 1.86 or newer, so 1.80 and 1.85 are no longer
+supported. Its Oxfmt peer requires at least 0.71; repository tooling uses 0.74.0.
+The current archive is checked on exactly 1.87.0, 1.88.0 and 1.89.0, matching the
+pinned native Effect checker. Published 0.5.0 was qualified on 1.86.0 and 1.89.0.
+
 ## Project settings
 
 Rules that refer to project files, schemas or routes are available but excluded
@@ -134,11 +296,38 @@ Alchemy checks use `alchemy-secrets/`. Keep those names when moving from copied
 rule files. Remove the copied implementations and change `jsPlugins` to the
 package subpaths; keep your existing rule settings.
 
+## Immutable accumulation
+
+`effect` and `strict` enable `strict-effect/no-copying-accumulator` as an error.
+It catches repeated array accumulator spreads, growing object spreads, copying
+`Array.append`/`prepend`/`appendAll`/`prependAll`/`union`/`copy` calls and
+`Record.set`/`union` calls in Effect reducers. Repeatedly copying an ever larger
+result can make a modest input expensive to process.
+
+Use `Array.map` or `Array.flatMap` to produce an array. Use `Record.fromEntries`
+to build a record in one pass. When genuine accumulation is needed, use
+persistent `Chunk.append`, `HashMap.set` or `HashSet.add`, which share existing
+structure. The rule never suggests mutation and has no automatic fix.
+
+It recognises imported Effect `reduce`, `reduceRight`, `scan` and `scanRight`
+operations, including named, namespace, renamed and immutable aliased imports.
+Both argument orders and locally declared callbacks are covered. It follows
+accumulator aliases, fields and destructured fields, checks copied values by
+their actual local binding, and recognises a copier as the first pipe operation.
+Shadowed names, unrelated libraries, scalar folds, spreads of the current input
+and fixed-shape object spreads remain valid. `Array.fromIterable` is allowed: the
+installed Effect version reuses an input array rather than copying it.
+
+This is a local written-pattern check. It does not follow imported callbacks,
+opaque helper implementations, mutable aliases or an accumulator through later
+pipe operations, and it does not measure input sizes or prove a runtime cost.
+Native loops and mutation remain forbidden by the separate strict rules.
+
 ## Rule exports
 
 | Package subpath     | Rule prefix           | Rules |
 | ------------------- | --------------------- | ----: |
-| `/strict-effect`    | `strict-effect/`      |    29 |
+| `/strict-effect`    | `strict-effect/`      |    30 |
 | `/effect`           | `effect/`             |     9 |
 | `/alchemy`          | `alchemy-secrets/`    |     3 |
 | `/bun`              | `bun/`                |     1 |

package/dist/accumulation.d.ts

@@ -0,0 +1 @@
+export declare const noCopyingAccumulator: import("@oxlint/plugins").Rule;

package/dist/accumulation.js

@@ -0,0 +1,140 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Option } from "effect";
+import { constant, operation, referenceOf, valueOf } from "./native-reference.js";
+import { childNodes, propertyName, variableInScope } from "./syntax.js";
+const reducers = ["Array", "Chunk", "HashMap", "HashSet", "Record", "Effect"];
+const isFunction = (node) => node.type === "ArrowFunctionExpression" ||
+    node.type === "FunctionExpression" ||
+    node.type === "FunctionDeclaration";
+const callbackOf = (context, node, visited = []) => {
+    if (Array.some(visited, (entry) => entry === node))
+        return Option.none();
+    if (isFunction(node))
+        return Option.some(node);
+    if (node.type !== "Identifier")
+        return Option.none();
+    const next = [...visited, node];
+    return variableInScope(context.sourceCode.getScope(node), node.name).pipe(Option.flatMap((variable) => constant(variable).pipe(Option.flatMap((declaration) => Option.fromNullishOr(declaration.init)), Option.flatMap((value) => callbackOf(context, value, next)), Option.orElse(() => Array.head(variable.defs).pipe(Option.filter(() => Array.every(variable.references, (entry) => !entry.isWrite())), Option.map((definition) => definition.node), Option.filter(isFunction))))));
+};
+const bindings = (node) => {
+    if (node.type === "Identifier")
+        return [node];
+    if (node.type === "AssignmentPattern")
+        return bindings(node.left);
+    if (node.type === "RestElement")
+        return bindings(node.argument);
+    if (node.type === "ObjectPattern")
+        return Array.flatMap(node.properties, (property) => property.type === "Property"
+            ? bindings(property.value)
+            : property.type === "RestElement"
+                ? bindings(property.argument)
+                : []);
+    if (node.type === "ArrayPattern")
+        return Array.flatMap(node.elements, (element) => element === null ? [] : bindings(element));
+    return [];
+};
+// Compare bindings, not names: a nested parameter called `acc` is another value.
+// Only immutable local aliases are followed; imported helpers remain opaque.
+const accumulator = (context, node, variables, visited = []) => {
+    if (Array.some(visited, (entry) => entry === node))
+        return false;
+    const next = [...visited, node];
+    if (node.type === "TSAsExpression" ||
+        node.type === "TSSatisfiesExpression" ||
+        node.type === "TSNonNullExpression" ||
+        node.type === "ChainExpression")
+        return accumulator(context, node.expression, variables, next);
+    if (node.type === "MemberExpression")
+        return accumulator(context, node.object, variables, next);
+    if (node.type !== "Identifier")
+        return false;
+    return variableInScope(context.sourceCode.getScope(node), node.name).pipe(Option.exists((variable) => Array.some(variables, (entry) => entry === variable) ||
+        constant(variable).pipe(Option.flatMap((declaration) => Option.fromNullishOr(declaration.init)), Option.exists((value) => accumulator(context, value, variables, next)))));
+};
+// The argument count is the installed operation's data-first arity. Persistent
+// Chunk/HashMap/HashSet updates share structure and deliberately do not appear.
+const copierArity = (context, node) => referenceOf(context, node).pipe(Option.flatMap((reference) => Option.flatMap(reference.name, (name) => {
+    if (reference.module === "effect/Array") {
+        if (name === "copy")
+            return Option.some(1);
+        if (Array.contains(["append", "appendAll", "prepend", "prependAll", "union"], name))
+            return Option.some(2);
+    }
+    if (reference.module === "effect/Record") {
+        if (name === "set")
+            return Option.some(3);
+        if (name === "union")
+            return Option.some(2);
+    }
+    return Option.none();
+})));
+const curriedCopier = (context, node) => {
+    const resolved = Option.getOrElse(valueOf(context, node), () => node);
+    if (resolved.type !== "CallExpression")
+        return Option.contains(copierArity(context, resolved), 1);
+    return copierArity(context, resolved.callee).pipe(Option.exists((arity) => arity > 1 && resolved.arguments.length === arity - 1));
+};
+export const noCopyingAccumulator = defineRule({
+    meta: {
+        type: "problem",
+        schema: [],
+        docs: { description: "Reject repeated accumulator copies without recommending mutation." },
+        messages: {
+            copying: "Copying the growing result on every step can make a small input very slow. Use Effect Array.map/flatMap, Record.fromEntries, Chunk.append, HashMap.set or HashSet.add. Keep old values unchanged; do not use push, Object.assign or mutable builders.",
+        },
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                const reducer = referenceOf(context, node.callee).pipe(Option.exists((reference) => Array.some(reducers, (module) => reference.module === `effect/${module}`) &&
+                    Option.exists(reference.name, (name) => Array.contains(["reduce", "reduceRight", "scan", "scanRight"], name))));
+                if (!reducer || node.arguments.length < 2)
+                    return;
+                const argument = Array.get(node.arguments, node.arguments.length >= 3 ? 2 : 1);
+                const callback = Option.flatMap(argument, (value) => callbackOf(context, value));
+                if (Option.isNone(callback) || !isFunction(callback.value))
+                    return;
+                const first = Array.head(callback.value.params);
+                const variables = first.pipe(Option.map((parameter) => Array.flatMap(bindings(parameter), (binding) => Option.toArray(variableInScope(context.sourceCode.getScope(binding), binding.name)))), Option.getOrElse(() => []));
+                const report = (copy) => context.report({ node: copy, messageId: "copying" });
+                const isAccumulator = (value) => accumulator(context, value, variables);
+                const inspect = (value) => {
+                    // A fixed-shape object update is bounded. Dynamic keys or another
+                    // spread can grow the copied record with each incoming element.
+                    if (value.type === "SpreadElement" &&
+                        (value.parent.type === "ArrayExpression" ||
+                            (value.parent.type === "ObjectExpression" &&
+                                Array.some(value.parent.properties, (property) => (property.type === "Property" &&
+                                    property.computed &&
+                                    property.key.type !== "Literal") ||
+                                    (property.type === "SpreadElement" && property !== value)))) &&
+                        isAccumulator(value.argument))
+                        report(value);
+                    if (value.type === "CallExpression") {
+                        if (copierArity(context, value.callee).pipe(Option.exists((arity) => value.arguments.length >= arity)) &&
+                            Array.head(value.arguments).pipe(Option.exists(isAccumulator)))
+                            report(value);
+                        if (value.callee.type === "CallExpression" &&
+                            curriedCopier(context, value.callee) &&
+                            Array.head(value.arguments).pipe(Option.exists(isAccumulator)))
+                            report(value);
+                        const pipe = operation(context, value.callee, "effect/Function", "pipe") ||
+                            operation(context, value.callee, "effect", "pipe");
+                        const method = value.callee.type === "MemberExpression" &&
+                            Option.contains(propertyName(value.callee.property), "pipe") &&
+                            isAccumulator(value.callee.object);
+                        const transforms = method ? value.arguments : Array.drop(value.arguments, 1);
+                        if (method || (pipe && Array.head(value.arguments).pipe(Option.exists(isAccumulator))))
+                            Array.head(transforms).pipe(Option.map((transform) => {
+                                if (curriedCopier(context, transform))
+                                    report(transform);
+                            }));
+                    }
+                    Array.forEach(childNodes(context, value), inspect);
+                };
+                if (callback.value.body)
+                    inspect(callback.value.body);
+            },
+        };
+    },
+});

package/dist/config.js

@@ -1,5 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
-import { Array, Option, Predicate, Record, Schema } from "effect";
+import { Array, HashMap, Option, Predicate, Record, Schema } from "effect";
 import { childNodes, propertyName, variableInScope } from "./syntax.js";
 const RuleId = Schema.String.check(Schema.isPattern(/^\S+$/u));
 const Options = Schema.Struct({
@@ -37,7 +37,7 @@ const staticValue = (context, node, visited = []) => {
 const staticProperties = (context, node) => staticValue(context, node).pipe(Option.filter((value) => value.type === "ObjectExpression"), Option.flatMap((value) => {
     if (value.type !== "ObjectExpression")
         return Option.none();
-    const empty = {};
+    const empty = HashMap.empty();
     return Option.some(Array.reduce(value.properties, empty, (known, entry) => {
         if (entry.type !== "Property")
             return empty;
@@ -48,9 +48,9 @@ const staticProperties = (context, node) => staticValue(context, node).pipe(Opti
             : propertyName(entry.key);
         return Option.match(key, {
             onNone: () => empty,
-            onSome: (name) => Record.set(known, name, entry),
+            onSome: (name) => HashMap.set(known, name, entry),
         });
-    }));
+    }).pipe(HashMap.toEntries, Record.fromEntries));
 }));
 const importedConfig = (context, node, namespace) => {
     if (node.type !== "Identifier")

package/dist/conventions/syntax.js

@@ -51,7 +51,8 @@ export const syntaxRules = {
                 "reduce",
                 "some",
                 "sort",
-            ], name)))))
+            ], name) &&
+                (name !== "reduce" || node.arguments.length >= 3)))))
                 report(context, node);
         },
     })),

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import type { OxlintConfig } from "oxlint";
 /** General code checks, with no project-specific file names or settings. */
 export declare const general: {
     jsPlugins: string[];
@@ -21,33 +22,7 @@ export declare const general: {
     };
 };
 /** Effect code checks. Add the general group separately if wanted. */
-export declare const effect: {
-    jsPlugins: string[];
-    rules: {
-        "effect/no-ambient-process": "error";
-        "effect/no-async-await-promise": "error";
-        "effect/no-console": "error";
-        "effect/no-instanceof": "error";
-        "effect/no-manual-tag": "error";
-        "effect/no-raw-fetch": "error";
-        "effect/require-service-operation-instrumentation": "error";
-        "strict-effect/static-layers": "error";
-        "strict-effect/subprocess-pipe-capture": "error";
-        "strict-effect/no-runtime-type-assertions": "error";
-        "strict-effect/no-unchecked-index": "error";
-        "strict-effect/no-native-at": "error";
-        "strict-effect/tagged-error-name": "error";
-        "strict-effect/error-constructor-new": "error";
-        "strict-effect/no-promise-workflow": "error";
-        "strict-effect/no-unsafe-option-unwrap": "error";
-        "strict-effect/no-unchecked-json": "error";
-        "strict-effect/no-native-work": "error";
-        "strict-effect/no-imperative-collections": "error";
-        "strict-effect/no-native-client-replica": "error";
-        "bun/no-ambient-host-api": "error";
-        "anti-slop-effect/no-service-constructor-imports": "error";
-    };
-};
+export declare const effect: OxlintConfig;
 /** Optional strict coding conventions; boundary permissions remain project facts. */
 export declare const conventions: {
     jsPlugins: string[];
@@ -95,7 +70,7 @@ export declare const alchemy: {
 };
 /** Complete strict Effect application profile; exact project owners stay local. */
 export declare const strict: {
-    extends: ({
+    extends: (OxlintConfig | {
         jsPlugins: string[];
         rules: {
             "anti-slop/no-chained-type-assertions": "error";
@@ -115,32 +90,6 @@ export declare const strict: {
             "anti-slop/require-safety-comment-for-type-assertion": "error";
             "package/no-cross-package-source-imports": "error";
         };
-    } | {
-        jsPlugins: string[];
-        rules: {
-            "effect/no-ambient-process": "error";
-            "effect/no-async-await-promise": "error";
-            "effect/no-console": "error";
-            "effect/no-instanceof": "error";
-            "effect/no-manual-tag": "error";
-            "effect/no-raw-fetch": "error";
-            "effect/require-service-operation-instrumentation": "error";
-            "strict-effect/static-layers": "error";
-            "strict-effect/subprocess-pipe-capture": "error";
-            "strict-effect/no-runtime-type-assertions": "error";
-            "strict-effect/no-unchecked-index": "error";
-            "strict-effect/no-native-at": "error";
-            "strict-effect/tagged-error-name": "error";
-            "strict-effect/error-constructor-new": "error";
-            "strict-effect/no-promise-workflow": "error";
-            "strict-effect/no-unsafe-option-unwrap": "error";
-            "strict-effect/no-unchecked-json": "error";
-            "strict-effect/no-native-work": "error";
-            "strict-effect/no-imperative-collections": "error";
-            "strict-effect/no-native-client-replica": "error";
-            "bun/no-ambient-host-api": "error";
-            "anti-slop-effect/no-service-constructor-imports": "error";
-        };
     } | {
         jsPlugins: string[];
         rules: Record<`effect-conventions/${string}`, "error">;
@@ -180,3 +129,4 @@ export declare const strict: {
         };
     })[];
 };
+export { default as style } from "./style.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+import { correctness } from "@effect/tsgo/oxlint-presets";
 import { Record } from "effect";
 import conventionPlugin from "./conventions.js";
 import webPlugin from "./web.js";
@@ -25,6 +26,7 @@ export const general = {
 };
 /** Effect code checks. Add the general group separately if wanted. */
 export const effect = {
+    ...correctness,
     jsPlugins: [
         "@commonplaces/oxlint-plugin/effect",
         "@commonplaces/oxlint-plugin/strict-effect",
@@ -32,6 +34,7 @@ export const effect = {
         "@commonplaces/oxlint-plugin/anti-slop-effect",
     ],
     rules: {
+        ...Record.map(correctness.rules ?? {}, () => "error"),
         "effect/no-ambient-process": "error",
         "effect/no-async-await-promise": "error",
         "effect/no-console": "error",
@@ -51,6 +54,7 @@ export const effect = {
         "strict-effect/no-unchecked-json": "error",
         "strict-effect/no-native-work": "error",
         "strict-effect/no-imperative-collections": "error",
+        "strict-effect/no-copying-accumulator": "error",
         "strict-effect/no-native-client-replica": "error",
         "bun/no-ambient-host-api": "error",
         "anti-slop-effect/no-service-constructor-imports": "error",
@@ -106,3 +110,4 @@ export const alchemy = {
 export const strict = {
     extends: [general, effect, alchemy, conventions, web, typescript],
 };
+export { default as style } from "./style.js";

package/dist/package/workspace-import-boundaries.js

@@ -1,5 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
-import { Array, Number, Option, Predicate, Record, Schema } from "effect";
+import { Array, Chunk, Number, Option, Predicate, Record, Schema } from "effect";
 import { variableInScope } from "../syntax.js";
 // A checked manifest consumer selects export conditions before configuring this
 // pure rule. A false entry preserves a manifest's explicit null export fence.
@@ -104,13 +104,13 @@ const moduleAddress = (context, node, visited = []) => {
         ? Option.fromNullishOr(definition.node.init)
         : Option.none()), Option.flatMap((initialiser) => moduleAddress(context, initialiser, next)));
 };
-const resolvePath = (base, address) => Array.join(Array.reduce(address.split("/"), base === "." || base === "" ? [] : base.split("/"), (parts, part) => part === ".."
-    ? parts.length === 0 || Option.contains(Array.last(parts), "..")
-        ? [...parts, ".."]
-        : Array.dropRight(parts, 1)
+const resolvePath = (base, address) => Chunk.join(Array.reduce(address.split("/"), Chunk.fromIterable(base === "." || base === "" ? [] : base.split("/")), (parts, part) => part === ".."
+    ? parts.length === 0 || Option.contains(Chunk.last(parts), "..")
+        ? Chunk.append(parts, "..")
+        : Chunk.dropRight(parts, 1)
     : part === "." || part === ""
         ? parts
-        : [...parts, part]), "/");
+        : Chunk.append(parts, part)), "/");
 const relativeFile = (filename, cwd) => {
     const file = normalise(filename);
     const root = normalise(cwd).replace(/\/$/u, "");

package/dist/package.js

@@ -1,12 +1,12 @@
 import { defineRule } from "@oxlint/plugins";
-import { Array, Option, Predicate } from "effect";
+import { Array, Chunk, Option, Predicate } from "effect";
 import { workspaceImportBoundariesRule } from "./package/workspace-import-boundaries.js";
 import { noRedundantRuleRegistrations } from "./config.js";
-const resolveRelative = (fileName, specifier) => Array.join(Array.reduce(specifier.split("/"), Array.dropRight(fileName.split("/"), 1), (segments, segment) => segment === ".."
-    ? Array.dropRight(segments, 1)
+const resolveRelative = (fileName, specifier) => Chunk.join(Array.reduce(specifier.split("/"), Chunk.fromIterable(Array.dropRight(fileName.split("/"), 1)), (segments, segment) => segment === ".."
+    ? Chunk.dropRight(segments, 1)
     : segment === "." || segment.length === 0
         ? segments
-        : [...segments, segment]), "/");
+        : Chunk.append(segments, segment)), "/");
 const workspaceSourceRoot = (fileName) => Option.fromNullishOr(fileName.match(/\/(?:apps|packages|content)\/[^/]+(?:\/|$)/u)).pipe(Option.flatMap(Array.head), Option.map((root) => root.replace(/\/$/u, "")));
 const isPrivatePackageAlias = (specifier) => /^@[^/]+\/[^/]+\/src(?:\/|$)/u.test(specifier);
 const isCrossWorkspaceSourcePath = (fileName, specifier) => {

package/dist/service-instrumentation.js

@@ -1,5 +1,5 @@
 import { defineRule } from "@oxlint/plugins";
-import { Array, Option, Schema } from "effect";
+import { Array, Chunk, Option, Schema } from "effect";
 import { constant, operation, referenceOf, valueOf } from "./native-reference.js";
 import { childNodes, propertyName, variableInScope } from "./syntax.js";
 const Options = Schema.Struct({
@@ -17,11 +17,11 @@ const adapted = (context, node, name, adapters) => {
         return false;
     return referenceOf(context, value.value.callee).pipe(Option.exists((reference) => Array.some(adapters, (adapter) => {
         const relative = reference.module.startsWith(".")
-            ? Array.join(Array.reduce(reference.module.split("/"), Array.dropRight(context.filename.replaceAll("\\", "/").split("/"), 1), (parts, segment) => segment === ".."
-                ? Array.dropRight(parts, 1)
+            ? Chunk.join(Array.reduce(reference.module.split("/"), Chunk.fromIterable(Array.dropRight(context.filename.replaceAll("\\", "/").split("/"), 1)), (parts, segment) => segment === ".."
+                ? Chunk.dropRight(parts, 1)
                 : segment === "."
                     ? parts
-                    : [...parts, segment]), "/")
+                    : Chunk.append(parts, segment)), "/")
             : "";
         const source = (path) => path.replace(/\.[cm]?[jt]sx?$/u, "");
         return (adapter.operation === name &&

package/dist/strict-effect.js

@@ -1,6 +1,8 @@
 import { subprocessPipeCapture } from "./subprocess-pipe-capture.js";
+import { noCopyingAccumulator } from "./accumulation.js";
 import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
 import * as Array from "effect/Array";
+import * as Chunk from "effect/Chunk";
 import * as Function from "effect/Function";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
@@ -596,6 +598,23 @@ const layerExpression = (context, expression, visited = []) => {
         if (Array.isReadonlyArrayEmpty(expression.arguments)) {
             return layerExpression(context, expression.callee.object, next);
         }
+        // Completed Match.value pipelines return their branch values, including
+        // Layers. Inline native callbacks remain allowed; an owned factory does not.
+        const completesMatch = Array.last(expression.arguments).pipe(Option.exists((argument) => scopedEffectReference(context, argument.type === "CallExpression" ? argument.callee : argument).pipe(Option.exists((reference) => isExport(reference, "effect/Match", "exhaustive") ||
+            isExport(reference, "effect/Match", "orElse")))));
+        const valueMatch = expression.callee.object.type === "CallExpression" &&
+            scopedEffectReference(context, expression.callee.object.callee).pipe(Option.exists((reference) => isExport(reference, "effect/Match", "value")));
+        const branchReturnsLayer = (argument) => argument.type === "CallExpression" &&
+            scopedEffectReference(context, argument.callee).pipe(Option.exists((reference) => reference.module === "effect/Match")) &&
+            Array.some((callback) => (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression") &&
+                Option.fromNullishOr(callback.body).pipe(Option.exists((body) => body.type === "BlockStatement"
+                    ? returnsLayer(context, body)
+                    : layerExpression(context, body, next))))(argument.arguments);
+        if (valueMatch &&
+            completesMatch &&
+            Array.some(branchReturnsLayer)(expression.arguments)) {
+            return true;
+        }
         return transforms(expression.arguments);
     }
     return false;
@@ -1493,15 +1512,15 @@ const relativeModule = (filename, address) => {
         return address;
     }
     const directory = filename.replaceAll("\\", "/").replace(/\/[^/]+$/u, "");
-    return Function.pipe(`${directory}/${address}`.split("/"), Array.reduce([], (parts, part) => {
+    return Function.pipe(`${directory}/${address}`.split("/"), Array.reduce(Chunk.empty(), (parts, part) => {
         if (part === "." || part === "") {
             return parts;
         }
         if (part === "..") {
-            return Array.dropRight(parts, 1);
+            return Chunk.dropRight(parts, 1);
         }
-        return [...parts, part];
-    }), Array.join("/"));
+        return Chunk.append(parts, part);
+    }), Chunk.join("/"));
 };
 const CheckedPageOptions = Schema.Struct({
     checkedHelper: Schema.Struct({ module: Schema.String, export: Schema.String }),
@@ -2543,6 +2562,7 @@ export default eslintCompatPlugin({
         "no-native-work": noNativeWork,
         "no-runtime-type-assertions": noRuntimeTypeAssertions,
         "no-imperative-collections": noImperativeCollections,
+        "no-copying-accumulator": noCopyingAccumulator,
         "public-host-literals": publicHostLiterals,
         "route-literal-ownership": routeLiteralOwnership,
         "http-client-ownership": httpClientOwnership,

package/dist/style.d.ts

@@ -0,0 +1,4 @@
+import type { OxlintConfig } from "oxlint";
+/** Optional shared style checks. Extend before strict and the project policy. */
+declare const style: OxlintConfig;
+export default style;

package/dist/style.js

@@ -0,0 +1,58 @@
+import { Array, Record } from "effect";
+import core from "ultracite/oxlint/core";
+import react from "ultracite/oxlint/react";
+import vitest from "ultracite/oxlint/vitest";
+/** Optional shared style checks. Extend before strict and the project policy. */
+const style = {
+    extends: [
+        core,
+        {
+            ...react,
+            // Leave these correctness rules to the host category settings. Explicit
+            // upstream "off" values would beat strict's correctness category.
+            rules: Record.filter(react.rules ?? {}, (_, name) => name !== "jsx-a11y/no-autofocus" && name !== "react/forward-ref-uses-ref"),
+        },
+        {
+            ...vitest,
+            // Keep the host's correctness check for test titles in test files too.
+            overrides: Array.map(vitest.overrides ?? [], (override) => ({
+                ...override,
+                rules: Record.filter(override.rules ?? {}, (_, name) => name !== "vitest/valid-title"),
+            })),
+        },
+    ],
+    rules: {
+        // Effect owns asynchronous work. Host callbacks may return a Promise
+        // directly without adding async, await or a Promise chain.
+        "require-await": "off",
+        "typescript/promise-function-async": "off",
+        "typescript/return-await": "off",
+        "promise/prefer-await-to-callbacks": "off",
+        "promise/prefer-await-to-then": "off",
+        // These rewrites suggest loops, mutation or native APIs that strict Effect
+        // rejects. Immutable Effect operations remain checked by the strict rules.
+        "typescript/prefer-for-of": "off",
+        "typescript/non-nullable-type-assertion-style": "off",
+        "oxc/no-accumulating-spread": "off",
+        "unicorn/no-array-reduce": "off",
+        "unicorn/prefer-at": "off",
+        "unicorn/prefer-date-now": "off",
+        "unicorn/prefer-reflect-apply": "off",
+        "unicorn/prefer-set-has": "off",
+        "unicorn/prefer-ternary": "off",
+        // An errors or service module may own several related Schema classes.
+        "max-classes-per-file": "off",
+        "unicorn/no-array-for-each": "off",
+        "unicorn/no-array-sort": "off",
+        "unicorn/throw-new-error": "off",
+        "no-redeclare": "off",
+        "react/function-component-definition": "off",
+        "sort-keys": "off",
+        "func-names": "off",
+        "func-style": "off",
+        "no-use-before-define": "off",
+        "no-inline-comments": "off",
+        "typescript/consistent-return": "off",
+    },
+};
+export default style;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonplaces/oxlint-plugin",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Shared Oxlint rules for strict Effect TypeScript, Alchemy and repository code.",
   "license": "MIT",
   "author": "Cooper Corbett",
@@ -56,6 +56,10 @@
     "./anti-slop-effect": {
       "types": "./dist/anti-slop/effect/index.d.ts",
       "default": "./dist/anti-slop/effect/index.js"
+    },
+    "./style": {
+      "types": "./dist/style.d.ts",
+      "default": "./dist/style.js"
     }
   },
   "publishConfig": {
@@ -68,18 +72,21 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@oxlint/plugins": "1.80.0",
-    "effect": "4.0.2"
+    "@effect/tsgo": "0.55.0",
+    "@oxlint/plugins": "1.89.0",
+    "effect": "4.0.5",
+    "oxlint-tsgolint": "7.0.2004",
+    "ultracite": "8.0.1"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.2",
-    "@effect/vitest": "4.0.2",
-    "@types/bun": "1.4.0",
+    "@effect/platform-node": "4.0.5",
+    "@effect/vitest": "4.0.5",
+    "@types/bun": "1.4.3",
     "typescript": "7.0.2",
-    "vitest": "5.0.1"
+    "vitest": "5.0.5"
   },
   "peerDependencies": {
-    "oxlint": "1.80.0 || 1.85.0 || 1.86.0"
+    "oxlint": "1.87.0 || 1.88.0 || 1.89.0"
   },
   "engines": {
     "node": ">=22.14.0"