@commonplaces/oxlint-plugin 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,3 +1,6 @@
+import { Record } from "effect";
+import conventionPlugin from "./conventions.js";
+import webPlugin from "./web.js";
 /** General code checks, with no project-specific file names or settings. */
 export const general = {
     jsPlugins: ["@commonplaces/oxlint-plugin/anti-slop", "@commonplaces/oxlint-plugin/package"],
@@ -35,6 +38,7 @@ export 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",
@@ -52,6 +56,42 @@ export const effect = {
         "anti-slop-effect/no-service-constructor-imports": "error",
     },
 };
+/** Optional strict coding conventions; boundary permissions remain project facts. */
+export const conventions = {
+    jsPlugins: ["@commonplaces/oxlint-plugin/conventions"],
+    rules: Record.mapKeys(Record.map(Record.filter(conventionPlugin.rules, (_, name) => name !== "no-schema-decoder-outside-ingress" &&
+        name !== "no-schema-encoder-outside-egress" &&
+        name !== "no-sync-decoder-outside-consumer" &&
+        name !== "browser-runtime-ownership" &&
+        name !== "native-http-client-ownership" &&
+        name !== "bounded-build-memo"), () => "error"), (name) => `effect-conventions/${name}`),
+};
+/** Optional React/TanStack, MDX, semantic typography and route conventions. */
+export const web = {
+    plugins: ["react", "react-perf", "jsx-a11y"],
+    jsPlugins: ["@commonplaces/oxlint-plugin/web"],
+    rules: Record.mapKeys(Record.map(webPlugin.rules, () => "error"), (name) => `web/${name}`),
+};
+/** Native type-aware checks. Run Oxlint with --type-aware. */
+export const typescript = {
+    plugins: ["typescript", "unicorn", "import", "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 const alchemy = {
     jsPlugins: ["@commonplaces/oxlint-plugin/alchemy", "@commonplaces/oxlint-plugin/strict-effect"],
@@ -62,3 +102,7 @@ export const alchemy = {
         "strict-effect/native-cloudflare-cache": "error",
     },
 };
+/** Complete strict Effect application profile; exact project owners stay local. */
+export const strict = {
+    extends: [general, effect, alchemy, conventions, web, typescript],
+};

package/dist/native-reference.d.ts

@@ -1,5 +1,11 @@
 import type { Context, ESTree, Variable } from "@oxlint/plugins";
 import * as Option from "effect/Option";
+interface Reference {
+    readonly module: string;
+    readonly name: Option.Option<string>;
+}
 export declare const constant: (variable: Variable) => Option.Option<ESTree.VariableDeclarator>;
+export declare const referenceOf: (context: Context, node: ESTree.Node, visited?: readonly ESTree.Node[]) => Option.Option<Reference>;
 export declare const valueOf: (context: Context, node: ESTree.Node, visited?: readonly ESTree.Node[]) => Option.Option<ESTree.Node>;
 export declare const operation: (context: Context, node: ESTree.Node, module: string, name: string) => boolean;
+export {};

package/dist/native-reference.js

@@ -9,8 +9,12 @@ export const constant = (variable) => Array.head(variable.defs).pipe(Option.filt
 const member = (reference, name) => {
     if (Option.isSome(reference.name))
         return Option.none();
+    if (reference.module === "@effect/atom-react" && name === "Atom") {
+        return Option.some({ module: "effect/reactivity/Atom", name: Option.none() });
+    }
     return reference.module === "alchemy" ||
         reference.module === "effect" ||
+        Array.contains(["effect/reactivity", "effect/http", "effect/http-api", "effect/rpc", "effect/unstable/http"], reference.module) ||
         (reference.module === "effect/process" &&
             (name === "ChildProcess" || name === "ChildProcessSpawner"))
         ? Option.some({ module: `${reference.module}/${name}`, name: Option.none() })
@@ -18,11 +22,14 @@ const member = (reference, 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 = []) => {
+export 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") {
+    if (node.type === "TSAsExpression" ||
+        node.type === "TSSatisfiesExpression" ||
+        node.type === "TSInstantiationExpression" ||
+        node.type === "ChainExpression") {
         return referenceOf(context, node.expression, next);
     }
     if (node.type === "MemberExpression") {
@@ -40,11 +47,6 @@ const referenceOf = (context, node, visited = []) => {
             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);

package/dist/package.js

@@ -7,7 +7,7 @@ const resolveRelative = (fileName, specifier) => Array.join(Array.reduce(specifi
     : segment === "." || segment.length === 0
         ? segments
         : [...segments, segment]), "/");
-const workspaceSourceRoot = (fileName) => Option.fromNullishOr(fileName.match(/\/(?:apps|packages)\/(?:[^/]+\/)+?src(?:\/|$)/u)).pipe(Option.flatMap(Array.head), Option.map((root) => root.replace(/\/$/u, "")));
+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) => {
     if (!specifier.startsWith(".")) {

package/dist/service-instrumentation.d.ts

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

package/dist/service-instrumentation.js

@@ -0,0 +1,238 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Option, Schema } from "effect";
+import { constant, operation, referenceOf, valueOf } from "./native-reference.js";
+import { childNodes, propertyName, variableInScope } from "./syntax.js";
+const Options = Schema.Struct({
+    serviceNames: Schema.optionalKey(Schema.NonEmptyArray(Schema.String)),
+    operationAdapters: Schema.optionalKey(Schema.Array(Schema.Struct({
+        module: Schema.NonEmptyString,
+        file: Schema.NonEmptyString.check(Schema.isPattern(/^(?!\/)(?!.*(?:\*|\\|(?:^|\/)\.\.?\/)).+\.tsx?$/u)),
+        exports: Schema.NonEmptyArray(Schema.NonEmptyString),
+        operation: Schema.NonEmptyString,
+    }))),
+});
+const adapted = (context, node, name, adapters) => {
+    const value = valueOf(context, node);
+    if (Option.isNone(value) || value.value.type !== "CallExpression")
+        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)
+                : segment === "."
+                    ? parts
+                    : [...parts, segment]), "/")
+            : "";
+        const source = (path) => path.replace(/\.[cm]?[jt]sx?$/u, "");
+        return (adapter.operation === name &&
+            Option.exists(reference.name, (export_) => Array.contains(adapter.exports, export_)) &&
+            (reference.module === adapter.module ||
+                source(relative) === source(`${context.cwd}/${adapter.file}`)));
+    })));
+};
+const serviceClass = (context, node) => {
+    const containsService = (value) => (value.type === "CallExpression" &&
+        operation(context, value.callee, "effect/Context", "Service")) ||
+        Array.some(childNodes(context, value), containsService);
+    return Option.fromNullishOr(node.superClass).pipe(Option.exists(containsService));
+};
+// Imported names preserve the contract's canonical name even when locally aliased.
+// Local objects and shadowed parameters cannot borrow an imported service name.
+const serviceOf = (context, node, visited = []) => {
+    if (Array.some(visited, (previous) => previous === node))
+        return Option.none();
+    const next = [...visited, node];
+    const imported = referenceOf(context, node).pipe(Option.filter((reference) => !/^(?:effect|alchemy)(?:\/|$)/u.test(reference.module)), Option.flatMap((reference) => reference.name), Option.filter((name) => /^[A-Z]/u.test(name)), Option.map((name) => ({ name, declaration: Option.none() })));
+    if (Option.isSome(imported))
+        return imported;
+    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.node.type === "ClassDeclaration" &&
+            serviceClass(context, definition.node)) {
+            return Option.some({ name: node.name, declaration: Option.some(definition.node) });
+        }
+        return constant(variable).pipe(Option.flatMap((declaration) => Option.fromNullishOr(declaration.init)), Option.flatMap((value) => serviceOf(context, value, next)));
+    }))));
+};
+// Local contracts supply positive evidence for data/Stream members. No property
+// name, file suffix or service name is exempted from operation checks.
+const contractFields = (context, service) => {
+    const fields = (node) => {
+        if (node.type === "CallExpression" &&
+            operation(context, node.callee, "effect/Context", "Service")) {
+            return Option.fromNullishOr(node.typeArguments).pipe(Option.flatMap((arguments_) => Array.get(arguments_.params, 1)), Option.filter((type) => type.type === "TSTypeLiteral"), Option.map((type) => (type.type === "TSTypeLiteral" ? type.members : [])), Option.getOrElse(() => []));
+        }
+        return Array.flatMap(childNodes(context, node), fields);
+    };
+    return service.declaration.pipe(Option.map(fields), Option.getOrElse(() => []));
+};
+const typeModule = (context, type) => {
+    const name = type.typeName;
+    const root = name.type === "TSQualifiedName" ? name.left : name;
+    if (root.type !== "Identifier")
+        return Option.none();
+    return variableInScope(context.sourceCode.getScope(root), root.name).pipe(Option.flatMap((variable) => Array.head(variable.defs)), Option.flatMap((definition) => {
+        if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration")
+            return Option.none();
+        const source = definition.parent.source.value;
+        if (source === "effect" && definition.node.type === "ImportSpecifier") {
+            return propertyName(definition.node.imported).pipe(Option.map((member) => `effect/${member}`));
+        }
+        return Option.some(source);
+    }));
+};
+const dataMember = (context, fields, name) => Array.findFirst(fields, (field) => field.type === "TSPropertySignature" && Option.contains(propertyName(field.key), name)).pipe(Option.flatMap((field) => field.type === "TSPropertySignature"
+    ? Option.fromNullishOr(field.typeAnnotation?.typeAnnotation)
+    : Option.none()), Option.exists((type) => Array.contains(["TSStringKeyword", "TSNumberKeyword", "TSBooleanKeyword", "TSLiteralType"], type.type) ||
+    (type.type === "TSTypeReference" &&
+        typeModule(context, type).pipe(Option.exists((module) => Array.contains(["effect/Option", "effect/Stream", "effect/Schema"], module))))));
+const streamValue = (context, node) => valueOf(context, node).pipe(Option.exists((value) => {
+    if (value.type === "CallExpression") {
+        if (value.callee.type === "MemberExpression" &&
+            Option.contains(propertyName(value.callee.property), "pipe")) {
+            return streamValue(context, value.callee.object);
+        }
+        return (value.callee.type === "MemberExpression" &&
+            value.callee.object.type === "Identifier" &&
+            operation(context, value.callee.object, "effect", "Stream"));
+    }
+    return (value.type === "MemberExpression" && operation(context, value.object, "effect", "Stream"));
+}));
+const named = (context, node, name, method) => node.type === "CallExpression" &&
+    operation(context, node.callee, "effect/Effect", method) &&
+    Array.head(node.arguments).pipe(Option.exists((argument) => argument.type === "Literal" && argument.value === name));
+// A nested unrelated span is insufficient: instrumentation must wrap the value
+// or the operation's returned Effect, including every explicit return branch.
+const instrumented = (context, node, name, visited = []) => {
+    if (Array.some(visited, (previous) => previous === node))
+        return false;
+    const next = [...visited, node];
+    if (node.type === "Identifier") {
+        return valueOf(context, node).pipe(Option.exists((value) => instrumented(context, value, name, next)));
+    }
+    if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+        if (node.body === null)
+            return false;
+        if (node.body.type !== "BlockStatement")
+            return instrumented(context, node.body, name, next);
+        const returned = (statement) => {
+            if (statement.type === "ReturnStatement")
+                return Option.toArray(Option.fromNullishOr(statement.argument));
+            if (statement.type === "ArrowFunctionExpression" ||
+                statement.type === "FunctionExpression" ||
+                statement.type === "FunctionDeclaration")
+                return [];
+            return Array.flatMap(childNodes(context, statement), returned);
+        };
+        const values = returned(node.body);
+        return (values.length > 0 && Array.every(values, (value) => instrumented(context, value, name, next)));
+    }
+    if (node.type !== "CallExpression")
+        return false;
+    if (node.callee.type === "CallExpression" &&
+        (named(context, node.callee, name, "fn") || named(context, node.callee, name, "withSpan")))
+        return true;
+    return (((node.callee.type === "MemberExpression" &&
+        Option.contains(propertyName(node.callee.property), "pipe")) ||
+        operation(context, node.callee, "effect/Function", "pipe")) &&
+        Array.some(node.arguments, (argument) => named(context, argument, name, "withSpan")));
+};
+export const requireServiceOperationInstrumentation = defineRule({
+    meta: {
+        type: "problem",
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    serviceNames: { type: "array", minItems: 1, items: { type: "string", minLength: 1 } },
+                    operationAdapters: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                module: { type: "string", minLength: 1 },
+                                file: { type: "string", minLength: 1 },
+                                exports: { type: "array", minItems: 1, items: { type: "string", minLength: 1 } },
+                                operation: { type: "string", minLength: 1 },
+                            },
+                            required: ["module", "file", "exports", "operation"],
+                            additionalProperties: false,
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        docs: {
+            description: "Require canonical operation spans on native services, including imported aliases and mixed contracts.",
+        },
+        messages: {
+            missingInstrumentation: "Instrument {{operation}} with Effect.fn or Effect.withSpan using that exact name.",
+            unsupportedOperation: "Declare service members as explicit named properties so their operation spans can be checked.",
+        },
+    },
+    create(context) {
+        // Oxlint owns this synchronous options boundary. Invalid options stop linting.
+        const options = Schema.decodeUnknownSync(Options)(Option.getOrElse(Array.head(context.options), () => ({})));
+        return {
+            CallExpression(node) {
+                const mock = operation(context, node.callee, "effect/Layer", "mock");
+                const constructor = mock
+                    ? Array.head(node.arguments)
+                    : node.callee.type === "MemberExpression" &&
+                        Option.contains(propertyName(node.callee.property), "of")
+                        ? Option.some(node.callee.object)
+                        : Option.none();
+                if (Option.isNone(constructor))
+                    return;
+                const target = constructor.value;
+                const selected = options.serviceNames;
+                const explicit = target.type === "Identifier" && selected?.includes(target.name);
+                const service = explicit
+                    ? Option.some({
+                        name: target.type === "Identifier" ? target.name : "",
+                        declaration: Option.none(),
+                    })
+                    : selected
+                        ? Option.none()
+                        : serviceOf(context, target);
+                Option.match(service, {
+                    onNone: () => { },
+                    onSome: (owner) => {
+                        const fields = contractFields(context, owner);
+                        const argument = Array.get(node.arguments, mock ? 1 : 0).pipe(Option.flatMap((value) => valueOf(context, value)));
+                        if (Option.isNone(argument) || argument.value.type !== "ObjectExpression") {
+                            context.report({ node, messageId: "unsupportedOperation" });
+                            return;
+                        }
+                        Array.forEach(argument.value.properties, (property) => {
+                            if (property.type !== "Property") {
+                                context.report({ node: property, messageId: "unsupportedOperation" });
+                                return;
+                            }
+                            const key = property.computed && property.key.type !== "Literal"
+                                ? Option.none()
+                                : propertyName(property.key);
+                            Option.match(key, {
+                                onNone: () => context.report({ node: property, messageId: "unsupportedOperation" }),
+                                onSome: (member) => {
+                                    if (dataMember(context, fields, member) || streamValue(context, property.value))
+                                        return;
+                                    const name = `${owner.name}.${member}`;
+                                    if (!instrumented(context, property.value, name) &&
+                                        !adapted(context, property.value, name, options.operationAdapters ?? []))
+                                        context.report({
+                                            node: property,
+                                            messageId: "missingInstrumentation",
+                                            data: { operation: name },
+                                        });
+                                },
+                            });
+                        });
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/strict-effect.js

@@ -2240,12 +2240,12 @@ const SchemaOwner = Schema.Struct({
 });
 const SharedSchemaOptions = Schema.Struct({
     owners: nonEmpty(SchemaOwner),
-    fields: Schema.Array(Schema.Struct({
+    fields: Schema.optionalKey(Schema.Array(Schema.Struct({
         file: PolicyFile,
         declaration: PolicyName,
         field: PolicyName,
         schema: PolicyName,
-    })),
+    }))),
 });
 const ConstantMapOptions = Schema.Struct({
     maps: nonEmpty(Schema.Struct({ file: PolicyFile, name: PolicyName, constraint: PolicyConstraint })),
@@ -2377,10 +2377,13 @@ const sharedSchemaOwner = defineRule({
     meta: {
         type: "problem",
         schema: [
-            jsonObject({
-                owners: jsonList({ file: jsonFile, module: jsonText, names: jsonNames }, 1),
-                fields: jsonList({ file: jsonFile, declaration: jsonText, field: jsonText, schema: jsonText }, 0),
-            }),
+            {
+                ...jsonObject({
+                    owners: jsonList({ file: jsonFile, module: jsonText, names: jsonNames }, 1),
+                    fields: jsonList({ file: jsonFile, declaration: jsonText, field: jsonText, schema: jsonText }, 0),
+                }),
+                required: ["owners"],
+            },
         ],
         messages: {
             options: "Configure the shared schema owners and the fields that must reuse them.",
@@ -2391,7 +2394,10 @@ const sharedSchemaOwner = defineRule({
     create(context) {
         const options = ruleOptions(SharedSchemaOptions)(context);
         const owners = Option.match(options, { onNone: () => [], onSome: (value) => value.owners });
-        const fields = Option.match(options, { onNone: () => [], onSome: (value) => value.fields });
+        const fields = Option.match(options, {
+            onNone: () => [],
+            onSome: (value) => value.fields ?? [],
+        });
         // A local `const` may alias the owner's export of the same name.
         const importedAlias = (node, name) => scopedVariable(context.sourceCode.getScope(node), name).pipe(Option.flatMap(constantDeclaration), Option.flatMap((declaration) => Option.fromNullishOr(declaration.init)), Option.exists((value) => Array.some(owners, (owner) => Array.contains(owner.names, name) && ownerExport(context, value, name, owner))));
         const checkName = (node, name, alias) => {

package/dist/web/typography.d.ts

@@ -0,0 +1,5 @@
+export declare const typographyRules: {
+    "semantic-typography": import("@oxlint/plugins").Rule;
+    "gap-layout": import("@oxlint/plugins").Rule;
+    "safe-type-line-height": import("@oxlint/plugins").Rule;
+};

package/dist/web/typography.js

@@ -0,0 +1,98 @@
+import { Array, Option, Predicate } from "effect";
+import { report, rule } from "../conventions/shared.js";
+const stringValue = (node) => node.type === "Literal" && Predicate.isString(node.value)
+    ? Option.some(node.value)
+    : node.type === "TemplateElement"
+        ? Option.some(node.value.cooked ?? node.value.raw)
+        : Option.none();
+const classContext = (node) => {
+    const parent = node.parent;
+    if (parent === null)
+        return false;
+    if (parent.type === "JSXAttribute" &&
+        parent.name.type === "JSXIdentifier" &&
+        Array.contains(["class", "className"], parent.name.name))
+        return true;
+    if (parent.type === "CallExpression" &&
+        parent.callee.type === "Identifier" &&
+        Array.contains(["cn", "clsx", "cva", "twMerge"], parent.callee.name))
+        return true;
+    return classContext(parent);
+};
+// Variant colons inside arbitrary selectors/values do not delimit the utility.
+const utility = (text) => {
+    const state = Array.reduce(Array.fromIterable(text), { square: 0, paren: 0, last: -1, index: 0 }, (previous, character) => ({
+        square: character === "["
+            ? previous.square + 1
+            : character === "]"
+                ? Math.max(0, previous.square - 1)
+                : previous.square,
+        paren: character === "("
+            ? previous.paren + 1
+            : character === ")"
+                ? Math.max(0, previous.paren - 1)
+                : previous.paren,
+        last: character === ":" && previous.square === 0 && previous.paren === 0
+            ? previous.index
+            : previous.last,
+        index: previous.index + 1,
+    }));
+    return text
+        .slice(state.last + 1)
+        .replace(/^!|!$/gu, "")
+        .replace(/\/.*$/u, "");
+};
+const typography = [
+    "font-bold",
+    "font-medium",
+    "font-mono",
+    "font-normal",
+    "font-sans",
+    "font-semibold",
+    "leading-none",
+    "leading-normal",
+    "leading-relaxed",
+    "leading-snug",
+    "leading-tight",
+    "text-2xl",
+    "text-3xl",
+    "text-4xl",
+    "text-base",
+    "text-lg",
+    "text-md",
+    "text-sm",
+    "text-xl",
+    "text-xs",
+    "tracking-display",
+    "tracking-loose",
+    "tracking-tight",
+];
+export const typographyRules = {
+    "semantic-typography": rule("Use shared semantic typography primitives instead of local text-size, line-height, tracking and font utility piles.", (context) => {
+        const check = (node) => {
+            if (classContext(node) &&
+                stringValue(node).pipe(Option.exists((value) => Array.some(value.split(/\s+/u), (word) => Array.contains(typography, utility(word))))))
+                report(context, node);
+        };
+        return { Literal: check, TemplateElement: check };
+    }),
+    "gap-layout": rule("Use flex/grid gap rather than sibling-margin space-x/space-y utilities.", (context) => {
+        const check = (node) => {
+            if (classContext(node) &&
+                stringValue(node).pipe(Option.exists((value) => Array.some(value.split(/\s+/u), (word) => /^space-[xy]-/u.test(utility(word))))))
+                report(context, node);
+        };
+        return { Literal: check, TemplateElement: check };
+    }),
+    "safe-type-line-height": rule("Use semantic line-height tokens; reject calculated divisions and ratios below one.", (context) => {
+        const check = (node) => {
+            if (stringValue(node).pipe(Option.exists((value) => Array.some(Array.fromIterable(value.matchAll(/--text-[a-z0-9-]+--line-height\s*:\s*(?<value>[^;"'`\n}]+)/giu)), (match) => {
+                const text = match.groups?.value?.trim() ?? "";
+                const number = Number(text);
+                return (/^calc\([^)]*\/[^)]*\)$/u.test(text) || (Number.isFinite(number) && number < 1));
+            }))))
+                report(context, node);
+        };
+        return { Literal: check, TemplateElement: check };
+    }),
+};

package/dist/web.d.ts

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

package/dist/web.js

@@ -0,0 +1,120 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+import { Array, Option, Predicate } from "effect";
+import { propertyName } from "./syntax.js";
+import { report, rule } from "./conventions/shared.js";
+import { typographyRules } from "./web/typography.js";
+const nameOf = (node) => node.type === "JSXIdentifier" ? Option.some(node.name) : propertyName(node);
+const routes = (filename) => /(?:^|\/)src\/routes\/.+\.[jt]sx?$/u.test(filename);
+const mdxKeys = [
+    "a",
+    "blockquote",
+    "code",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "img",
+    "li",
+    "ol",
+    "p",
+    "pre",
+    "table",
+    "tbody",
+    "td",
+    "th",
+    "thead",
+    "tr",
+    "ul",
+];
+export default eslintCompatPlugin({
+    meta: { name: "web" },
+    rules: {
+        ...typographyRules,
+        "no-context-nullish-default": rule("Use canonical Schema-owned metadata and preserve absent values rather than inventing defaults.", (context) => ({
+            LogicalExpression(node) {
+                if (node.operator === "??" &&
+                    node.left.type === "MemberExpression" &&
+                    Option.exists(propertyName(node.left.property), (name) => Array.contains(["description", "image", "title"], name)))
+                    report(context, node);
+            },
+        })),
+        "no-page-wrapper": rule("Compose the route in its owning route component rather than delegating to a page-sized wrapper.", (context) => ({
+            Property(node) {
+                if (routes(context.filename) &&
+                    Option.contains(propertyName(node.key), "component") &&
+                    node.value.type === "Identifier" &&
+                    /^[A-Z][A-Za-z]*Page$/u.test(node.value.name))
+                    report(context, node.value);
+            },
+        })),
+        "no-route-local-seo": rule("Reuse the canonical checked route metadata builder.", (context) => ({
+            CallExpression(node) {
+                if (node.callee.type === "Identifier" && node.callee.name === "seo")
+                    report(context, node);
+            },
+        })),
+        "no-route-local-markdown-negotiation": rule("Keep Markdown negotiation in the application's request middleware owner.", (context) => ({
+            ImportDeclaration(node) {
+                if (/[/]seo-aeo[/]markdown-negotiation$/u.test(node.source.value))
+                    report(context, node);
+            },
+        })),
+        "no-unscoped-server-functions": rule("Use the application's typed runtime boundary rather than creating TanStack server-function wrappers.", (context) => ({
+            ImportDeclaration(node) {
+                if (node.source.value === "@tanstack/react-start")
+                    Array.forEach(node.specifiers, (specifier) => {
+                        if (specifier.type === "ImportSpecifier" &&
+                            Option.exists(propertyName(specifier.imported), (name) => name === "createServerFn" || name === "createServerOnlyFn"))
+                            report(context, specifier);
+                    });
+            },
+        })),
+        "no-route-json-ld": rule("Let the canonical checked metadata owner encode JSON-LD scripts.", (context) => ({
+            Property(node) {
+                if (routes(context.filename) &&
+                    Option.contains(propertyName(node.key), "type") &&
+                    node.value.type === "Literal" &&
+                    node.value.value === "application/ld+json")
+                    report(context, node.value);
+            },
+        })),
+        "no-module-owned-public-asset-url": rule("Import module-owned image and pattern assets through the bundler's module graph.", (context) => ({
+            JSXAttribute(node) {
+                if (Option.contains(nameOf(node.name), "src") &&
+                    node.value?.type === "Literal" &&
+                    Predicate.isString(node.value.value) &&
+                    /^\/(?:images|patterns)\//u.test(node.value.value))
+                    report(context, node.value);
+            },
+        })),
+        "no-http-globals-in-seo": rule("Keep Web HTTP adaptation outside SEO and AEO domain modules.", (context) => ({
+            Identifier(node) {
+                if (/(?:\/(?:seo|seo-aeo)\/|\/packages\/aeo\/)/u.test(context.filename) &&
+                    Array.contains(["Request", "Response", "Headers"], node.name))
+                    report(context, node);
+            },
+        })),
+        "no-local-mdx-registry": rule("Reuse a shared MDX component registry rather than rebuilding it in a route or component.", (context) => ({
+            VariableDeclarator(node) {
+                if (node.id.type === "Identifier" &&
+                    (node.id.name === "mdxComponents" ||
+                        (node.id.name === "components" &&
+                            node.init?.type === "ObjectExpression" &&
+                            Array.some(node.init.properties, (property) => property.type === "Property" &&
+                                Option.exists(propertyName(property.key), (name) => Array.contains(mdxKeys, name))))))
+                    report(context, node.id);
+            },
+            JSXAttribute(node) {
+                if (Option.contains(nameOf(node.name), "components") &&
+                    node.parent.type === "JSXOpeningElement" &&
+                    Option.contains(nameOf(node.parent.name), "MDX") &&
+                    node.value?.type === "JSXExpressionContainer" &&
+                    node.value.expression.type === "ObjectExpression")
+                    report(context, node);
+            },
+        })),
+    },
+});