@doubleloop-io/oxlint-plugin-effect 0.0.0-stage → 0.1.0-rc.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export declare const pluginName = "dl-effect";
+export declare const pluginPath: string;
+declare const dlEffectPlugin: import("@oxlint/plugins").Plugin;
+export default dlEffectPlugin;

package/dist/index.js

@@ -0,0 +1,71 @@
+import { fileURLToPath } from "node:url";
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { adapterImportBoundaryRule } from "./rules/adapter-import-boundary.js";
+import { antiSlopNoManualEffectErrorTagRule } from "./rules/anti-slop-no-manual-effect-error-tag.js";
+import { antiSlopNoServiceConstructorImportsRule } from "./rules/anti-slop-no-service-constructor-imports.js";
+import { antiSlopPreferEffectMatchRule } from "./rules/anti-slop-prefer-effect-match.js";
+import { boundaryEntrypointShapeRule } from "./rules/boundary-entrypoint-shape.js";
+import { errorHandlingInEffectFnHandlerRule } from "./rules/error-handling-in-effect-fn-handler.js";
+import { exportedSchemaIdentifierRule } from "./rules/exported-schema-identifier.js";
+import { noAsymmetricMatchHandlersRule } from "./rules/no-asymmetric-match-handlers.js";
+import { noBareErrorInEffectRule } from "./rules/no-bare-error-in-effect.js";
+import { noEffectPromiseRule } from "./rules/no-effect-promise.js";
+import { noEffectReturnTypeRule } from "./rules/no-effect-return-type.js";
+import { noInlineSchemaCodecRule } from "./rules/no-inline-schema-codec.js";
+import { noInlineYieldStarRule } from "./rules/no-inline-yield-star.js";
+import { noManualDiscriminantComparisonRule } from "./rules/no-manual-discriminant-comparison.js";
+import { noManualDiscriminantConstructionRule } from "./rules/no-manual-discriminant-construction.js";
+import { noNestedMatchRule } from "./rules/no-nested-match.js";
+import { noParameterlessCatchAllRule } from "./rules/no-parameterless-catch-all.js";
+import { noProvideOnDefinitionRule } from "./rules/no-provide-on-definition.js";
+import { noTransportTypesInGeneratorRule } from "./rules/no-transport-types-in-generator.js";
+import { noYieldedMatchRule } from "./rules/no-yielded-match.js";
+import { preferEffectFnRule } from "./rules/prefer-effect-fn.js";
+import { provideNamedLayerRule } from "./rules/provide-named-layer.js";
+import { redactedSecretNamesRule } from "./rules/redacted-secret-names.js";
+import { runOnlyAtEntryRule } from "./rules/run-only-at-entry.js";
+import { serviceBuiltWithOfRule } from "./rules/service-built-with-of.js";
+import { serviceKeyMatchesNameRule } from "./rules/service-key-matches-name.js";
+import { servicePortShapeOnlyRule } from "./rules/service-port-shape-only.js";
+import { singleStylePerFunctionRule } from "./rules/single-style-per-function.js";
+import { tryObjectFormRule } from "./rules/try-object-form.js";
+import { untracedRecursionRule } from "./rules/untraced-recursion.js";
+export const pluginName = "dl-effect";
+// Resolved at runtime so it points at this file both from the sources and from `dist/`.
+export const pluginPath = fileURLToPath(import.meta.url);
+const dlEffectPlugin = eslintCompatPlugin({
+    meta: { name: pluginName },
+    rules: {
+        "anti-slop-no-manual-effect-error-tag": antiSlopNoManualEffectErrorTagRule,
+        "anti-slop-no-service-constructor-imports": antiSlopNoServiceConstructorImportsRule,
+        "anti-slop-prefer-effect-match": antiSlopPreferEffectMatchRule,
+        "adapter-import-boundary": adapterImportBoundaryRule,
+        "boundary-entrypoint-shape": boundaryEntrypointShapeRule,
+        "error-handling-in-effect-fn-handler": errorHandlingInEffectFnHandlerRule,
+        "exported-schema-identifier": exportedSchemaIdentifierRule,
+        "no-asymmetric-match-handlers": noAsymmetricMatchHandlersRule,
+        "no-bare-error-in-effect": noBareErrorInEffectRule,
+        "no-effect-promise": noEffectPromiseRule,
+        "no-effect-return-type": noEffectReturnTypeRule,
+        "no-inline-schema-codec": noInlineSchemaCodecRule,
+        "no-inline-yield-star": noInlineYieldStarRule,
+        "no-manual-discriminant-comparison": noManualDiscriminantComparisonRule,
+        "no-manual-discriminant-construction": noManualDiscriminantConstructionRule,
+        "no-nested-match": noNestedMatchRule,
+        "no-parameterless-catch-all": noParameterlessCatchAllRule,
+        "no-provide-on-definition": noProvideOnDefinitionRule,
+        "no-transport-types-in-generator": noTransportTypesInGeneratorRule,
+        "no-yielded-match": noYieldedMatchRule,
+        "prefer-effect-fn": preferEffectFnRule,
+        "provide-named-layer": provideNamedLayerRule,
+        "redacted-secret-names": redactedSecretNamesRule,
+        "run-only-at-entry": runOnlyAtEntryRule,
+        "service-built-with-of": serviceBuiltWithOfRule,
+        "service-key-matches-name": serviceKeyMatchesNameRule,
+        "service-port-shape-only": servicePortShapeOnlyRule,
+        "single-style-per-function": singleStylePerFunctionRule,
+        "try-object-form": tryObjectFormRule,
+        "untraced-recursion": untracedRecursionRule,
+    },
+});
+export default dlEffectPlugin;

package/dist/presets/all.d.ts

@@ -0,0 +1,7 @@
+declare const all: {
+    jsPlugins: string[];
+    rules: {
+        [k: string]: "warn";
+    };
+};
+export default all;

package/dist/presets/all.js

@@ -0,0 +1,9 @@
+import dlEffectPlugin, { pluginName, pluginPath } from "../index.js";
+const allRules = Object.fromEntries(Object.keys(dlEffectPlugin.rules).map((rule) => [`${pluginName}/${rule}`, "warn"]));
+// Absolute because an imported config object carries no location of its own: a relative
+// path would resolve against the consumer's config file, not this package.
+const all = {
+    jsPlugins: [pluginPath],
+    rules: allRules,
+};
+export default all;

package/dist/presets/all.json

@@ -0,0 +1,37 @@
+{
+    "jsPlugins": [
+        "../index.js"
+    ],
+    "rules": {
+        "dl-effect/anti-slop-no-manual-effect-error-tag": "warn",
+        "dl-effect/anti-slop-no-service-constructor-imports": "warn",
+        "dl-effect/anti-slop-prefer-effect-match": "warn",
+        "dl-effect/adapter-import-boundary": "warn",
+        "dl-effect/boundary-entrypoint-shape": "warn",
+        "dl-effect/error-handling-in-effect-fn-handler": "warn",
+        "dl-effect/exported-schema-identifier": "warn",
+        "dl-effect/no-asymmetric-match-handlers": "warn",
+        "dl-effect/no-bare-error-in-effect": "warn",
+        "dl-effect/no-effect-promise": "warn",
+        "dl-effect/no-effect-return-type": "warn",
+        "dl-effect/no-inline-schema-codec": "warn",
+        "dl-effect/no-inline-yield-star": "warn",
+        "dl-effect/no-manual-discriminant-comparison": "warn",
+        "dl-effect/no-manual-discriminant-construction": "warn",
+        "dl-effect/no-nested-match": "warn",
+        "dl-effect/no-parameterless-catch-all": "warn",
+        "dl-effect/no-provide-on-definition": "warn",
+        "dl-effect/no-transport-types-in-generator": "warn",
+        "dl-effect/no-yielded-match": "warn",
+        "dl-effect/prefer-effect-fn": "warn",
+        "dl-effect/provide-named-layer": "warn",
+        "dl-effect/redacted-secret-names": "warn",
+        "dl-effect/run-only-at-entry": "warn",
+        "dl-effect/service-built-with-of": "warn",
+        "dl-effect/service-key-matches-name": "warn",
+        "dl-effect/service-port-shape-only": "warn",
+        "dl-effect/single-style-per-function": "warn",
+        "dl-effect/try-object-form": "warn",
+        "dl-effect/untraced-recursion": "warn"
+    }
+}

package/dist/rules/adapter-import-boundary.d.ts

@@ -0,0 +1,7 @@
+type Deps = {
+    readonly isAdapterDir: (dir: string) => boolean;
+};
+export declare const buildsLayer: (source: string) => boolean;
+export declare const makeAdapterImportBoundaryRule: (deps: Deps) => import("@oxlint/plugins").Rule;
+export declare const adapterImportBoundaryRule: import("@oxlint/plugins").Rule;
+export {};

package/dist/rules/adapter-import-boundary.js

@@ -0,0 +1,103 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { isEntryFile } from "../shared/entry-files.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+// Only the APIs that build a service implementation, so composition of existing layers
+// (`mergeAll`, `provide`, `merge`) leaves the entry point out. Longest names first: the
+// alternation is ordered, and `effect` would otherwise shadow `effectContext`.
+// `scoped*`, `context`, `service` and `function` exist in Effect 3 only; `unwrap` and
+// `mock` in Effect 4 only. Naming the API instead of the binding keeps `FooLive` covered.
+const LAYER_CONSTRUCTORS = [
+    "effectContext",
+    "effectDiscard",
+    "succeedContext",
+    "scopedContext",
+    "scopedDiscard",
+    "syncContext",
+    "function",
+    "service",
+    "context",
+    "succeed",
+    "scoped",
+    "effect",
+    "unwrap",
+    "sync",
+    "mock",
+];
+// Like the other rules, names are matched literally: `import * as L from "effect/Layer"` escapes.
+const LAYER_CONSTRUCTION = new RegExp(`\\bLayer\\.(?:${LAYER_CONSTRUCTORS.join("|")})\\s*\\(`, "u");
+export const buildsLayer = (source) => LAYER_CONSTRUCTION.test(source);
+// Test files are skipped so a fixture layer cannot promote a domain directory to an adapter.
+const isSource = (entry) => entry.endsWith(".ts") && !entry.endsWith(".test.ts");
+const buildsLayerIn = (dir) => {
+    try {
+        return readdirSync(dir)
+            .filter(isSource)
+            .some((entry) => buildsLayer(readFileSync(resolve(dir, entry), "utf8")));
+    }
+    catch {
+        return false;
+    }
+};
+const cachedBuildsLayerIn = () => {
+    const known = new Map();
+    return (dir) => {
+        const seen = known.get(dir);
+        if (seen !== undefined)
+            return seen;
+        const verdict = buildsLayerIn(dir);
+        known.set(dir, verdict);
+        return verdict;
+    };
+};
+const isRelativeImport = (source) => source.startsWith("./") || source.startsWith("../");
+const toPosix = (path) => path.split(sep).join("/");
+export const makeAdapterImportBoundaryRule = (deps) => defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Import adapters only at the entry point, and never from another adapter. Entry and test files are skipped.",
+        },
+        messages: {
+            adapterOutsideEntry: "`{{adapter}}` is an adapter: depend on its port instead and let the entry point provide the Layer.",
+            crossAdapter: "`{{adapter}}` is another adapter: depend on its port instead and let the entry point compose the Layers.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    entryFiles: filePatternsSchema,
+                    testFiles: filePatternsSchema,
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const ownDir = dirname(context.filename);
+        // A test composes the Layers it exercises, so it is an entry point too.
+        const composesLayers = isEntryFile(context) || isTestFile(context);
+        return {
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                if (composesLayers || !isRelativeImport(source))
+                    return;
+                const targetDir = dirname(resolve(ownDir, source));
+                if (targetDir === ownDir || !deps.isAdapterDir(targetDir))
+                    return;
+                context.report({
+                    node,
+                    messageId: deps.isAdapterDir(ownDir)
+                        ? "crossAdapter"
+                        : "adapterOutsideEntry",
+                    data: { adapter: toPosix(relative(context.cwd, targetDir)) },
+                });
+            },
+        };
+    },
+});
+export const adapterImportBoundaryRule = makeAdapterImportBoundaryRule({
+    isAdapterDir: cachedBuildsLayerIn(),
+});

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

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

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

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

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

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

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

@@ -0,0 +1,49 @@
+import { defineRule } from "@oxlint/plugins";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+const serviceConstructorName = /^make[A-Z]/u;
+const isProjectLocalImport = (source) => source.startsWith("./") || source.startsWith("../");
+const importedName = (specifier) => specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+export const antiSlopNoServiceConstructorImportsRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow project-local make<CapabilityName> imports outside test 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.',
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let inTestFile = false;
+        return {
+            // Tests build services from their constructors to inject fakes.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            ImportDeclaration(node) {
+                if (inTestFile || !isProjectLocalImport(node.source.value))
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportSpecifier")
+                        continue;
+                    const name = importedName(specifier);
+                    if (!serviceConstructorName.test(name))
+                        continue;
+                    context.report({
+                        node: specifier,
+                        messageId: "serviceConstructorImport",
+                        data: { name },
+                    });
+                }
+            },
+        };
+    },
+});

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

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

package/dist/rules/anti-slop-prefer-effect-match.js

@@ -0,0 +1,45 @@
+import { defineRule } from "@oxlint/plugins";
+import { isEqualityComparison } from "../shared/tagged-values.js";
+const isLiteral = (node) => node.type === "Literal" || (node.type === "TemplateLiteral" && node.expressions.length === 0);
+export const antiSlopPreferEffectMatchRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use Match from Effect for chained literal ternaries over the same value.",
+        },
+        messages: {
+            preferMatch: "Use Match from Effect instead of a chained literal ternary.",
+        },
+    },
+    createOnce(context) {
+        // The compared value is identified by its source text: no type or binding analysis.
+        const comparedValue = (node) => {
+            if (!isEqualityComparison(node))
+                return undefined;
+            if (isLiteral(node.left))
+                return context.sourceCode.getText(node.right);
+            if (isLiteral(node.right))
+                return context.sourceCode.getText(node.left);
+            return undefined;
+        };
+        return {
+            ConditionalExpression(node) {
+                if (node.parent?.type === "ConditionalExpression")
+                    return;
+                const value = comparedValue(node.test);
+                if (value === undefined)
+                    return;
+                let alternate = node.alternate;
+                let literalChecks = 1;
+                while (alternate.type === "ConditionalExpression") {
+                    if (comparedValue(alternate.test) !== value)
+                        return;
+                    literalChecks += 1;
+                    alternate = alternate.alternate;
+                }
+                if (literalChecks > 1)
+                    context.report({ node, messageId: "preferMatch" });
+            },
+        };
+    },
+});

package/dist/rules/boundary-entrypoint-shape.d.ts

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

package/dist/rules/boundary-entrypoint-shape.js

@@ -0,0 +1,52 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, nearestFunction } from "../shared/effect-ast.js";
+// The *Exit runners hand failures back as values, so an open error channel cannot leak there.
+const effectRunners = new Set(["runPromise", "runSync", "runFork", "runCallback"]);
+const runtimes = ["NodeRuntime", "BunRuntime"];
+const isRunnerCall = (node) => effectRunners.has(calleeOf(node, "Effect") ?? "") ||
+    runtimes.some((runtime) => calleeOf(node, runtime) === "runMain");
+const isEffectTypeName = (name) => (name.type === "Identifier" && name.name === "Effect") ||
+    (name.type === "TSQualifiedName" &&
+        name.left.type === "Identifier" &&
+        name.left.name === "Effect" &&
+        name.right.name === "Effect");
+const isClosedEffectType = (type) => type?.type === "TSTypeReference" &&
+    isEffectTypeName(type.typeName) &&
+    type.typeArguments?.params[1]?.type === "TSNeverKeyword";
+const parameterType = (identifier) => {
+    for (let fn = nearestFunction(identifier); fn; fn = nearestFunction(fn)) {
+        for (const param of fn.params) {
+            if (param.type === "Identifier" && param.name === identifier.name) {
+                return param.typeAnnotation?.typeAnnotation;
+            }
+        }
+    }
+    return undefined;
+};
+const hasClosedErrorChannel = (node) => {
+    if (node?.type === "TSSatisfiesExpression")
+        return isClosedEffectType(node.typeAnnotation);
+    if (node?.type === "Identifier")
+        return isClosedEffectType(parameterType(node));
+    return false;
+};
+export const boundaryEntrypointShapeRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Close the error channel to `never` before running an Effect at the boundary.",
+        },
+        messages: {
+            openErrorChannel: "Close the error channel before running: `program satisfies Effect.Effect<A, never>`, or a runner parameter typed `Effect.Effect<A, never, never>`.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (isRunnerCall(node) && !hasClosedErrorChannel(node.arguments[0])) {
+                    context.report({ node, messageId: "openErrorChannel" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/error-handling-in-effect-fn-handler.d.ts

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

package/dist/rules/error-handling-in-effect-fn-handler.js

@@ -0,0 +1,66 @@
+import { defineRule } from "@oxlint/plugins";
+import { isInsideEffectGeneratorBody, memberOf } from "../shared/effect-ast.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+import { isTestFile } from "../shared/test-files.js";
+// mapError, orElse and orElseSucceed stay allowed: they name a failure or give an alternative
+// without opening a handling branch inside the success path.
+const errorHandlers = new Set([
+    "catch",
+    "catchAll",
+    "catchCause",
+    "catchCauseFilter",
+    "catchCauseIf",
+    "catchDefect",
+    "catchEager",
+    "catchFilter",
+    "catchIf",
+    "catchReason",
+    "catchReasons",
+    "catchTag",
+    "catchTags",
+    "either",
+    "exit",
+    "match",
+    "matchCause",
+    "matchCauseEffect",
+    "matchEffect",
+    "result",
+    "sandbox",
+]);
+export const errorHandlingInEffectFnHandlerRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Keep only the success path in Effect generators and handle errors in the second argument of `Effect.fn`. Test files are skipped.",
+        },
+        messages: {
+            handlerInGenerator: "Move `Effect.{{name}}` out of the generator: keep the success path in the body and handle errors in the pipeable arguments of `Effect.fn`.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { testFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let inTestFile = false;
+        return {
+            // In a test the failure is the observed outcome, not a branch of the success path.
+            before() {
+                inTestFile = isTestFile(context);
+            },
+            MemberExpression(node) {
+                const name = memberOf(node, "Effect");
+                if (inTestFile ||
+                    name === undefined ||
+                    !errorHandlers.has(name) ||
+                    !isInsideEffectGeneratorBody(node)) {
+                    return;
+                }
+                context.report({ node, messageId: "handlerInGenerator", data: { name } });
+            },
+        };
+    },
+});

package/dist/rules/exported-schema-identifier.d.ts

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

package/dist/rules/exported-schema-identifier.js

@@ -0,0 +1,117 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf } from "../shared/effect-ast.js";
+// `Schema.Class` and `Schema.TaggedError` carry their name already.
+const anonymousSchemas = new Set(["Struct", "Union", "Array"]);
+const chainedMethod = (node) => node.type === "CallExpression" &&
+    node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    node.callee.property.type === "Identifier"
+    ? { name: node.callee.property.name, receiver: node.callee.object, call: node }
+    : undefined;
+// `X.pipe(Schema.annotate(a))` and `X.annotate(a)`, in any order along the chain.
+const annotationsOf = (init) => {
+    const annotations = [];
+    let current = init;
+    while (calleeOf(current, "Schema") === undefined) {
+        const link = chainedMethod(current);
+        if (link === undefined)
+            return undefined;
+        if (link.name === "annotate")
+            annotations.push(...link.call.arguments);
+        else if (link.name === "pipe") {
+            for (const argument of link.call.arguments) {
+                if (calleeOf(argument, "Schema") === "annotate" &&
+                    argument.type === "CallExpression") {
+                    annotations.push(...argument.arguments);
+                }
+            }
+        }
+        else if (link.name !== "check")
+            return undefined;
+        current = link.receiver;
+    }
+    const root = calleeOf(current, "Schema");
+    return root !== undefined && anonymousSchemas.has(root) ? annotations : undefined;
+};
+const identifierOf = (annotations) => {
+    for (const annotation of annotations) {
+        if (annotation.type !== "ObjectExpression")
+            continue;
+        for (const property of annotation.properties) {
+            if (property.type === "Property" &&
+                !property.computed &&
+                ((property.key.type === "Identifier" && property.key.name === "identifier") ||
+                    (property.key.type === "Literal" && property.key.value === "identifier"))) {
+                return property.value;
+            }
+        }
+    }
+    return undefined;
+};
+export const exportedSchemaIdentifierRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Annotate every exported `Schema.Struct`, `Schema.Union` and `Schema.Array` with an `identifier` equal to its name.",
+        },
+        hasSuggestions: true,
+        messages: {
+            missingIdentifier: 'Annotate `{{name}}` with `identifier: "{{name}}"`, so errors, JSON Schema and arbitraries name it.',
+            wrongIdentifier: 'The `identifier` of `{{name}}` is `{{identifier}}`: use `"{{name}}"`, the name the schema is imported by.',
+            addIdentifier: 'Append `.annotate({ identifier: "{{name}}" })`.',
+            renameIdentifier: 'Use `"{{name}}"` as identifier.',
+        },
+    },
+    createOnce(context) {
+        const check = (declarator) => {
+            const { id, init } = declarator;
+            if (id.type !== "Identifier" || !init)
+                return;
+            const annotations = annotationsOf(init);
+            if (annotations === undefined)
+                return;
+            const name = id.name;
+            const identifier = identifierOf(annotations);
+            if (identifier === undefined) {
+                context.report({
+                    node: id,
+                    messageId: "missingIdentifier",
+                    data: { name },
+                    suggest: [
+                        {
+                            messageId: "addIdentifier",
+                            data: { name },
+                            fix: (fixer) => fixer.insertTextAfter(init, `.annotate({ identifier: "${name}" })`),
+                        },
+                    ],
+                });
+                return;
+            }
+            // A computed identifier cannot be checked without evaluating it.
+            if (identifier.type !== "Literal" || typeof identifier.value !== "string")
+                return;
+            if (identifier.value === name)
+                return;
+            context.report({
+                node: identifier,
+                messageId: "wrongIdentifier",
+                data: { name, identifier: identifier.value },
+                suggest: [
+                    {
+                        messageId: "renameIdentifier",
+                        data: { name },
+                        fix: (fixer) => fixer.replaceText(identifier, `"${name}"`),
+                    },
+                ],
+            });
+        };
+        return {
+            // Internal fragments, reused through `.fields`, never reach an error message alone.
+            ExportNamedDeclaration(node) {
+                if (node.declaration?.type !== "VariableDeclaration")
+                    return;
+                node.declaration.declarations.forEach(check);
+            },
+        };
+    },
+});

package/dist/rules/no-asymmetric-match-handlers.d.ts

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