@commonplaces/oxlint-plugin 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cooper Corbett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,131 @@
-# Temporary Holding Version
+# @commonplaces/oxlint-plugin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+57 custom Oxlint rules for strict Effect TypeScript, Alchemy and general code
+checks. This package supports **Oxlint 1.80.0 or 1.85.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 either supported version.
+Both exact versions are checked with independently installed archives. ESLint is not a supported host.
+
+## Install
+
+Install from npm:
+
+```sh
+npm install --save-dev --save-exact @commonplaces/oxlint-plugin@0.1.1 oxlint@1.80.0
+```
+
+Create `oxlint.config.ts`:
+
+```ts
+import { defineConfig } from "oxlint";
+import { general, effect, alchemy } from "@commonplaces/oxlint-plugin";
+
+export default defineConfig({
+  extends: [general, effect, alchemy],
+});
+```
+
+Then run `npx oxlint .`. Choose only the groups that fit your project. `general`
+checks code style and package imports; `effect` checks Effect code; `alchemy`
+checks native Alchemy settings and secret sources. Each group turns its checks
+on as errors. They do not depend on one another. Override individual rules in
+your own `rules` or `overrides` settings.
+
+The root export contains these three configurations. Individual plugins use
+the subpaths below. For example, a JSON configuration can enable one rule:
+
+```json
+{
+  "jsPlugins": ["@commonplaces/oxlint-plugin/strict-effect"],
+  "rules": { "strict-effect/static-layers": "error" }
+}
+```
+
+## Project settings
+
+Rules that refer to project files, services, schemas or routes are available
+but excluded from the groups. Configure them explicitly, for example:
+
+```ts
+import { defineConfig } from "oxlint";
+import { general, effect } from "@commonplaces/oxlint-plugin";
+
+export default defineConfig({
+  extends: [general, effect],
+  rules: {
+    "effect/no-runtime-execution-outside-main": [
+      "error",
+      {
+        allowedFiles: ["apps/cli/src/main.ts"],
+      },
+    ],
+    "effect/require-service-operation-instrumentation": [
+      "error",
+      {
+        serviceNames: ["Orders"],
+      },
+    ],
+    "strict-effect/module-ownership": [
+      "error",
+      {
+        owners: [
+          {
+            module: "vendor-sdk",
+            allowedFiles: ["packages/orders/src/live.layer.ts"],
+            allowTypes: false,
+          },
+        ],
+      },
+    ],
+  },
+});
+```
+
+Use repository-relative paths with `/` separators. Runtime execution is denied
+everywhere unless `allowedFiles` grants an entry file. The service tracing rule
+requires `serviceNames` and checks names such as `Effect.fn("Orders.create")`.
+Invalid settings stop linting. Each rule's exported `meta.schema` describes its
+accepted options; no marketplace plugin is needed to read or run them.
+
+The portable Effect checks use the existing `strict-effect/` names, and the
+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.
+
+## Rule exports
+
+| Package subpath     | Rule prefix         | Rules |
+| ------------------- | ------------------- | ----: |
+| `/strict-effect`    | `strict-effect/`    |    27 |
+| `/effect`           | `effect/`           |     9 |
+| `/alchemy`          | `alchemy-secrets/`  |     3 |
+| `/bun`              | `bun/`              |     1 |
+| `/package`          | `package/`          |     1 |
+| `/anti-slop`        | `anti-slop/`        |    15 |
+| `/anti-slop-effect` | `anti-slop-effect/` |     1 |
+
+## Development
+
+This workspace owns the rule code. Skills provide guidance and installation
+instructions; they do not carry another copy of the rules. The package contains
+compiled JavaScript and declarations, the README and the MIT licence. It does
+not contain the private marketplace's skills, icons, source maps or tests.
+
+Run `bun run build:lint-plugin` from the repository root before linting. Root
+installation and lint/test commands do this automatically. Local consumers and
+npm consumers use the same compiled exports; there is no source-only export
+condition to hide packaging mistakes. Run `bun run test:lint-rules` for existing
+integration checks and `bun run test` for the archive installation
+and public contract checks.
+
+Oxlint owns synchronous rule callbacks and reporting. Pure checks use immutable
+Effect collections. The two synchronous option decoders in `effect.ts` are
+required by Oxlint's `create` callback and throw only for invalid configuration.
+The `syntax.ts` child adapter selects nodes from Oxlint's already parsed tree
+using its visitor keys; it is not a decoder for external JSON. Traversal cycle
+checks compare host nodes and variables by reference, never structural equality. Native nullable
+syntax fields stay at this host boundary. There is no Effect runtime, service
+or infrastructure stack inside the package.
+
+The strict Effect rules were adapted from Cooper's DAW rules at `e47ecfb` and
+subsequent Commonplace rules. The package's MIT licence covers this lint code.

package/dist/alchemy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@oxlint/plugins").Plugin;
+export default _default;

package/dist/alchemy.js

@@ -0,0 +1,196 @@
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+import * as Array from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+const variableInScope = (scope, name) => Array.findFirst((variable) => variable.name === name)(scope.variables).pipe(Option.orElse(() => Option.fromNullishOr(scope.upper).pipe(Option.flatMap((upper) => variableInScope(upper, name)))));
+const constant = (variable) => Array.head(variable.defs).pipe(Option.filter(() => variable.defs.length === 1), Option.filter(() => Array.every((reference) => !reference.isWrite() || reference.init)(variable.references)), Option.flatMap((definition) => definition.node.type === "VariableDeclarator" &&
+    definition.parent?.type === "VariableDeclaration" &&
+    definition.parent.kind === "const"
+    ? Option.some(definition.node)
+    : Option.none()));
+const propertyName = (node) => {
+    if (node.type === "Identifier")
+        return Option.some(node.name);
+    if (node.type === "Literal" && Predicate.isString(node.value))
+        return Option.some(node.value);
+    return Option.none();
+};
+const member = (reference, name) => {
+    if (Option.isSome(reference.name))
+        return Option.none();
+    return reference.module === "alchemy" ||
+        reference.module === "effect" ||
+        (reference.module === "effect/process" && name === "ChildProcess")
+        ? Option.some({ module: `${reference.module}/${name}`, name: Option.none() })
+        : Option.some({ ...reference, name: Option.some(name) });
+};
+// Only real imports and immutable local aliases count. The nearest declaration
+// prevents a shadowed parameter from borrowing an outer import's identity.
+const referenceOf = (context, node, visited = []) => {
+    if (Array.some(visited, (previous) => previous === node))
+        return Option.none();
+    const next = [...visited, node];
+    if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+        return referenceOf(context, node.expression, next);
+    }
+    if (node.type === "MemberExpression") {
+        const name = node.computed
+            ? node.property.type === "Literal"
+                ? propertyName(node.property)
+                : Option.none()
+            : propertyName(node.property);
+        return Option.all([referenceOf(context, node.object, next), name]).pipe(Option.flatMap(([reference, key]) => member(reference, key)));
+    }
+    if (node.type !== "Identifier")
+        return Option.none();
+    return variableInScope(context.sourceCode.getScope(node), node.name).pipe(Option.flatMap((variable) => Array.head(variable.defs).pipe(Option.flatMap((definition) => {
+        if (definition.type === "ImportBinding" &&
+            definition.parent?.type === "ImportDeclaration" &&
+            definition.parent.importKind !== "type") {
+            const module = definition.parent.source.value;
+            if (module !== "alchemy" &&
+                !module.startsWith("alchemy/") &&
+                module !== "effect" &&
+                !module.startsWith("effect/"))
+                return Option.none();
+            const reference = { module, name: Option.none() };
+            if (definition.node.type === "ImportNamespaceSpecifier")
+                return Option.some(reference);
+            if (definition.node.type === "ImportSpecifier" &&
+                definition.node.importKind !== "type") {
+                return propertyName(definition.node.imported).pipe(Option.flatMap((name) => member(reference, name)));
+            }
+            return Option.none();
+        }
+        return constant(variable).pipe(Option.flatMap((declaration) => Option.fromNullishOr(declaration.init).pipe(Option.flatMap((initialiser) => {
+            if (declaration.id.type === "Identifier") {
+                return referenceOf(context, initialiser, next);
+            }
+            if (declaration.id.type !== "ObjectPattern")
+                return Option.none();
+            return Array.findFirst((property) => property.type === "Property" &&
+                property.value.type === "Identifier" &&
+                property.value.name === node.name &&
+                !property.computed)(declaration.id.properties).pipe(Option.flatMap((property) => property.type === "Property"
+                ? Option.all([
+                    referenceOf(context, initialiser, next),
+                    propertyName(property.key),
+                ]).pipe(Option.flatMap(([reference, key]) => member(reference, key)))
+                : Option.none()));
+        }))));
+    }))));
+};
+const valueOf = (context, node, visited = []) => {
+    if (Array.some(visited, (previous) => previous === node))
+        return Option.none();
+    const next = [...visited, node];
+    if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+        return valueOf(context, node.expression, next);
+    }
+    if (node.type !== "Identifier")
+        return Option.some(node);
+    return variableInScope(context.sourceCode.getScope(node), node.name).pipe(Option.flatMap(constant), Option.filter((declaration) => declaration.id.type === "Identifier"), Option.flatMap((declaration) => Option.fromNullishOr(declaration.init)), Option.flatMap((initialiser) => valueOf(context, initialiser, next)));
+};
+const operation = (context, node, module, name) => referenceOf(context, node).pipe(Option.exists((reference) => (reference.module === module && Option.contains(reference.name, name)) ||
+    (reference.module === `${module}/${name}` && Option.isNone(reference.name))));
+const providerCall = (context, node, module, name) => valueOf(context, node).pipe(Option.filter((value) => value.type === "CallExpression"), Option.filter((value) => operation(context, value.callee, module, name)));
+const field = (node, name) => node.type === "ObjectExpression" &&
+    Array.every((property) => property.type === "Property" && property.kind === "init" && !property.computed)(node.properties)
+    ? Array.findLast((property) => property.type === "Property" && Option.contains(propertyName(property.key), name))(node.properties).pipe(Option.filter((property) => property.type === "Property"))
+    : Option.none();
+const shellDisabled = (context, node) => providerCall(context, node, "alchemy/Secrets", "ProcessEnv").pipe(Option.flatMap((call) => Array.head(call.arguments)), Option.flatMap((argument) => valueOf(context, argument)), Option.flatMap((options) => field(options, "disabled")), Option.flatMap((property) => valueOf(context, property.value)), Option.exists((disabled) => disabled.type === "Literal" && disabled.value === true));
+const nativeSources = defineRule({
+    meta: {
+        type: "problem",
+        schema: [],
+        messages: {
+            sources: "Use [Doppler.Secrets(...), Alchemy.Secrets.DotEnv(), Alchemy.Secrets.ProcessEnv({ disabled: true })] in every stage; .env overrides Doppler.",
+            shell: "Disable shell settings with Alchemy.Secrets.ProcessEnv({ disabled: true }); provider sign-in remains Alchemy's native responsibility.",
+        },
+    },
+    create(context) {
+        return {
+            ArrayExpression(node) {
+                const doppler = (element) => Option.isSome(providerCall(context, element, "alchemy/Doppler", "Secrets"));
+                if (!Array.some(node.elements, (element) => element !== null && doppler(element)))
+                    return;
+                const valid = node.elements.length === 3 &&
+                    Array.get(node.elements, 0).pipe(Option.flatMap(Option.fromNullishOr), Option.exists(doppler)) &&
+                    Array.get(node.elements, 1).pipe(Option.flatMap(Option.fromNullishOr), Option.exists((element) => Option.isSome(providerCall(context, element, "alchemy/Secrets", "DotEnv")))) &&
+                    Array.get(node.elements, 2).pipe(Option.flatMap(Option.fromNullishOr), Option.exists((element) => shellDisabled(context, element)));
+                if (!valid)
+                    context.report({ node, messageId: "sources" });
+            },
+            CallExpression(node) {
+                if (operation(context, node.callee, "alchemy/Secrets", "ProcessEnv") &&
+                    !shellDisabled(context, node)) {
+                    context.report({ node, messageId: "shell" });
+                }
+            },
+        };
+    },
+});
+const explicitStackSources = defineRule({
+    meta: {
+        type: "problem",
+        schema: [],
+        messages: {
+            stack: "Declare secrets explicitly on the native Stack using the shared checked provider list; omitted settings keep Alchemy's legacy shell/dotenv behaviour.",
+        },
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                // Zero-argument and name-only calls declare a Stack class, not a configured stack.
+                if (node.arguments.length < 2 || !operation(context, node.callee, "alchemy", "Stack"))
+                    return;
+                const explicit = Array.get(node.arguments, 1).pipe(Option.flatMap((argument) => valueOf(context, argument)), Option.flatMap((options) => field(options, "secrets")), Option.exists((property) => property.value.type !== "Literal" &&
+                    !(property.value.type === "Identifier" && property.value.name === "undefined") &&
+                    valueOf(context, property.value).pipe(Option.match({
+                        onNone: () => true,
+                        onSome: (value) => value.type !== "Literal" &&
+                            (value.type !== "ArrayExpression" || value.elements.length === 3),
+                    }))));
+                if (!explicit)
+                    context.report({ node, messageId: "stack" });
+            },
+        };
+    },
+});
+const commandText = (context, node) => valueOf(context, node).pipe(Option.flatMap((value) => value.type === "Literal" && Predicate.isString(value.value)
+    ? Option.some(value.value)
+    : Option.none()));
+const noDopplerWrapper = defineRule({
+    meta: {
+        type: "problem",
+        schema: [],
+        messages: {
+            wrapper: "Run the native Alchemy CLI with its declared secrets; remove Doppler CLI injection from this command.",
+        },
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!operation(context, node.callee, "effect/process/ChildProcess", "make"))
+                    return;
+                const command = Array.head(node.arguments).pipe(Option.flatMap((argument) => commandText(context, argument)));
+                const argumentsList = Array.get(node.arguments, 1).pipe(Option.flatMap((argument) => valueOf(context, argument)), Option.filter((argument) => argument.type === "ArrayExpression"));
+                const direct = Option.exists(command, (text) => /(?:^|\/)doppler$/u.test(text)) &&
+                    argumentsList.pipe(Option.flatMap((argumentsNode) => Array.head(argumentsNode.elements)), Option.flatMap(Option.fromNullishOr), Option.flatMap((argument) => commandText(context, argument)), Option.contains("run"));
+                const shell = Option.exists(command, (text) => /(?:^|\/)(?:sh|bash|zsh)$/u.test(text)) &&
+                    Option.exists(argumentsList, (argumentsNode) => Array.some(argumentsNode.elements, (argument) => argument !== null &&
+                        Option.exists(commandText(context, argument), (text) => /(?:^|[\s;|&])doppler\s+run(?:\s|$)/u.test(text))));
+                if (direct || shell)
+                    context.report({ node, messageId: "wrapper" });
+            },
+        };
+    },
+});
+export default eslintCompatPlugin({
+    meta: { name: "alchemy-secrets" },
+    rules: {
+        "native-sources": nativeSources,
+        "explicit-stack-sources": explicitStackSources,
+        "no-doppler-wrapper": noDopplerWrapper,
+    },
+});

package/dist/anti-slop/effect/index.d.ts

@@ -0,0 +1,3 @@
+/** Opt-in Oxlint rules for Effect service and Layer architecture. */
+declare const antiSlopEffectPlugin: import("@oxlint/plugins").Plugin;
+export default antiSlopEffectPlugin;

package/dist/anti-slop/effect/index.js

@@ -0,0 +1,10 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { noServiceConstructorImportsRule } from "./rules/no-service-constructor-imports.js";
+/** Opt-in Oxlint rules for Effect service and Layer architecture. */
+const antiSlopEffectPlugin = eslintCompatPlugin({
+    meta: { name: "anti-slop-effect" },
+    rules: {
+        "no-service-constructor-imports": noServiceConstructorImportsRule,
+    },
+});
+export default antiSlopEffectPlugin;

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

@@ -0,0 +1,2 @@
+/** Keep dependency-bearing Effect service constructors local to their owning capability modules. */
+export declare const noServiceConstructorImportsRule: import("@oxlint/plugins").Rule;

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

@@ -0,0 +1,45 @@
+import { Array } from "effect";
+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;
+                Array.forEach(node.specifiers, (specifier) => {
+                    if (specifier.type !== "ImportSpecifier")
+                        return;
+                    const importedName = getImportedName(specifier);
+                    if (!SERVICE_CONSTRUCTOR_NAME.test(importedName))
+                        return;
+                    context.report({
+                        node: specifier,
+                        messageId: "serviceConstructorImport",
+                        data: { name: importedName },
+                    });
+                });
+            },
+        };
+    },
+});

package/dist/anti-slop/index.d.ts

@@ -0,0 +1,3 @@
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+declare const antiSlopPlugin: import("@oxlint/plugins").Plugin;
+export default antiSlopPlugin;

package/dist/anti-slop/index.js

@@ -0,0 +1,38 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.js";
+import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.js";
+import { noKnownValueWideningRule } from "./rules/no-known-value-widening.js";
+import { noModuleMockingRule } from "./rules/no-module-mocking.js";
+import { noObjectParametersRule } from "./rules/no-object-parameters.js";
+import { noReflectApplyRule } from "./rules/no-reflect-apply.js";
+import { noReflectGetRule } from "./rules/no-reflect-get.js";
+import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.js";
+import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.js";
+import { noUnknownParametersRule } from "./rules/no-unknown-parameters.js";
+import { noUnknownReturnsRule } from "./rules/no-unknown-returns.js";
+import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.js";
+import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.js";
+import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.js";
+import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.js";
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+const antiSlopPlugin = eslintCompatPlugin({
+    meta: { name: "anti-slop" },
+    rules: {
+        "no-chained-type-assertions": noChainedTypeAssertionsRule,
+        "no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+        "no-known-value-widening": noKnownValueWideningRule,
+        "no-module-mocking": noModuleMockingRule,
+        "no-object-parameters": noObjectParametersRule,
+        "no-reflect-apply": noReflectApplyRule,
+        "no-reflect-get": noReflectGetRule,
+        "no-runtime-typeof": noRuntimeTypeofRule,
+        "no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+        "no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+        "no-unknown-parameters": noUnknownParametersRule,
+        "no-unknown-returns": noUnknownReturnsRule,
+        "no-unknown-type-aliases": noUnknownTypeAliasesRule,
+        "no-widen-then-assert": noWidenThenAssertRule,
+        "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+    },
+});
+export default antiSlopPlugin;

package/dist/anti-slop/rules/no-chained-type-assertions.d.ts

@@ -0,0 +1,2 @@
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export declare const noChainedTypeAssertionsRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-chained-type-assertions.js

@@ -0,0 +1,57 @@
+import { Array } from "effect";
+import { defineRule } from "@oxlint/plugins";
+function isTypeAssertionExpression(node) {
+    return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+function unwrapParenthesizedExpression(expression) {
+    return expression.type === "ParenthesizedExpression"
+        ? unwrapParenthesizedExpression(expression.expression)
+        : expression;
+}
+function isConstAssertion(node) {
+    const { typeAnnotation } = node;
+    return (typeAnnotation.type === "TSTypeReference" &&
+        typeAnnotation.typeName.type === "Identifier" &&
+        typeAnnotation.typeName.name === "const");
+}
+function outsideParentheses(node) {
+    return node.parent.type === "ParenthesizedExpression" && node.parent.expression === node
+        ? outsideParentheses(node.parent)
+        : node;
+}
+function isOutermostAssertionInChain(node) {
+    const current = outsideParentheses(node);
+    return !isTypeAssertionExpression(current.parent) || current.parent.expression !== current;
+}
+function assertionChain(node) {
+    return isTypeAssertionExpression(node)
+        ? [node, ...assertionChain(unwrapParenthesizedExpression(node.expression))]
+        : [];
+}
+function isForbiddenAssertionChain(node) {
+    const chain = assertionChain(node);
+    return chain.length > 1 && Array.some(chain, (assertion) => !isConstAssertion(assertion));
+}
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export const noChainedTypeAssertionsRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
+        },
+        messages: {
+            chained: "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it.",
+        },
+    },
+    createOnce(context) {
+        const checkTypeAssertion = (node) => {
+            if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node))
+                return;
+            context.report({ node, messageId: "chained" });
+        };
+        return {
+            TSAsExpression: checkTypeAssertion,
+            TSTypeAssertion: checkTypeAssertion,
+        };
+    },
+});

package/dist/anti-slop/rules/no-conditional-empty-object-spread.d.ts

@@ -0,0 +1,2 @@
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export declare const noConditionalEmptyObjectSpreadRule: import("@oxlint/plugins").Rule;

package/dist/anti-slop/rules/no-conditional-empty-object-spread.js

@@ -0,0 +1,36 @@
+import { defineRule } from "@oxlint/plugins";
+function unwrapParentheses(node) {
+    return node.type === "ParenthesizedExpression" ? unwrapParentheses(node.expression) : node;
+}
+function isEmptyObjectExpression(node) {
+    return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function isConditionalEmptyObjectSpread(node) {
+    const conditional = unwrapParentheses(node);
+    return (conditional.type === "ConditionalExpression" &&
+        (isEmptyObjectExpression(conditional.consequent) ||
+            isEmptyObjectExpression(conditional.alternate)));
+}
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export const noConditionalEmptyObjectSpreadRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Disallow object spreads that conditionally spread an empty object to omit fields.",
+        },
+        messages: {
+            avoid: "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
+        },
+    },
+    createOnce(context) {
+        return {
+            SpreadElement(node) {
+                if (node.parent.type !== "ObjectExpression")
+                    return;
+                if (isConditionalEmptyObjectSpread(node.argument)) {
+                    context.report({ node, messageId: "avoid" });
+                }
+            },
+        };
+    },
+});

package/dist/anti-slop/rules/no-known-value-widening.d.ts

@@ -0,0 +1,2 @@
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+export declare const noKnownValueWideningRule: import("@oxlint/plugins").Rule;