@commonplaces/oxlint-plugin 0.3.1 → 0.5.0

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,91 @@ 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";
+        };
+    })[];
+};
+export { default as style } from "./style.js";

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,8 @@ 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],
+};
+export { default as style } from "./style.js";

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

@@ -596,6 +596,23 @@ const layerExpression = (context, expression, visited = []) => {
         if (Array.isReadonlyArrayEmpty(expression.arguments)) {
             return layerExpression(context, expression.callee.object, next);
         }
+        // Completed Match.value pipelines return their branch values, including
+        // Layers. Inline native callbacks remain allowed; an owned factory does not.
+        const completesMatch = Array.last(expression.arguments).pipe(Option.exists((argument) => scopedEffectReference(context, argument.type === "CallExpression" ? argument.callee : argument).pipe(Option.exists((reference) => isExport(reference, "effect/Match", "exhaustive") ||
+            isExport(reference, "effect/Match", "orElse")))));
+        const valueMatch = expression.callee.object.type === "CallExpression" &&
+            scopedEffectReference(context, expression.callee.object.callee).pipe(Option.exists((reference) => isExport(reference, "effect/Match", "value")));
+        const branchReturnsLayer = (argument) => argument.type === "CallExpression" &&
+            scopedEffectReference(context, argument.callee).pipe(Option.exists((reference) => reference.module === "effect/Match")) &&
+            Array.some((callback) => (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression") &&
+                Option.fromNullishOr(callback.body).pipe(Option.exists((body) => body.type === "BlockStatement"
+                    ? returnsLayer(context, body)
+                    : layerExpression(context, body, next))))(argument.arguments);
+        if (valueMatch &&
+            completesMatch &&
+            Array.some(branchReturnsLayer)(expression.arguments)) {
+            return true;
+        }
         return transforms(expression.arguments);
     }
     return false;
@@ -2240,12 +2257,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 +2394,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 +2411,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/style.d.ts

@@ -0,0 +1,4 @@
+import type { OxlintConfig } from "oxlint";
+/** Optional shared style checks. Extend before strict and the project policy. */
+declare const style: OxlintConfig;
+export default style;

package/dist/style.js

@@ -0,0 +1,38 @@
+import { Array, Record } from "effect";
+import core from "ultracite/oxlint/core";
+import react from "ultracite/oxlint/react";
+import vitest from "ultracite/oxlint/vitest";
+/** Optional shared style checks. Extend before strict and the project policy. */
+const style = {
+    extends: [
+        core,
+        {
+            ...react,
+            // Leave these correctness rules to the host category settings. Explicit
+            // upstream "off" values would beat strict's correctness category.
+            rules: Record.filter(react.rules ?? {}, (_, name) => name !== "jsx-a11y/no-autofocus" && name !== "react/forward-ref-uses-ref"),
+        },
+        {
+            ...vitest,
+            // Keep the host's correctness check for test titles in test files too.
+            overrides: Array.map(vitest.overrides ?? [], (override) => ({
+                ...override,
+                rules: Record.filter(override.rules ?? {}, (_, name) => name !== "vitest/valid-title"),
+            })),
+        },
+    ],
+    rules: {
+        "unicorn/no-array-for-each": "off",
+        "unicorn/no-array-sort": "off",
+        "unicorn/throw-new-error": "off",
+        "no-redeclare": "off",
+        "react/function-component-definition": "off",
+        "sort-keys": "off",
+        "func-names": "off",
+        "func-style": "off",
+        "no-use-before-define": "off",
+        "no-inline-comments": "off",
+        "typescript/consistent-return": "off",
+    },
+};
+export default style;

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;
+};