@commonplaces/oxlint-plugin 0.3.1 → 0.4.0

package/dist/conventions/ownership.js

@@ -0,0 +1,86 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Option, Schema } from "effect";
+import { operation } from "../native-reference.js";
+import { propertyName } from "../syntax.js";
+const Paths = Schema.Array(Schema.NonEmptyString);
+const BrowserOptions = Schema.Struct({ runtimeOwners: Paths, registryOwners: Paths });
+const ClientOptions = Schema.Struct({ browserOwners: Paths, serverOwners: Paths });
+const pathsSchema = {
+    type: "array",
+    items: { type: "string", minLength: 1 },
+    uniqueItems: true,
+};
+const owns = (context, paths) => {
+    const filename = context.filename.replaceAll("\\", "/");
+    const cwd = context.cwd.replaceAll("\\", "/").replace(/\/$/u, "");
+    return Array.some(paths, (path) => filename === `${cwd}/${path}`);
+};
+export const browserRuntimeOwnership = defineRule({
+    meta: {
+        type: "problem",
+        schema: [
+            {
+                type: "object",
+                properties: { runtimeOwners: pathsSchema, registryOwners: pathsSchema },
+                required: ["runtimeOwners", "registryOwners"],
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            runtime: "Construct Atom.runtime only in its configured runtime owners.",
+            registry: "Mount RegistryProvider only in its configured registry owner.",
+        },
+    },
+    create(context) {
+        // Oxlint owns synchronous option validation; malformed permissions fail closed.
+        const options = Array.head(context.options).pipe(Option.flatMap(Schema.decodeUnknownOption(BrowserOptions)), Option.getOrElse(() => ({ runtimeOwners: [], registryOwners: [] })));
+        return {
+            CallExpression(node) {
+                if (operation(context, node.callee, "effect/reactivity/Atom", "runtime") &&
+                    !owns(context, options.runtimeOwners))
+                    context.report({ node, messageId: "runtime" });
+            },
+            ImportDeclaration(node) {
+                if (node.importKind === "type" ||
+                    !node.source.value.startsWith("@effect/atom-react") ||
+                    owns(context, options.registryOwners))
+                    return;
+                if (Array.some(node.specifiers, (specifier) => specifier.type === "ImportNamespaceSpecifier" ||
+                    (specifier.type === "ImportSpecifier" &&
+                        specifier.importKind !== "type" &&
+                        Option.contains(propertyName(specifier.imported), "RegistryProvider"))))
+                    context.report({ node, messageId: "registry" });
+            },
+        };
+    },
+});
+export const nativeHttpClientOwnership = defineRule({
+    meta: {
+        type: "problem",
+        schema: [
+            {
+                type: "object",
+                properties: { browserOwners: pathsSchema, serverOwners: pathsSchema },
+                required: ["browserOwners", "serverOwners"],
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            browser: "Construct AtomHttpApi.Service only in its configured browser owner.",
+            server: "Construct HttpApiClient only in its configured binding adapter or response tests.",
+        },
+    },
+    create(context) {
+        const options = Array.head(context.options).pipe(Option.flatMap(Schema.decodeUnknownOption(ClientOptions)), Option.getOrElse(() => ({ browserOwners: [], serverOwners: [] })));
+        return {
+            CallExpression(node) {
+                if (operation(context, node.callee, "effect/reactivity/AtomHttpApi", "Service") &&
+                    !owns(context, options.browserOwners))
+                    context.report({ node, messageId: "browser" });
+                if (Array.some(["make", "makeWith"], (method) => operation(context, node.callee, "effect/http-api/HttpApiClient", method)) &&
+                    !owns(context, options.serverOwners))
+                    context.report({ node, messageId: "server" });
+            },
+        };
+    },
+});

package/dist/conventions/shared.d.ts

@@ -0,0 +1,11 @@
+import type { Context, ESTree, Visitor } from "@oxlint/plugins";
+import { Option } from "effect";
+export declare const rule: (message: string, create: (context: Context) => Visitor) => import("@oxlint/plugins").Rule;
+export declare const report: (context: Context, node: ESTree.Node) => void;
+export declare const testFile: (filename: string) => boolean;
+export declare const isFunction: (node: ESTree.Node) => node is ESTree.ArrowFunctionExpression | ESTree.Function;
+export declare const contains: (context: Context, node: ESTree.Node, accepts: (node: ESTree.Node) => boolean) => boolean;
+export declare const memberName: (context: Context, node: ESTree.Node, module: string) => Option.Option<string>;
+export declare const returns: (node: ESTree.Node) => readonly ESTree.Node[];
+export declare const effectCallback: (context: Context, node: ESTree.CallExpression) => Option.Option<ESTree.ArrowFunctionExpression | ESTree.Function>;
+export declare const plainStringSchema: (context: Context, node: ESTree.Node, seen?: readonly ESTree.Node[]) => boolean;

package/dist/conventions/shared.js

@@ -0,0 +1,54 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Option } from "effect";
+import { childNodes, propertyName } from "../syntax.js";
+import { referenceOf, valueOf } from "../native-reference.js";
+export const rule = (message, create) => defineRule({ meta: { type: "problem", schema: [], messages: { policy: message } }, create });
+export const report = (context, node) => context.report({ node, messageId: "policy" });
+export const testFile = (filename) => /(?:\.(?:test|spec)\.[cm]?[jt]sx?$|\/(?:test|tests|testing)\/)/u.test(filename.replaceAll("\\", "/"));
+export const isFunction = (node) => node.type === "ArrowFunctionExpression" ||
+    node.type === "FunctionExpression" ||
+    node.type === "FunctionDeclaration";
+export const contains = (context, node, accepts) => accepts(node) ||
+    Array.some(childNodes(context, node), (child) => contains(context, child, accepts));
+export const memberName = (context, node, module) => referenceOf(context, node).pipe(Option.filter((reference) => reference.module === module), Option.flatMap((reference) => reference.name));
+export const returns = (node) => {
+    if (!isFunction(node) || node.body === null)
+        return [];
+    if (node.body.type !== "BlockStatement")
+        return [node.body];
+    return Array.flatMap(node.body.body, (statement) => statement.type === "ReturnStatement"
+        ? Option.toArray(Option.fromNullishOr(statement.argument))
+        : []);
+};
+export const effectCallback = (context, node) => {
+    const callee = node.callee.type === "CallExpression" ? node.callee.callee : node.callee;
+    const method = memberName(context, callee, "effect/Effect");
+    if (!Option.exists(method, (name) => name === "fn" || name === "fnUntraced"))
+        return Option.none();
+    return Array.head(node.arguments).pipe(Option.filter(isFunction));
+};
+// Brand discovery follows the Schema expression itself, never an unrelated
+// callback's nested brand or a same-named, shadowed local object.
+export const plainStringSchema = (context, node, seen = []) => {
+    if (Array.some(seen, (previous) => previous === node))
+        return false;
+    const next = [...seen, node];
+    const resolved = valueOf(context, node);
+    if (Option.isSome(resolved) && resolved.value !== node)
+        return plainStringSchema(context, resolved.value, next);
+    if (Option.exists(memberName(context, node, "effect/Schema"), (name) => name === "String" || name === "Trimmed"))
+        return true;
+    if (node.type !== "CallExpression")
+        return false;
+    const method = memberName(context, node.callee, "effect/Schema");
+    if (Option.exists(method, (name) => name === "Array" || name === "Option" || name === "optional" || name === "optionalKey")) {
+        return Array.head(node.arguments).pipe(Option.exists((argument) => plainStringSchema(context, argument, next)));
+    }
+    if (node.callee.type !== "MemberExpression")
+        return false;
+    if (!Option.exists(propertyName(node.callee.property), (name) => name === "pipe" || name === "check" || name === "make"))
+        return false;
+    const branded = Array.some(node.arguments, (argument) => argument.type === "CallExpression" &&
+        Option.contains(memberName(context, argument.callee, "effect/Schema"), "brand"));
+    return !branded && plainStringSchema(context, node.callee.object, next);
+};

package/dist/conventions/syntax.d.ts

@@ -0,0 +1,14 @@
+export declare const syntaxRules: {
+    "no-conditional-object-spread": import("@oxlint/plugins").Rule;
+    "no-in-operator": import("@oxlint/plugins").Rule;
+    "no-nullish-comparison": import("@oxlint/plugins").Rule;
+    "no-native-collections": import("@oxlint/plugins").Rule;
+    "curried-collections": import("@oxlint/plugins").Rule;
+    "no-wrapper-composition": import("@oxlint/plugins").Rule;
+    "no-nullable-boundary-leak": import("@oxlint/plugins").Rule;
+    "no-primitive-failure": import("@oxlint/plugins").Rule;
+    "require-try-promise-catch": import("@oxlint/plugins").Rule;
+    "no-defecting-layer": import("@oxlint/plugins").Rule;
+    "named-effect-operations": import("@oxlint/plugins").Rule;
+    "object-operation-input": import("@oxlint/plugins").Rule;
+};

package/dist/conventions/syntax.js

@@ -0,0 +1,172 @@
+import { Array, Option } from "effect";
+import { propertyName } from "../syntax.js";
+import { operation } from "../native-reference.js";
+import { effectCallback, isFunction, memberName, report, returns, rule, testFile, } from "./shared.js";
+const primitive = (node) => node.type === "Literal" ||
+    (node.type === "Identifier" && node.name === "undefined") ||
+    (node.type === "TemplateLiteral" && node.expressions.length === 0) ||
+    (node.type === "UnaryExpression" && Array.contains(["void", "-", "+", "!"], node.operator));
+export const syntaxRules = {
+    "no-conditional-object-spread": rule("Use Schema-owned optional fields instead of conditional object spreads.", (context) => ({
+        SpreadElement(node) {
+            if (node.parent.type === "ObjectExpression" &&
+                (node.argument.type === "ConditionalExpression" ||
+                    node.argument.type === "LogicalExpression"))
+                report(context, node);
+        },
+    })),
+    "no-in-operator": rule("Use Schema or Effect Record/HashMap operations instead of probing keys with in.", (context) => ({
+        BinaryExpression(node) {
+            if (node.operator === "in")
+                report(context, node);
+        },
+    })),
+    "no-nullish-comparison": rule("Keep absence as Option and use its matching operations.", (context) => ({
+        BinaryExpression(node) {
+            if (Array.contains(["===", "!==", "==", "!="], node.operator) &&
+                Array.some([node.left, node.right], (side) => (side.type === "Literal" && side.value === null) ||
+                    (side.type === "Identifier" && side.name === "undefined")))
+                report(context, node);
+        },
+    })),
+    "no-native-collections": rule("Use immutable Effect HashMap and HashSet instead of native mutable collections.", (context) => ({
+        NewExpression(node) {
+            if (node.callee.type === "Identifier" &&
+                Array.contains(["Map", "Set", "WeakMap", "WeakSet"], node.callee.name))
+                report(context, node);
+        },
+    })),
+    "curried-collections": rule("Use curried Effect collection operations so transformations remain pipeable.", (context) => ({
+        CallExpression(node) {
+            if (node.arguments.length < 2)
+                return;
+            if (Array.some(["Array", "Chunk", "HashMap", "HashSet", "Option", "Record"], (module) => memberName(context, node.callee, `effect/${module}`).pipe(Option.exists((name) => Array.contains([
+                "every",
+                "filter",
+                "findFirst",
+                "flatMap",
+                "forEach",
+                "map",
+                "partition",
+                "reduce",
+                "some",
+                "sort",
+            ], name)))))
+                report(context, node);
+        },
+    })),
+    "no-wrapper-composition": rule("Use a pipe for sequential transformations and keep one-use mapper callbacks inline.", (context) => ({
+        CallExpression(node) {
+            if (node.callee.type === "Identifier" &&
+                Array.some(node.arguments, (argument) => argument.type === "CallExpression"))
+                report(context, node);
+            const mapper = Option.exists(memberName(context, node.callee, "effect/Effect"), (name) => name === "map" || name === "mapError") ||
+                Option.exists(memberName(context, node.callee, "effect/rpc/Rpc"), (name) => name === "map" || name === "mapError") ||
+                Option.exists(memberName(context, node.callee, "effect/Schema"), (name) => /^(?:decode|encode)/u.test(name));
+            if (mapper)
+                Array.forEach(node.arguments, (argument) => {
+                    if (argument.type === "Identifier" &&
+                        /^(?:map|to|decode|encode|normalize)[A-Z]\w*$/u.test(argument.name))
+                        report(context, argument);
+                });
+        },
+    })),
+    "no-nullable-boundary-leak": rule("Keep internal absence as Option; confine null to an owning external codec.", (context) => testFile(context.filename)
+        ? {}
+        : {
+            CallExpression(node) {
+                if (operation(context, node.callee, "effect/Option", "getOrNull") ||
+                    operation(context, node.callee, "effect/Schema", "NullOr"))
+                    report(context, node);
+            },
+            Property(node) {
+                if (node.value.type === "Literal" && node.value.value === null)
+                    report(context, node.value);
+            },
+        }),
+    "no-primitive-failure": rule("Use an owner-named tagged error instead of a primitive Effect failure.", (context) => ({
+        CallExpression(node) {
+            const method = memberName(context, node.callee, "effect/Effect");
+            const argument = Array.head(node.arguments);
+            if (Option.isNone(argument))
+                return;
+            if ((Option.contains(method, "fail") && primitive(argument.value)) ||
+                (Option.exists(method, (name) => name === "failSync" || name === "mapError") &&
+                    Array.some(returns(argument.value), primitive)))
+                report(context, node);
+        },
+    })),
+    "require-try-promise-catch": rule("Map Promise rejection explicitly with Effect.tryPromise({ try, catch }).", (context) => ({
+        CallExpression(node) {
+            if (!operation(context, node.callee, "effect/Effect", "tryPromise"))
+                return;
+            const argument = Array.head(node.arguments);
+            if (Option.isNone(argument) ||
+                argument.value.type !== "ObjectExpression" ||
+                !Array.every(["try", "catch"], (name) => argument.value.type === "ObjectExpression" &&
+                    Array.some(argument.value.properties, (property) => property.type === "Property" && Option.contains(propertyName(property.key), name))))
+                report(context, node);
+        },
+    })),
+    "no-defecting-layer": rule("Preserve typed Layer construction failures instead of Layer.orDie.", (context) => ({
+        CallExpression(node) {
+            if (operation(context, node.callee, "effect/Layer", "orDie"))
+                report(context, node);
+        },
+    })),
+    "named-effect-operations": rule("Name reusable operations with Effect.fn or Effect.fnUntraced rather than returning Effect.gen from a plain function.", (context) => ({
+        VariableDeclarator(node) {
+            if (node.init &&
+                isFunction(node.init) &&
+                Array.some(returns(node.init), (value) => value.type === "CallExpression" &&
+                    operation(context, value.callee, "effect/Effect", "gen")))
+                report(context, node.id);
+        },
+        ExportNamedDeclaration(node) {
+            if (node.declaration?.type === "FunctionDeclaration" &&
+                Array.some(returns(node.declaration), (value) => value.type === "CallExpression" &&
+                    operation(context, value.callee, "effect/Effect", "gen")))
+                report(context, node.declaration);
+        },
+    })),
+    "object-operation-input": rule("Reusable Effect operations accept no arguments or one Schema-owned object input.", (context) => ({
+        ExportNamedDeclaration(node) {
+            if (!/(?:^|\/)actors\/[^/]+-(?:state|recovery)\.ts$/u.test(context.filename))
+                return;
+            const declaration = node.declaration;
+            if (declaration?.type === "FunctionDeclaration" && declaration.params.length > 1)
+                report(context, declaration);
+            if (declaration?.type === "VariableDeclaration")
+                Array.forEach(declaration.declarations, (value) => {
+                    if (value.init && isFunction(value.init) && value.init.params.length > 1)
+                        report(context, value.id);
+                });
+        },
+        CallExpression(node) {
+            effectCallback(context, node).pipe(Option.map((callback) => {
+                const parameter = Array.head(callback.params);
+                const type = parameter.pipe(Option.flatMap((value) => value.type === "TSParameterProperty"
+                    ? Option.none()
+                    : Option.fromNullishOr(value.typeAnnotation?.typeAnnotation)));
+                if (callback.params.length > 1 ||
+                    parameter.pipe(Option.exists((value) => value.type === "RestElement")) ||
+                    type.pipe(Option.exists((value) => Array.contains([
+                        "TSArrayType",
+                        "TSBigIntKeyword",
+                        "TSBooleanKeyword",
+                        "TSFunctionType",
+                        "TSLiteralType",
+                        "TSNeverKeyword",
+                        "TSNullKeyword",
+                        "TSNumberKeyword",
+                        "TSStringKeyword",
+                        "TSSymbolKeyword",
+                        "TSTupleType",
+                        "TSUndefinedKeyword",
+                        "TSVoidKeyword",
+                    ], value.type))))
+                    report(context, node);
+            }));
+        },
+    })),
+};

package/dist/conventions.d.ts

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

package/dist/conventions.js

@@ -0,0 +1,19 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { syntaxRules } from "./conventions/syntax.js";
+import { contractRules } from "./conventions/contracts.js";
+import { codecRules } from "./conventions/codecs.js";
+import { lifetimeRules } from "./conventions/lifetimes.js";
+import { browserRuntimeOwnership, nativeHttpClientOwnership } from "./conventions/ownership.js";
+import { boundedBuildMemo } from "./conventions/bounded-build-memo.js";
+export default eslintCompatPlugin({
+    meta: { name: "effect-conventions" },
+    rules: {
+        ...syntaxRules,
+        ...contractRules,
+        ...codecRules,
+        ...lifetimeRules,
+        "browser-runtime-ownership": browserRuntimeOwnership,
+        "native-http-client-ownership": nativeHttpClientOwnership,
+        "bounded-build-memo": boundedBuildMemo,
+    },
+});

package/dist/effect.js

@@ -1,6 +1,7 @@
+import { requireServiceOperationInstrumentation } from "./service-instrumentation.js";
 import { defineRule } from "@oxlint/plugins";
-import { Array, Option, Predicate, Schema } from "effect";
-import { childNodes, propertyName, variableInScope } from "./syntax.js";
+import { Array, Option, Schema } from "effect";
+import { propertyName } from "./syntax.js";
 const memberExpressionName = (node) => {
     if (node?.type !== "MemberExpression" || node.object?.type !== "Identifier") {
         return Option.none();
@@ -215,7 +216,6 @@ const noManualTag = defineRule({
     },
 });
 const RuntimeOptions = Schema.Struct({ allowedFiles: Schema.Array(Schema.String) });
-const ServiceOptions = Schema.Struct({ serviceNames: Schema.Array(Schema.String) });
 const noRuntimeExecutionOutsideMain = defineRule({
     meta: {
         type: "problem",
@@ -253,89 +253,6 @@ const noRuntimeExecutionOutsideMain = defineRule({
         };
     },
 });
-const instrumentationName = (node) => {
-    if (node.type !== "CallExpression" ||
-        node.callee.type !== "MemberExpression" ||
-        node.callee.object.type !== "Identifier" ||
-        node.callee.object.name !== "Effect" ||
-        !Option.exists(propertyName(node.callee.property), (name) => Array.contains(["fn", "withSpan"], name)))
-        return Option.none();
-    return Array.head(node.arguments).pipe(Option.flatMap((argument) => argument.type === "Literal" && Predicate.isString(argument.value)
-        ? Option.some(argument.value)
-        : Option.none()));
-};
-const containsInstrumentation = (context, node, name) => Option.contains(instrumentationName(node), name) ||
-    Array.some(childNodes(context, node), (child) => containsInstrumentation(context, child, name));
-const operationValue = (context, node) => {
-    if (node.type !== "Identifier")
-        return Option.some(node);
-    return variableInScope(context.sourceCode.getScope(node), node.name).pipe(Option.flatMap((variable) => Array.head(variable.defs)), Option.flatMap((definition) => definition.node.type === "VariableDeclarator"
-        ? Option.fromNullishOr(definition.node.init)
-        : Option.none()));
-};
-const requireServiceOperationInstrumentation = defineRule({
-    meta: {
-        type: "problem",
-        schema: [
-            {
-                type: "object",
-                properties: { serviceNames: { type: "array", items: { type: "string", minLength: 1 } } },
-                required: ["serviceNames"],
-                additionalProperties: false,
-            },
-        ],
-        docs: {
-            description: "Require exact tracing names on configured public Effect service operations.",
-        },
-        messages: {
-            missingInstrumentation: "Instrument {{operation}} with Effect.fn or Effect.withSpan using that exact name.",
-            unsupportedOperation: "Declare public Effect service operations as named object properties so tracing can be checked.",
-        },
-    },
-    create(context) {
-        // Oxlint requires a synchronous create callback; invalid options stop linting.
-        const options = Schema.decodeUnknownSync(ServiceOptions)(Option.getOrUndefined(Array.head(context.options)));
-        return {
-            CallExpression(node) {
-                if (node.callee.type !== "MemberExpression" ||
-                    node.callee.object.type !== "Identifier" ||
-                    !Array.contains(options.serviceNames, node.callee.object.name) ||
-                    !Option.contains(propertyName(node.callee.property), "of"))
-                    return;
-                const service = node.callee.object.name;
-                const operations = Array.head(node.arguments);
-                Option.match(operations, {
-                    onNone: () => { },
-                    onSome: (argument) => {
-                        if (argument.type !== "ObjectExpression")
-                            return;
-                        Array.forEach(argument.properties, (operation) => {
-                            if (operation.type !== "Property") {
-                                context.report({ messageId: "unsupportedOperation", node: operation });
-                                return;
-                            }
-                            Option.match(propertyName(operation.key), {
-                                onNone: () => {
-                                    context.report({ messageId: "unsupportedOperation", node: operation });
-                                },
-                                onSome: (name) => {
-                                    const fullName = `${service}.${name}`;
-                                    if (!Option.exists(operationValue(context, operation.value), (value) => containsInstrumentation(context, value, fullName))) {
-                                        context.report({
-                                            messageId: "missingInstrumentation",
-                                            data: { operation: fullName },
-                                            node: operation,
-                                        });
-                                    }
-                                },
-                            });
-                        });
-                    },
-                });
-            },
-        };
-    },
-});
 export default {
     meta: { name: "effect" },
     rules: {

package/dist/index.d.ts

@@ -30,6 +30,7 @@ export declare const effect: {
         "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";
@@ -47,6 +48,41 @@ export declare const effect: {
         "anti-slop-effect/no-service-constructor-imports": "error";
     };
 };
+/** Optional strict coding conventions; boundary permissions remain project facts. */
+export declare const conventions: {
+    jsPlugins: string[];
+    rules: Record<`effect-conventions/${string}`, "error">;
+};
+/** Optional React/TanStack, MDX, semantic typography and route conventions. */
+export declare const web: {
+    plugins: ("jsx-a11y" | "react" | "react-perf")[];
+    jsPlugins: string[];
+    rules: Record<`web/${string}`, "error">;
+};
+/** Native type-aware checks. Run Oxlint with --type-aware. */
+export declare const typescript: {
+    plugins: ("import" | "typescript" | "unicorn" | "vitest")[];
+    categories: {
+        correctness: "error";
+    };
+    rules: {
+        "no-ternary": "error";
+        "typescript/consistent-type-assertions": ["error", {
+            assertionStyle: "never";
+        }];
+        "typescript/no-explicit-any": "error";
+        "typescript/no-non-null-assertion": "error";
+        "typescript/await-thenable": "error";
+        "typescript/no-floating-promises": "error";
+        "typescript/no-misused-promises": "error";
+        "typescript/no-unsafe-argument": "error";
+        "typescript/no-unsafe-assignment": "error";
+        "typescript/no-unsafe-call": "error";
+        "typescript/no-unsafe-member-access": "error";
+        "typescript/no-unsafe-return": "error";
+        "typescript/no-unsafe-type-assertion": "error";
+    };
+};
 /** Native Alchemy configuration and secret-source checks. */
 export declare const alchemy: {
     jsPlugins: string[];
@@ -57,3 +93,90 @@ export declare const alchemy: {
         "strict-effect/native-cloudflare-cache": "error";
     };
 };
+/** Complete strict Effect application profile; exact project owners stay local. */
+export declare const strict: {
+    extends: ({
+        jsPlugins: string[];
+        rules: {
+            "anti-slop/no-chained-type-assertions": "error";
+            "anti-slop/no-conditional-empty-object-spread": "error";
+            "anti-slop/no-known-value-widening": "error";
+            "anti-slop/no-module-mocking": "error";
+            "anti-slop/no-object-parameters": "error";
+            "anti-slop/no-reflect-apply": "error";
+            "anti-slop/no-reflect-get": "error";
+            "anti-slop/no-runtime-typeof": "error";
+            "anti-slop/no-shape-in-symbol-names": "error";
+            "anti-slop/no-unknown-parameters": "error";
+            "anti-slop/no-unknown-returns": "error";
+            "anti-slop/no-unknown-type-aliases": "error";
+            "anti-slop/no-unsafe-dictionary-type": "error";
+            "anti-slop/no-widen-then-assert": "error";
+            "anti-slop/require-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">;
+    } | {
+        plugins: ("jsx-a11y" | "react" | "react-perf")[];
+        jsPlugins: string[];
+        rules: Record<`web/${string}`, "error">;
+    } | {
+        plugins: ("import" | "typescript" | "unicorn" | "vitest")[];
+        categories: {
+            correctness: "error";
+        };
+        rules: {
+            "no-ternary": "error";
+            "typescript/consistent-type-assertions": ["error", {
+                assertionStyle: "never";
+            }];
+            "typescript/no-explicit-any": "error";
+            "typescript/no-non-null-assertion": "error";
+            "typescript/await-thenable": "error";
+            "typescript/no-floating-promises": "error";
+            "typescript/no-misused-promises": "error";
+            "typescript/no-unsafe-argument": "error";
+            "typescript/no-unsafe-assignment": "error";
+            "typescript/no-unsafe-call": "error";
+            "typescript/no-unsafe-member-access": "error";
+            "typescript/no-unsafe-return": "error";
+            "typescript/no-unsafe-type-assertion": "error";
+        };
+    } | {
+        jsPlugins: string[];
+        rules: {
+            "alchemy-secrets/native-sources": "error";
+            "alchemy-secrets/explicit-stack-sources": "error";
+            "alchemy-secrets/no-doppler-wrapper": "error";
+            "strict-effect/native-cloudflare-cache": "error";
+        };
+    })[];
+};