@commonplaces/oxlint-plugin 0.5.0 → 0.6.1

package/README.md

@@ -1,21 +1,26 @@
 # @commonplaces/oxlint-plugin
 
-106 custom Oxlint rules for strict Effect TypeScript, Alchemy and general code
-checks. This package supports **Oxlint 1.86.0 or 1.89.0** and **Node 22.14 or newer**.
+107 custom Oxlint rules for strict Effect TypeScript, Alchemy and general code
+checks. Version 0.6.1 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.89.0; consuming projects may use any supported version.
-Both exact versions are checked with independently installed archives. ESLint is not a supported host.
+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 version 0.5.0 and save its exact version:
+Install version 0.6.1 and save its exact version:
 
 ```sh
-npm install --save-dev --save-exact @commonplaces/oxlint-plugin@0.5.0 oxlint@1.89.0
+npm install --save-dev --save-exact @commonplaces/oxlint-plugin@0.6.1 \
+  @effect/tsgo@0.55.0 oxlint@1.89.0 oxlint-tsgolint@7.0.2004 typescript@7.0.2
 ```
 
-Version 0.5.0 adds the optional style preset and the host requirements above.
-Published 0.4.0 keeps its earlier host list. Consumer adoption is a separate step.
+Version 0.6.1 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
@@ -59,6 +64,64 @@ 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 ships `@effect/tsgo` **0.55.0** and `oxlint-tsgolint` **7.0.2004**
+as exact regular dependencies. Full Effect projects should also declare their
+compiler and checker tools directly, as in the install command above. This
+keeps the selected local tools explicit. The pinned checker supports TypeScript
+**7.0.2** or **7.1.0-dev.20261019.1**, alongside the three Oxlint versions above.
+The archive tests use TypeScript 7.0.2.
+Check the installed checker's supported versions before changing these tools.
+
+Use [Effect's recommended automatic setup](https://github.com/Effect-TS/tsgo/blob/main/docs/README.md).
+Add this command to the consuming project's root `package.json`:
+
+```json
+{
+  "scripts": {
+    "prepare": "effect-tsgo patch --oxlint"
+  }
+}
+```
+
+Merge the patch command into an existing `prepare` script with `&&`; retain its
+hooks, code generation and build tasks. Add it once at the repository root.
+Run `npm install` after editing the script. Future installs, including clean
+CI installs, run it automatically. Then run the project's normal strict
+TypeScript and Oxlint commands, including `oxlint --deny-warnings .`.
+
+This prepares both the TypeScript compiler and Oxlint. Do not use
+`--no-typescript` for a full Effect project. That option is only for an explicit
+Oxlint-only host which has no supported native TypeScript compiler; record that
+host constraint rather than making it the shared default. Do not use
+`--skip-missing` to hide missing tools or incompatible versions.
+
+For initial configuration, the installed `effect-tsgo setup` command can guide
+TypeScript, Oxlint and editor setup. Review its proposed changes against the
+project's existing strict rules and exact dependency versions. Keep the shared
+presets and all project-specific restrictions active.
+
+If a deliberate install or lint-package refresh uses `--ignore-scripts`, run
+`effect-tsgo patch --oxlint` explicitly after that operation and before checking
+code. An earlier successful prepare does not cover replaced binaries. Missing
+native setup causes a configuration error rather than silently losing checks.
+
+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:
@@ -74,8 +137,7 @@ 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 this release without selecting `style` leaves strict checks
-unchanged. This preset includes more than formatting preferences: Ultracite
+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.
@@ -107,6 +169,37 @@ size limits remain in each consumer's project policy.
 | `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
@@ -120,10 +213,14 @@ from the eleven shared overrides above:
 - 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 both supported hosts and compare
+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. These adjustments import no strict
-settings and leave every other upstream setting intact.
+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
 
@@ -144,7 +241,8 @@ 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 archive is checked on exactly 1.86.0 and the current 1.89.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
 
@@ -224,11 +322,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">;

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",

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";
@@ -1510,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 }),
@@ -2560,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.js

@@ -22,6 +22,26 @@ const style = {
         },
     ],
     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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonplaces/oxlint-plugin",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Shared Oxlint rules for strict Effect TypeScript, Alchemy and repository code.",
   "license": "MIT",
   "author": "Cooper Corbett",
@@ -72,8 +72,10 @@
     "prepack": "bun run build"
   },
   "dependencies": {
+    "@effect/tsgo": "0.55.0",
     "@oxlint/plugins": "1.89.0",
     "effect": "4.0.5",
+    "oxlint-tsgolint": "7.0.2004",
     "ultracite": "8.0.1"
   },
   "devDependencies": {
@@ -84,7 +86,7 @@
     "vitest": "5.0.5"
   },
   "peerDependencies": {
-    "oxlint": "1.86.0 || 1.89.0"
+    "oxlint": "1.87.0 || 1.88.0 || 1.89.0"
   },
   "engines": {
     "node": ">=22.14.0"