oxlint-plugin-arch 0.12.5 → 0.12.6

package/dist/index.js

@@ -1,3 +1,6 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
@@ -3358,9 +3361,684 @@ var copyDashes = defineRule27({
   }
 });
 
-// src/rules/files/files-components-only.ts
+// src/rules/effect/effect-layer-file.ts
 import { defineRule as defineRule28 } from "@oxlint/plugins";
 
+// src/utils/effect.utils.ts
+var effectBuilders = ["Effect.gen", "Effect.fn", "Effect.fnUntraced"];
+function effectIsBuilder(node, builders) {
+  const value = node ? astUnwrap(node) : undefined;
+  if (value?.type !== "CallExpression") {
+    return false;
+  }
+  const callee = value.callee.type === "CallExpression" ? value.callee.callee : value.callee;
+  return builders.has(astDottedName(callee) ?? "");
+}
+function effectGenerator(node, builders) {
+  const value = node ? astUnwrap(node) : undefined;
+  return effectIsBuilder(value, builders) ? value.arguments.find((argument) => argument.type === "FunctionExpression") : undefined;
+}
+function effectMatches(node, patterns) {
+  if (!node || node.type === "Super") {
+    return false;
+  }
+  const value = astUnwrap(node);
+  const target = value.type === "CallExpression" ? value.callee : value;
+  const name = astDottedName(target);
+  if (name !== undefined && optionsPatternsTest(patterns, name)) {
+    return true;
+  }
+  return value.type === "CallExpression" && target.type === "MemberExpression" && astMemberName(target) === "pipe" && effectMatches(target.object, patterns);
+}
+
+// src/rules/effect/effect-layer-file.ts
+var effectLayerFileDefaultLayers = ["^Layer\\.", "^HttpRouter\\.add(?:All)?$", "(?:^|\\.)layer[^.]*$"];
+var effectLayerFileDefaultServices = ["(?:^|\\.)of$", "^Context\\."];
+var effectLayerFileDefaultConstructors = [
+  "Layer.effect",
+  "Layer.effectContext",
+  "Layer.effectDiscard",
+  "Layer.scoped",
+  "Layer.scopedContext",
+  "Layer.scopedDiscard",
+  "Layer.sync",
+  "Layer.unwrap"
+];
+var effectLayerFile = defineRule28({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          layer: { type: "string" },
+          make: { type: "string" },
+          prefix: { type: "string" },
+          builders: { type: "array", items: { type: "string" } },
+          layers: optionsPatternSchema,
+          services: optionsPatternSchema,
+          constructors: { type: "array", items: { type: "string" } }
+        }
+      }
+    ],
+    messages: {
+      missing: "A layer file exports `{{layer}}`.",
+      notLayer: "`{{layer}}` is built with Layer: a Layer call, a Layer pipe, or a function returning one.",
+      builderName: "The Effect that builds the service is named `{{make}}`, one per layer file.",
+      moduleMethod: "Only `{{make}}` is an Effect at module level; move this into `{{make}}`, or into a utils file if two files use it.",
+      moduleHelper: "A layer file holds only `{{make}}`, {{prefix}}<Role> layers and `{{layer}}`; move this into `{{make}}`, or into a utils file if two files use it.",
+      localLayer: "A Layer other than `{{layer}}` is named {{prefix}}<Role> and is not exported.",
+      makeReturn: "`{{make}}` returns the service through its tag (Tag.of({ … })), a Context, or a Layer.",
+      inlineBuilder: "Build this layer from `{{make}}`, not an inline Effect: Layer.effect(Tag, {{make}}). One built layer per file."
+    }
+  },
+  createOnce(context) {
+    let layer = "layer";
+    let make = "make";
+    let prefix = "layer";
+    let builders = new Set(effectBuilders);
+    let layers = [];
+    let services = [];
+    let constructors = new Set(effectLayerFileDefaultConstructors);
+    const returned = (node) => {
+      const value = node ? astUnwrap(node) : node;
+      if (!value || !astIsInlineFunction(value)) {
+        return value;
+      }
+      return value.body?.type === "BlockStatement" ? returned(value.body.body.findLast((statement) => statement.type === "ReturnStatement")?.argument) : returned(value.body);
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        layer = options.layer ?? "layer";
+        make = options.make ?? "make";
+        prefix = options.prefix ?? "layer";
+        builders = new Set(options.builders ?? effectBuilders);
+        constructors = new Set(options.constructors ?? effectLayerFileDefaultConstructors);
+        layers = optionsPatterns(options.layers ?? effectLayerFileDefaultLayers);
+        services = [...optionsPatterns(options.services ?? effectLayerFileDefaultServices), ...layers];
+      },
+      Program(program) {
+        const data = { layer, make, prefix };
+        const declarators = program.body.flatMap((statement) => {
+          const declaration = astDeclaration(statement);
+          const exported = statement.type === "ExportNamedDeclaration";
+          return declaration?.type === "VariableDeclaration" ? declaration.declarations.map((node) => ({ exported, node, name: node.id.type === "Identifier" ? node.id.name : "" })) : [];
+        });
+        const exportedLayer = declarators.find(({ exported, name }) => exported && name === layer);
+        if (!exportedLayer) {
+          context.report({
+            node: program,
+            messageId: "missing",
+            data
+          });
+        } else if (!effectMatches(returned(exportedLayer.node.init), layers)) {
+          context.report({
+            node: exportedLayer.node,
+            messageId: "notLayer",
+            data
+          });
+        }
+        const wired = new Set;
+        const wiring = declarators.filter((item) => item === exportedLayer || effectMatches(item.node.init, layers));
+        astVisit(wiring.map(({ node }) => node.init), [], (call) => {
+          if (call.type !== "CallExpression" || !optionsPatternsTest(layers, astDottedName(call.callee) ?? "")) {
+            return;
+          }
+          for (const argument of call.arguments) {
+            const target = argument.type === "CallExpression" ? argument.callee : argument;
+            if (target.type === "Identifier") {
+              wired.add(target.name);
+            }
+          }
+        });
+        const locals = declarators.filter(({ exported }) => !exported);
+        const effects = locals.filter(({ node }) => effectIsBuilder(node.init, builders));
+        const builder = effects.find(({ name }) => name === make) ?? effects.find(({ name }) => wired.has(name));
+        if (builder && builder.name !== make) {
+          context.report({
+            node: builder.node,
+            messageId: "builderName",
+            data
+          });
+        }
+        for (const { node, name, exported } of declarators) {
+          const isLayer = effectMatches(node.init, layers);
+          const isEffect = effectIsBuilder(node.init, builders);
+          if (!exported && isEffect && name !== builder?.name) {
+            context.report({
+              node,
+              messageId: "moduleMethod",
+              data
+            });
+          }
+          if (!exported && !isEffect && !isLayer && name !== make) {
+            context.report({
+              node,
+              messageId: "moduleHelper",
+              data
+            });
+          }
+          if (isLayer && name !== layer && (exported || !name.startsWith(prefix) || !/^[A-Z]\w*$/.test(name.slice(prefix.length)))) {
+            context.report({
+              node,
+              messageId: "localLayer",
+              data
+            });
+          }
+        }
+        for (const statement of program.body) {
+          if (statement.type === "FunctionDeclaration") {
+            context.report({
+              node: statement,
+              messageId: "moduleHelper",
+              data
+            });
+          }
+        }
+        const generator = builder?.name === make ? effectGenerator(builder.node.init, builders) : undefined;
+        for (const statement of generator?.body?.body ?? []) {
+          if (statement.type === "ReturnStatement" && !effectMatches(statement.argument, services)) {
+            context.report({
+              node: statement,
+              messageId: "makeReturn",
+              data
+            });
+          }
+        }
+      },
+      CallExpression(node) {
+        if (!constructors.has(astDottedName(node.callee) ?? "")) {
+          return;
+        }
+        for (const argument of node.arguments) {
+          if (argument.type !== "SpreadElement" && (astIsInlineFunction(astUnwrap(argument)) || effectIsBuilder(argument, builders))) {
+            context.report({
+              node: argument,
+              messageId: "inlineBuilder",
+              data: { layer, make, prefix }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/effect/effect-layers.ts
+import { defineRule as defineRule29 } from "@oxlint/plugins";
+var effectLayersDefaultMerge = ["Layer.mergeAll"];
+var effectLayersDefaultProvide = ["Effect.provide", "Layer.provide", "Layer.provideMerge"];
+var effectLayersDefaultMin = 2;
+var effectLayersGroupSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    callees: { type: "array", items: { type: "string" } },
+    min: { type: "integer", minimum: 1 }
+  }
+};
+var effectLayers = defineRule29({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          merge: effectLayersGroupSchema,
+          provide: effectLayersGroupSchema,
+          indent: sourceIndentSchema
+        }
+      }
+    ],
+    messages: {
+      merge: "Put every layer in this merge on its own line.",
+      provide: "Put every layer in this array on its own line."
+    }
+  },
+  createOnce(context) {
+    let merge = new Set(effectLayersDefaultMerge);
+    let provide = new Set(effectLayersDefaultProvide);
+    let mergeMin = effectLayersDefaultMin;
+    let provideMin = effectLayersDefaultMin;
+    let indentUnit = sourceIndentUnit();
+    const check = (node) => {
+      const source = context.sourceCode;
+      const call = node.type === "CallExpression";
+      const items = call ? node.arguments : node.elements;
+      const present = items.filter((item) => item !== null);
+      const open = call ? source.getTokenAfter(node.typeArguments ?? node.callee) : source.getFirstToken(node);
+      const close = source.getLastToken(node);
+      if (open?.value !== (call ? "(" : "[") || close === null || present.length < (call ? mergeMin : provideMin)) {
+        return;
+      }
+      const packed = [open, ...present].some((item, index) => item.loc.end.line === (present.at(index) ?? close).loc.start.line);
+      if (!packed) {
+        return;
+      }
+      const text = source.text;
+      const newline = sourceNewline(text);
+      const base = sourceLineIndent(text, open.range[0]);
+      const gaps = sourceItemGaps(open.range[1], present, close.range[0]);
+      context.report({
+        node,
+        messageId: call ? "merge" : "provide",
+        fix: (fixer) => {
+          if (present.length !== items.length) {
+            return null;
+          }
+          return sourceRespace(fixer, text, gaps, (_, end) => `${newline}${base}${end ? "" : indentUnit}`);
+        }
+      });
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        merge = new Set(options.merge?.callees ?? effectLayersDefaultMerge);
+        provide = new Set(options.provide?.callees ?? effectLayersDefaultProvide);
+        mergeMin = options.merge?.min ?? effectLayersDefaultMin;
+        provideMin = options.provide?.min ?? effectLayersDefaultMin;
+        indentUnit = sourceIndentUnit(options.indent);
+      },
+      CallExpression(node) {
+        const name = astDottedName(node.callee);
+        if (name !== undefined && merge.has(name)) {
+          check(node);
+        }
+        if (name !== undefined && provide.has(name)) {
+          for (const argument of node.arguments) {
+            if (argument.type === "ArrayExpression") {
+              check(argument);
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/effect/effect-merge-pipe.ts
+import { defineRule as defineRule30 } from "@oxlint/plugins";
+var effectMergePipeDefaultMerge = ["Layer.mergeAll"];
+var effectMergePipeDefaultPipe = ["pipe", "Function.pipe"];
+var effectMergePipeDefaultMethods = ["pipe"];
+var effectMergePipe = defineRule30({
+  meta: {
+    type: "layout",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          merge: { type: "array", items: { type: "string" } },
+          pipe: { type: "array", items: { type: "string" } },
+          methods: { type: "array", items: { type: "string" } }
+        }
+      }
+    ],
+    messages: {
+      piped: "A merge that spans lines is never piped. Name it first, then pipe the name."
+    }
+  },
+  createOnce(context) {
+    let merge = new Set(effectMergePipeDefaultMerge);
+    let pipe = new Set(effectMergePipeDefaultPipe);
+    let methods = new Set(effectMergePipeDefaultMethods);
+    const isMultilineMerge = (node) => node?.type === "CallExpression" && merge.has(astDottedName(node.callee) ?? "") && !astIsOneLine(node);
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        merge = new Set(options.merge ?? effectMergePipeDefaultMerge);
+        pipe = new Set(options.pipe ?? effectMergePipeDefaultPipe);
+        methods = new Set(options.methods ?? effectMergePipeDefaultMethods);
+      },
+      CallExpression(node) {
+        const callee = node.callee;
+        const first = node.arguments.at(0);
+        if (callee.type === "MemberExpression" && methods.has(astMemberName(callee) ?? "") && isMultilineMerge(callee.object)) {
+          context.report({ node: callee.property, messageId: "piped" });
+        }
+        if (pipe.has(astDottedName(callee) ?? "") && first !== undefined && isMultilineMerge(first)) {
+          context.report({ node: first, messageId: "piped" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/effect/effect-schema-first.ts
+import { defineRule as defineRule31 } from "@oxlint/plugins";
+var effectSchemaFirstDefaultRuntime = [
+  "Effect",
+  "Layer",
+  "Stream",
+  "Context",
+  "Scope",
+  "Kysely",
+  "React",
+  "Fiber",
+  "Queue",
+  "PubSub",
+  "Ref",
+  "Deferred",
+  "ManagedRuntime",
+  "Sink",
+  "Channel",
+  "Request",
+  "Response",
+  "Headers",
+  "ReadableStream",
+  "WritableStream",
+  "Blob",
+  "File",
+  "AbortSignal",
+  "WebSocket",
+  "Socket",
+  "Worker",
+  "Uint8Array",
+  "ArrayBuffer",
+  "globalThis"
+];
+var effectSchemaFirstSections = {
+  values: ["VariableDeclaration", "ClassDeclaration"],
+  interfaces: ["TSInterfaceDeclaration"],
+  modules: ["TSModuleDeclaration"],
+  aliases: ["TSTypeAliasDeclaration"]
+};
+var effectSchemaFirstLabels = {
+  values: "Schemas and values",
+  interfaces: "interfaces",
+  modules: "`declare module`",
+  aliases: "type aliases"
+};
+var effectSchemaFirstDefaultOrder = ["values", ["interfaces", "modules"], "aliases"];
+var effectSchemaFirstSectionSchema = { type: "string", enum: ["values", "interfaces", "modules", "aliases"] };
+function effectSchemaFirstTypeName(node) {
+  if (node.type === "TSQualifiedName") {
+    const left = effectSchemaFirstTypeName(node.left);
+    return left === undefined ? undefined : `${left}.${node.right.name}`;
+  }
+  return astDottedName(node);
+}
+function effectSchemaFirstReference(node) {
+  if (node.type === "TSTypeReference") {
+    return effectSchemaFirstTypeName(node.typeName);
+  }
+  if (node.type === "TSTypeQuery") {
+    return effectSchemaFirstTypeName(node.exprName);
+  }
+  return node.type === "TSInterfaceHeritage" ? astDottedName(node.expression) : undefined;
+}
+var effectSchemaFirst = defineRule31({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          member: { type: "string" },
+          keep: optionsPatternSchema,
+          runtime: { type: "array", items: { type: "string" } },
+          rows: {
+            type: "object",
+            additionalProperties: false,
+            properties: { types: { type: "array", items: { type: "string" } }, suffix: { type: "string" } }
+          },
+          order: {
+            type: "array",
+            items: { anyOf: [effectSchemaFirstSectionSchema, { type: "array", items: effectSchemaFirstSectionSchema, minItems: 1 }] }
+          },
+          derived: {
+            type: "object",
+            additionalProperties: false,
+            properties: { first: { type: "boolean" }, sorted: { type: "boolean" } }
+          }
+        }
+      }
+    ],
+    messages: {
+      order: "Order a types file as {{order}}.",
+      schemaType: "Add `export type {{name}} = typeof {{name}}.{{member}}` to the final type block.",
+      typeOrder: "Move {{name}}: the type block lists the `typeof` aliases first, in Schema order, then the other aliases.",
+      dataInterface: "Every field of {{name}} fits a Schema: make it a Schema and derive its type.",
+      rowItem: "{{name}} is built from a database row: make it a Schema; only a `…{{suffix}}` alias may read the row type."
+    }
+  },
+  createOnce(context) {
+    let member = "Type";
+    let keep = [];
+    let runtime = new Set(effectSchemaFirstDefaultRuntime);
+    let rows;
+    let suffix = "Record";
+    let ranks = new Map;
+    let orderText = "";
+    let derivedFirst = true;
+    let derivedSorted = true;
+    const derives = (alias) => {
+      const annotation = alias.typeAnnotation;
+      const name = annotation.type === "TSTypeQuery" ? annotation.exprName : undefined;
+      return name?.type === "TSQualifiedName" && name.left.type === "Identifier" && name.left.name === alias.id.name && name.right.name === member;
+    };
+    const refers = (node, names) => astSome(node, (child) => {
+      if (child.type === "TSFunctionType" || child.type === "TSConstructorType" || child.type === "TSMethodSignature") {
+        return true;
+      }
+      return (effectSchemaFirstReference(child)?.split(".") ?? []).some((name) => names.has(name));
+    });
+    const readsRow = (node) => astSome(node, (child) => Boolean(rows?.has(effectSchemaFirstReference(child) ?? "")));
+    const checkOrder = (program) => {
+      let highest = 0;
+      for (const statement of program.body) {
+        const rank = ranks.get(astDeclaration(statement)?.type ?? "") ?? 0;
+        if (rank > 0 && rank < highest) {
+          context.report({
+            node: statement,
+            messageId: "order",
+            data: { order: orderText }
+          });
+        }
+        highest = Math.max(highest, rank);
+      }
+    };
+    const keptNames = (program, aliases, interfaces) => {
+      const kept = new Set(aliases.filter((alias) => refers(alias.typeAnnotation, runtime)).map((alias) => alias.id.name));
+      for (const statement of program.body) {
+        if (statement.type === "ImportDeclaration" && statement.source.value.startsWith(".")) {
+          for (const specifier of statement.specifiers) {
+            if (statement.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type") {
+              kept.add(specifier.local.name);
+            }
+          }
+        }
+      }
+      const names = new Set([...runtime, ...kept]);
+      let grew = true;
+      while (grew) {
+        grew = false;
+        for (const node of interfaces) {
+          const stays = node.body.body.length === 0 || Boolean(node.typeParameters) || optionsPatternsTest(keep, node.id.name) || refers(node, names);
+          if (!kept.has(node.id.name) && stays) {
+            names.add(node.id.name);
+            kept.add(node.id.name);
+            grew = true;
+          }
+        }
+      }
+      return kept;
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        member = options.member ?? "Type";
+        keep = optionsPatterns(options.keep);
+        runtime = new Set(options.runtime ?? effectSchemaFirstDefaultRuntime);
+        rows = options.rows ? new Set(options.rows.types ?? ["Kysely.Selectable"]) : undefined;
+        suffix = options.rows?.suffix ?? "Record";
+        const order = (options.order ?? effectSchemaFirstDefaultOrder).map((group) => [group].flat());
+        ranks = new Map(order.flatMap((group, index) => group.flatMap((section) => effectSchemaFirstSections[section].map((type) => [type, index + 1]))));
+        orderText = order.map((group) => group.map((section) => effectSchemaFirstLabels[section]).join(" and ")).join(", then ");
+        derivedFirst = options.derived?.first ?? true;
+        derivedSorted = options.derived?.sorted ?? true;
+      },
+      Program(program) {
+        checkOrder(program);
+        const declarations = program.body.flatMap((statement) => astDeclaration(statement) ?? []);
+        const aliases = declarations.filter((node) => node.type === "TSTypeAliasDeclaration");
+        const interfaces = declarations.filter((node) => node.type === "TSInterfaceDeclaration");
+        const schemas = declarations.flatMap((node) => node.type === "VariableDeclaration" ? node.declarations : []).map(({ id }) => id.type === "Identifier" ? id.name : "");
+        const exported = program.body.flatMap((statement) => statement.type === "ExportNamedDeclaration" && statement.declaration ? [statement.declaration] : []);
+        const typed = new Set(exported.flatMap((node) => node.type === "TSTypeAliasDeclaration" && derives(node) ? [node.id.name] : []));
+        for (const node of exported.flatMap((declaration) => declaration.type === "VariableDeclaration" ? declaration.declarations : [])) {
+          const isSchema = node.init?.type === "CallExpression" || node.init?.type === "MemberExpression";
+          if (isSchema && node.id.type === "Identifier" && !typed.has(node.id.name)) {
+            context.report({
+              node,
+              messageId: "schemaType",
+              data: { name: node.id.name, member }
+            });
+          }
+        }
+        let order = -1;
+        let other = false;
+        for (const alias of aliases) {
+          if (!derives(alias)) {
+            other = true;
+            continue;
+          }
+          const index = schemas.indexOf(alias.id.name);
+          if (derivedFirst && other || derivedSorted && index < order) {
+            context.report({
+              node: alias,
+              messageId: "typeOrder",
+              data: { name: alias.id.name }
+            });
+          }
+          order = Math.max(order, index);
+        }
+        const kept = keptNames(program, aliases, interfaces);
+        for (const node of interfaces) {
+          if (!kept.has(node.id.name)) {
+            context.report({
+              node,
+              messageId: "dataInterface",
+              data: { name: node.id.name }
+            });
+          }
+        }
+        for (const node of rows ? declarations : []) {
+          const fromRow = node.type === "TSTypeAliasDeclaration" && !node.id.name.endsWith(suffix) && readsRow(node.typeAnnotation) || node.type === "TSInterfaceDeclaration" && node.extends.some(readsRow);
+          if (fromRow) {
+            context.report({
+              node,
+              messageId: "rowItem",
+              data: { name: node.id.name, suffix }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/effect/effect-values-first.ts
+import { defineRule as defineRule32 } from "@oxlint/plugins";
+var effectValuesFirstDefaultPinned = [
+  "^Layer\\.",
+  "^Context\\.",
+  "^HttpRouter\\.add(?:All)?$",
+  "(?:^|\\.)of$",
+  "(?:^|\\.)layer[^.]*$",
+  "^Schema\\.(?:asserts|decode\\w*|encode\\w*|is|isSchema|isSchemaError|resolveAnnotations)$"
+];
+var effectValuesFirst = defineRule32({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          builders: { type: "array", items: { type: "string" } },
+          pinned: optionsPatternSchema
+        }
+      }
+    ],
+    messages: {
+      value: "`{{name}}` is a value declared after `{{after}}`: declare values first, then helpers and methods."
+    }
+  },
+  createOnce(context) {
+    let builders = new Set(effectBuilders);
+    let pinned = [];
+    const check = (statements) => {
+      const tied = new Set;
+      let first;
+      let barrier = false;
+      for (const statement of statements) {
+        const declaration = astDeclaration(statement);
+        if (declaration?.type === "FunctionDeclaration" && declaration.id) {
+          tied.add(declaration.id.name);
+          first ??= declaration.id.name;
+          continue;
+        }
+        if (declaration?.type !== "VariableDeclaration") {
+          barrier ||= statement.type === "ExpressionStatement" && first !== undefined;
+          continue;
+        }
+        for (const declarator of declaration.declarations) {
+          const init = declarator.init;
+          const names = astBindings(declarator.id).map((binding) => binding.name);
+          const helper = Boolean(init && (astIsInlineFunction(astUnwrap(init)) || effectIsBuilder(init, builders)));
+          const kept = helper || effectMatches(init, pinned) || astSome(init, (node) => node.type === "Identifier" && tied.has(node.name));
+          if (first !== undefined && !kept && !barrier) {
+            context.report({
+              node: declarator,
+              messageId: "value",
+              data: { name: names.join(", "), after: first }
+            });
+          }
+          if (kept) {
+            names.forEach((name) => tied.add(name));
+          }
+          barrier ||= kept && first !== undefined && astSome(init, (node) => node.type === "YieldExpression");
+          first ??= helper ? names.join(", ") : undefined;
+        }
+      }
+    };
+    const body = (init) => {
+      const value = init ? astUnwrap(init) : null;
+      const target = value && astIsInlineFunction(value) ? value : effectGenerator(value, builders);
+      return target?.body?.type === "BlockStatement" ? target.body.body : [];
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        builders = new Set(options.builders ?? effectBuilders);
+        pinned = optionsPatterns(options.pinned ?? effectValuesFirstDefaultPinned);
+      },
+      Program(program) {
+        check(program.body);
+        for (const statement of program.body) {
+          const declaration = astDeclaration(statement);
+          if (declaration?.type === "FunctionDeclaration") {
+            check(declaration.body?.body ?? []);
+          }
+          if (declaration?.type === "VariableDeclaration") {
+            declaration.declarations.forEach((declarator) => check(body(declarator.init)));
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/files/files-components-only.ts
+import { defineRule as defineRule33 } from "@oxlint/plugins";
+
 // src/utils/react.utils.ts
 function reactReturnsOutput(program, node) {
   const expressions = astReturnExpressions(node);
@@ -3431,7 +4109,7 @@ function reactIsComponent(program, candidate) {
 function componentName(basename2) {
   return basename2.replace(/\.(tsx?|jsx?)$/, "").replaceAll(/(?:^[-.]*|[-.]+)(.?)/g, (_, char) => char.toUpperCase());
 }
-var filesComponentsOnly = defineRule28({
+var filesComponentsOnly = defineRule33({
   meta: {
     type: "problem",
     schema: [
@@ -3519,7 +4197,7 @@ var filesComponentsOnly = defineRule28({
 });
 
 // src/rules/files/files-constants-only.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
+import { defineRule as defineRule34 } from "@oxlint/plugins";
 function unwrap(expression) {
   if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "TSInstantiationExpression") {
     return unwrap(expression.expression);
@@ -3574,7 +4252,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var filesConstantsOnly = defineRule29({
+var filesConstantsOnly = defineRule34({
   meta: {
     type: "problem",
     schema: [
@@ -3673,7 +4351,7 @@ var filesConstantsOnly = defineRule29({
 });
 
 // src/rules/files/files-domain-constants.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
+import { defineRule as defineRule35 } from "@oxlint/plugins";
 import { basename as basename2, dirname as dirname2 } from "node:path";
 function isData(expression) {
   const value = astUnwrap(expression);
@@ -3691,7 +4369,7 @@ function isData(expression) {
   }
   return value.type === "NewExpression" && value.callee.type === "Identifier" && ["Map", "Set"].includes(value.callee.name) && value.arguments[0]?.type === "ArrayExpression" && value.arguments[0].elements.length > 0;
 }
-var filesDomainConstants = defineRule30({
+var filesDomainConstants = defineRule35({
   meta: {
     type: "problem",
     schema: [
@@ -3756,11 +4434,11 @@ var filesDomainConstants = defineRule30({
 });
 
 // src/rules/files/files-exports.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule36 } from "@oxlint/plugins";
 function escapeRegExp(value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var filesExports = defineRule31({
+var filesExports = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -3841,12 +4519,12 @@ var filesExports = defineRule31({
 });
 
 // src/rules/files/files-externals.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { builtinModules as builtinModules2 } from "node:module";
 import { dirname as dirname3, join as join2 } from "node:path";
 var filesExternalsConfigs = "^(?:vite|next)\\.config\\.[cm]?[jt]s$";
-var filesExternals = defineRule32({
+var filesExternals = defineRule37({
   meta: {
     type: "problem",
     schema: [
@@ -3939,7 +4617,7 @@ var filesExternals = defineRule32({
 });
 
 // src/rules/files/files-factory-keys.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
+import { defineRule as defineRule38 } from "@oxlint/plugins";
 function returnedObject(expression) {
   if (expression?.type === "TSAsExpression" || expression?.type === "TSSatisfiesExpression" || expression?.type === "TSTypeAssertion" || expression?.type === "TSNonNullExpression") {
     return returnedObject(expression.expression);
@@ -3950,7 +4628,7 @@ function compileKeys(pattern, keys, requireKeys) {
   const allowedList = keys.concat(requireKeys.filter((key) => !keys.includes(key)));
   return { patterns: optionsPatternsWithEmpty(pattern), allowed: new Set(allowedList), allowedList, required: requireKeys };
 }
-var filesFactoryKeys = defineRule33({
+var filesFactoryKeys = defineRule38({
   meta: {
     type: "problem",
     schema: [
@@ -4068,8 +4746,8 @@ var filesFactoryKeys = defineRule33({
 });
 
 // src/rules/files/files-helpers.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
-var filesHelpers = defineRule34({
+import { defineRule as defineRule39 } from "@oxlint/plugins";
+var filesHelpers = defineRule39({
   meta: {
     type: "problem",
     schema: [
@@ -4117,8 +4795,8 @@ var filesHelpers = defineRule34({
 });
 
 // src/rules/files/files-no-functions.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
-var filesNoFunctions = defineRule35({
+import { defineRule as defineRule40 } from "@oxlint/plugins";
+var filesNoFunctions = defineRule40({
   meta: {
     type: "problem",
     schema: [
@@ -4172,8 +4850,8 @@ var filesNoFunctions = defineRule35({
 });
 
 // src/rules/files/files-restricted.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
-var filesRestricted = defineRule36({
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+var filesRestricted = defineRule41({
   meta: {
     type: "problem",
     schema: [
@@ -4205,7 +4883,7 @@ var filesRestricted = defineRule36({
 });
 
 // src/rules/files/files-route.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule42 } from "@oxlint/plugins";
 function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
   astVisit(item.node.body, [item.node], (node) => {
     if (banIntrinsicJsx && node.type === "JSXOpeningElement" && node.name.type === "JSXIdentifier" && /^[a-z]/.test(node.name.name)) {
@@ -4225,7 +4903,7 @@ function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
-var filesRoute = defineRule37({
+var filesRoute = defineRule42({
   meta: {
     type: "problem",
     schema: [
@@ -4295,7 +4973,7 @@ var filesRoute = defineRule37({
 });
 
 // src/rules/files/files-types-only.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
+import { defineRule as defineRule43 } from "@oxlint/plugins";
 function runtimeImportLocalNames(statement) {
   return statement.specifiers.flatMap((specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type" ? [specifier.local.name] : []);
 }
@@ -4464,7 +5142,7 @@ function runtimeKind(node) {
   }
   return node.type === "FunctionDeclaration" ? "function" : "variable";
 }
-var filesTypesOnly = defineRule38({
+var filesTypesOnly = defineRule43({
   meta: {
     type: "problem",
     schema: [
@@ -4572,8 +5250,8 @@ var filesTypesOnly = defineRule38({
 });
 
 // src/rules/layout/layout-arrow-body.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
-var layoutArrowBody = defineRule39({
+import { defineRule as defineRule44 } from "@oxlint/plugins";
+var layoutArrowBody = defineRule44({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4625,12 +5303,12 @@ var layoutArrowBody = defineRule39({
 });
 
 // src/rules/layout/layout-call-arguments.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
+import { defineRule as defineRule45 } from "@oxlint/plugins";
 function layoutCallArgumentsHuggable(node) {
   return astIsInlineFunction(node) || node.type === "ObjectExpression" || node.type === "ArrayExpression" || astIsCall(node) && node.arguments.length === 1 && (node.callee.type !== "MemberExpression" || astIsOneLine(node.callee)) && node.arguments.every(layoutCallArgumentsHuggable);
 }
 var layoutCallArgumentsMax = { type: "integer", minimum: 1 };
-var layoutCallArguments = defineRule40({
+var layoutCallArguments = defineRule45({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4812,12 +5490,12 @@ var layoutCallArguments = defineRule40({
 });
 
 // src/rules/layout/layout-call-array.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
+import { defineRule as defineRule46 } from "@oxlint/plugins";
 var layoutCallArrayDefaultCallees = ["Promise.all", "Promise.allSettled"];
 function layoutCallArrayRoot(node) {
   return node.type === "MemberExpression" ? layoutCallArrayRoot(node.object) : node;
 }
-var layoutCallArray = defineRule41({
+var layoutCallArray = defineRule46({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4933,7 +5611,7 @@ var layoutCallArray = defineRule41({
 });
 
 // src/rules/layout/layout-call-depth.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
+import { defineRule as defineRule47 } from "@oxlint/plugins";
 function layoutCallDepthOuter(node) {
   const parent = node.parent;
   if (!parent || parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression" || parent.type.endsWith("Statement")) {
@@ -4941,7 +5619,7 @@ function layoutCallDepthOuter(node) {
   }
   return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : layoutCallDepthOuter(parent);
 }
-var layoutCallDepth = defineRule42({
+var layoutCallDepth = defineRule47({
   meta: {
     type: "layout",
     schema: [
@@ -4980,8 +5658,8 @@ var layoutCallDepth = defineRule42({
 });
 
 // src/rules/layout/layout-chain.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
-var layoutChain = defineRule43({
+import { defineRule as defineRule48 } from "@oxlint/plugins";
+var layoutChain = defineRule48({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5100,8 +5778,8 @@ var layoutChain = defineRule43({
 });
 
 // src/rules/layout/layout-items.ts
-import { defineRule as defineRule44 } from "@oxlint/plugins";
-var layoutItems = defineRule44({
+import { defineRule as defineRule49 } from "@oxlint/plugins";
+var layoutItems = defineRule49({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5156,8 +5834,8 @@ var layoutItems = defineRule44({
 });
 
 // src/rules/layout/layout-jsx-attributes.ts
-import { defineRule as defineRule45 } from "@oxlint/plugins";
-var layoutJsxAttributes = defineRule45({
+import { defineRule as defineRule50 } from "@oxlint/plugins";
+var layoutJsxAttributes = defineRule50({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5245,8 +5923,8 @@ var layoutJsxAttributes = defineRule45({
 });
 
 // src/rules/layout/layout-key-value.ts
-import { defineRule as defineRule46 } from "@oxlint/plugins";
-var layoutKeyValue = defineRule46({
+import { defineRule as defineRule51 } from "@oxlint/plugins";
+var layoutKeyValue = defineRule51({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5282,7 +5960,7 @@ var layoutKeyValue = defineRule46({
 });
 
 // src/rules/layout/layout-object.ts
-import { defineRule as defineRule47 } from "@oxlint/plugins";
+import { defineRule as defineRule52 } from "@oxlint/plugins";
 function layoutObjectIsWhitespace(text) {
   return /^[\t\n\r\f ]*$/.test(text);
 }
@@ -5290,7 +5968,7 @@ function layoutObjectIsFlat(property) {
   const value = property.type === "SpreadElement" ? property.argument : property.value;
   return astIsOneLine(property) && (property.type === "SpreadElement" || !property.method && property.kind === "init") && value.type !== "ObjectExpression" && value.type !== "ArrayExpression" && !astIsInlineFunction(value);
 }
-var layoutObject = defineRule47({
+var layoutObject = defineRule52({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5407,7 +6085,7 @@ var layoutObject = defineRule47({
 });
 
 // src/rules/layout/layout-padding.ts
-import { defineRule as defineRule48 } from "@oxlint/plugins";
+import { defineRule as defineRule53 } from "@oxlint/plugins";
 var layoutPaddingControl = new Set([
   "IfStatement",
   "ForStatement",
@@ -5436,7 +6114,7 @@ function layoutPaddingKind(node) {
 function layoutPaddingIsMultilineVariable(node, kind) {
   return kind === "variable" && node.loc.start.line !== node.loc.end.line;
 }
-var layoutPadding = defineRule48({
+var layoutPadding = defineRule53({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5525,8 +6203,8 @@ var layoutPadding = defineRule48({
 });
 
 // src/rules/layout/layout-pipe.ts
-import { defineRule as defineRule49 } from "@oxlint/plugins";
-var layoutPipe = defineRule49({
+import { defineRule as defineRule54 } from "@oxlint/plugins";
+var layoutPipe = defineRule54({
   meta: {
     type: "layout",
     messages: {
@@ -5557,7 +6235,7 @@ var layoutPipe = defineRule49({
 });
 
 // src/rules/layout/layout-ternary.ts
-import { defineRule as defineRule50 } from "@oxlint/plugins";
+import { defineRule as defineRule55 } from "@oxlint/plugins";
 function layoutTernaryLines(node) {
   return node.loc.end.line - node.loc.start.line + 1;
 }
@@ -5565,7 +6243,7 @@ function layoutTernaryBreak(between, operator, newline) {
   const at = between.indexOf(operator);
   return `${between.slice(0, at).trimEnd()}${newline}${operator} ${between.slice(at + 1).trimStart()}`;
 }
-var layoutTernary = defineRule50({
+var layoutTernary = defineRule55({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -5681,9 +6359,9 @@ var layoutTernary = defineRule50({
 });
 
 // src/rules/naming/naming-declarations.ts
-import { defineRule as defineRule51 } from "@oxlint/plugins";
+import { defineRule as defineRule56 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule51({
+var namingDeclarations = defineRule56({
   meta: {
     type: "problem",
     schema: [
@@ -5760,7 +6438,7 @@ var namingDeclarations = defineRule51({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule52 } from "@oxlint/plugins";
+import { defineRule as defineRule57 } from "@oxlint/plugins";
 var namingExportsScopeProperties = {
   scope: { type: "string", enum: ["exports", "functions", "declarations"] },
   types: { type: "boolean" },
@@ -5786,7 +6464,7 @@ function matchTemplate(basename3, template, placeholder = "[a-z0-9-]+") {
   }
   return new RegExp(`^${pattern}$`).exec(basename3)?.groups ?? null;
 }
-var namingExports = defineRule52({
+var namingExports = defineRule57({
   meta: {
     type: "problem",
     schema: {
@@ -5923,10 +6601,10 @@ var namingExports = defineRule52({
 });
 
 // src/rules/naming/naming-file.ts
-import { defineRule as defineRule53 } from "@oxlint/plugins";
+import { defineRule as defineRule58 } from "@oxlint/plugins";
 import { readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
-var namingFile = defineRule53({
+var namingFile = defineRule58({
   meta: {
     type: "problem",
     schema: {
@@ -5996,9 +6674,9 @@ var namingFile = defineRule53({
 });
 
 // src/rules/naming/naming-folder.ts
-import { defineRule as defineRule54 } from "@oxlint/plugins";
+import { defineRule as defineRule59 } from "@oxlint/plugins";
 import { posix as posix2 } from "node:path";
-var namingFolder = defineRule54({
+var namingFolder = defineRule59({
   meta: {
     type: "problem",
     schema: [
@@ -6072,9 +6750,9 @@ var reactDynamicClasses = astSelectorRule(':matches(JSXAttribute[name.name="clas
 var reactEmptyEffect = astSelectorRule(':matches(CallExpression[callee.name=/^use(Layout)?Effect$/], CallExpression[callee.object.name="React"][callee.property.name=/^use(Layout)?Effect$/]) > :matches(ArrowFunctionExpression, FunctionExpression) > BlockStatement[body.length=0]', "Remove the empty effect.");
 
 // src/rules/react/react-memo.ts
-import { defineRule as defineRule55 } from "@oxlint/plugins";
+import { defineRule as defineRule60 } from "@oxlint/plugins";
 var reactMemoNames = ["memo", "useMemo", "useCallback"];
-var reactMemo = defineRule55({
+var reactMemo = defineRule60({
   meta: {
     type: "problem",
     schema: [],
@@ -6109,7 +6787,7 @@ var reactMemo = defineRule55({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule56 } from "@oxlint/plugins";
+import { defineRule as defineRule61 } from "@oxlint/plugins";
 function reactPropsTarget(node) {
   if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
     return { fn: node };
@@ -6136,7 +6814,7 @@ function reactIsPassThrough(type) {
   const argument = type.typeArguments?.params.length === 1 ? type.typeArguments.params[0] : undefined;
   return name.type === "Identifier" && name.name === "ComponentProps" && (argument?.type === "TSTypeQuery" || argument?.type === "TSLiteralType" && argument.literal.type === "Literal" && typeof argument.literal.value === "string");
 }
-var reactProps = defineRule56({
+var reactProps = defineRule61({
   meta: {
     type: "problem",
     schema: [
@@ -6235,7 +6913,7 @@ var reactProps = defineRule56({
 });
 
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule57 } from "@oxlint/plugins";
+import { defineRule as defineRule62 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -6271,7 +6949,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule57({
+var schemasInline = defineRule62({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -6320,11 +6998,11 @@ var schemasInline = defineRule57({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule58 } from "@oxlint/plugins";
+import { defineRule as defineRule63 } from "@oxlint/plugins";
 var schemasLocalImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var schemasLocalConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
 var schemasLocalCalls = ["config", "prettifyError", "treeifyError", "flattenError", "formatError"];
-var schemasLocal = defineRule58({
+var schemasLocal = defineRule63({
   meta: {
     type: "problem",
     schema: [
@@ -6337,6 +7015,8 @@ var schemasLocal = defineRule58({
           calls: { type: "array", items: { type: "string" } },
           allow: { type: "array", items: { type: "string" } },
           patterns: { type: "array", items: { type: "string" } },
+          imports: { type: "boolean" },
+          values: { type: "boolean" },
           message: { type: "string" },
           importMessage: { type: "string" },
           constructionMessage: { type: "string" }
@@ -6356,6 +7036,32 @@ var schemasLocal = defineRule58({
     let pending = [];
     let importMessage = schemasLocalImportMessage;
     let constructionMessage = schemasLocalConstructionMessage;
+    let imports = true;
+    let values = false;
+    let inline = new Set;
+    function isInline(node) {
+      if (inline.size === 0) {
+        return false;
+      }
+      for (let parent = node.parent;parent; parent = parent.parent) {
+        if (inline.has(parent)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function readsLocal(node) {
+      const scope = context.sourceCode.getScope(node);
+      return astSome(node, (child) => {
+        if (child.type !== "Identifier") {
+          return false;
+        }
+        const parent = child.parent;
+        const named = parent.type === "MemberExpression" && parent.property === child && !parent.computed || parent.type === "Property" && parent.key === child && !parent.computed && !parent.shorthand;
+        const type = named ? undefined : boundariesDeclaredVariable(scope, child.name)?.scope.type;
+        return type !== undefined && type !== "module" && type !== "global";
+      });
+    }
     function isAllowedCall(node, member) {
       return member?.type === "MemberExpression" && member.object === node && !member.computed && member.property.type === "Identifier" && calls.has(member.property.name) && member.parent.type === "CallExpression" && member.parent.callee === member;
     }
@@ -6363,6 +7069,9 @@ var schemasLocal = defineRule58({
       return packages.has(source) || [...packages].some((name) => source.startsWith(`${name}/`));
     }
     function reportRuntimeImport(node, source) {
+      if (!imports) {
+        return;
+      }
       context.report({
         node,
         messageId: "runtimeImport",
@@ -6387,6 +7096,9 @@ var schemasLocal = defineRule58({
         pending = [];
         importMessage = options.importMessage ?? options.message ?? schemasLocalImportMessage;
         constructionMessage = options.constructionMessage ?? options.message ?? schemasLocalConstructionMessage;
+        imports = options.imports ?? true;
+        values = options.values ?? false;
+        inline = new Set;
         if ((options.allow ?? []).some((suffix) => filename.endsWith(suffix)) || (options.patterns ?? []).some((pattern) => new RegExp(pattern).test(filename))) {
           return false;
         }
@@ -6409,7 +7121,7 @@ var schemasLocal = defineRule58({
         pending.push({ node, locals });
       },
       "Program:exit"() {
-        const runtime = pending.filter(({ node, locals }) => context.sourceCode.getDeclaredVariables(node).filter((variable) => locals.includes(variable.name)).some((variable) => variable.references.length === 0 || variable.references.some((reference) => !isAllowedCall(reference.identifier, reference.identifier.parent))));
+        const runtime = pending.filter(({ node, locals }) => context.sourceCode.getDeclaredVariables(node).filter((variable) => locals.includes(variable.name)).some((variable) => variable.references.length === 0 || variable.references.some((reference) => !isAllowedCall(reference.identifier, reference.identifier.parent) && !isInline(reference.identifier))));
         for (const { node } of runtime) {
           reportRuntimeImport(node, node.source.value);
         }
@@ -6424,6 +7136,10 @@ var schemasLocal = defineRule58({
         if (root.type !== "Identifier" || !constructors.has(root.name) || node.callee.type === "MemberExpression" && node.callee.object === root && isAllowedCall(root, root.parent)) {
           return;
         }
+        if (values && (isInline(node) || readsLocal(node))) {
+          inline.add(node);
+          return;
+        }
         context.report({
           node,
           messageId: "construction",
@@ -6435,8 +7151,8 @@ var schemasLocal = defineRule58({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule59 } from "@oxlint/plugins";
-var schemasRederive = defineRule59({
+import { defineRule as defineRule64 } from "@oxlint/plugins";
+var schemasRederive = defineRule64({
   meta: {
     type: "problem",
     schema: [
@@ -6482,7 +7198,7 @@ var schemasRederive = defineRule59({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule60 } from "@oxlint/plugins";
+import { defineRule as defineRule65 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -6496,7 +7212,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule60({
+var schemasSingleUse = defineRule65({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -6572,7 +7288,7 @@ var schemasSingleUse = defineRule60({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule61 } from "@oxlint/plugins";
+import { defineRule as defineRule66 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -6762,7 +7478,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule61({
+var testsAssertions = defineRule66({
   meta: {
     type: "problem",
     schema: [
@@ -6888,8 +7604,8 @@ var testsAssertions = defineRule61({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule62 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule62({
+import { defineRule as defineRule67 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule67({
   meta: {
     type: "problem",
     schema: [
@@ -6945,7 +7661,7 @@ var testsConcurrentDb = defineRule62({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule63 } from "@oxlint/plugins";
+import { defineRule as defineRule68 } from "@oxlint/plugins";
 var testsModifiersNames = ["test", "it", "describe", "suite"];
 var testsModifiersPackages = new Set(["vitest", "bun:test", "@playwright/test", "@jest/globals"]);
 var testsModifiersBanned = ["only", "skip", "todo"];
@@ -6964,7 +7680,7 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule63({
+var testsModifiers = defineRule68({
   meta: {
     type: "problem",
     schema: [
@@ -7018,9 +7734,9 @@ var testsModifiers = defineRule63({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule64 } from "@oxlint/plugins";
+import { defineRule as defineRule69 } from "@oxlint/plugins";
 var testsTitlesModifiers = ["only", "skip", "concurrent", "sequential", "todo", "each", "for"];
-var testsTitles = defineRule64({
+var testsTitles = defineRule69({
   meta: {
     type: "suggestion",
     schema: [
@@ -7098,11 +7814,11 @@ var testsTitles = defineRule64({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule65 } from "@oxlint/plugins";
+import { defineRule as defineRule70 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule65({
+var typesDeclarations = defineRule70({
   meta: {
     type: "problem",
     schema: [
@@ -7144,8 +7860,73 @@ var typesDeclarations = defineRule65({
   }
 });
 
+// src/rules/types/types-duplicate.ts
+import { defineRule as defineRule71 } from "@oxlint/plugins";
+var typesDuplicate = defineRule71({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          structs: { type: "array", items: { type: "string" } },
+          min: { type: "integer", minimum: 1 }
+        }
+      }
+    ],
+    messages: { duplicate: "{{name}} has the same members as {{first}}; use {{first}}, or derive one from the other." }
+  },
+  createOnce(context) {
+    let structs = new Set(["Schema.Struct"]);
+    let min = 2;
+    let seen = new Map;
+    const check = (node, name, kind, members) => {
+      if (members.length < min) {
+        return;
+      }
+      const signature = members.map((item) => context.sourceCode.getText(item).replaceAll(/\breadonly\s+/g, "").replaceAll(/\s+/g, "").replace(/[;,]$/, "")).sort().join(";");
+      const key = `${kind}:${signature}`;
+      const first = seen.get(key);
+      if (first === undefined) {
+        seen.set(key, name);
+        return;
+      }
+      context.report({
+        node,
+        messageId: "duplicate",
+        data: { name, first }
+      });
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        structs = new Set(options.structs ?? ["Schema.Struct"]);
+        min = options.min ?? 2;
+        seen = new Map;
+      },
+      TSInterfaceDeclaration(node) {
+        const heritage = node.extends.map((item) => context.sourceCode.getText(item)).join(",");
+        check(node, node.id.name, `type:${heritage}`, node.body.body);
+      },
+      TSTypeAliasDeclaration(node) {
+        if (node.typeAnnotation.type === "TSTypeLiteral") {
+          check(node, node.id.name, "type:", node.typeAnnotation.members);
+        }
+      },
+      VariableDeclarator(node) {
+        const init = node.init ? astUnwrap(node.init) : undefined;
+        const fields = init?.type === "CallExpression" && structs.has(astDottedName(init.callee) ?? "") ? init.arguments[0] : undefined;
+        if (fields?.type === "ObjectExpression" && node.id.type === "Identifier") {
+          check(node, node.id.name, "struct", fields.properties);
+        }
+      }
+    };
+  }
+});
+
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule66 } from "@oxlint/plugins";
+import { defineRule as defineRule72 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -7157,7 +7938,7 @@ function importedAliasTarget(declaration, imports) {
   const { name } = type.typeName;
   return imports.has(name) && !declaration.typeParameters?.params.some((parameter) => parameter.name.name === name) ? name : undefined;
 }
-var typesImportedAlias = defineRule66({
+var typesImportedAlias = defineRule72({
   meta: {
     type: "problem",
     schema: [],
@@ -7219,7 +8000,7 @@ var typesImportedAlias = defineRule66({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule67 } from "@oxlint/plugins";
+import { defineRule as defineRule73 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -7229,7 +8010,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule67({
+var typesInline = defineRule73({
   meta: {
     type: "problem",
     schema: [
@@ -7305,8 +8086,8 @@ var typesInline = defineRule67({
 var typesLocalAlias = astSelectorRule("TSTypeAliasDeclaration", "Local component/hook contracts use interfaces named for their owner. Derived or reusable aliases belong in domain types; do not substitute an empty interface.");
 
 // src/rules/types/types-namespace-import.ts
-import { defineRule as defineRule68 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule68({
+import { defineRule as defineRule74 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule74({
   meta: {
     type: "suggestion",
     schema: [
@@ -7348,8 +8129,8 @@ var typesNamespaceImport = defineRule68({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule69 } from "@oxlint/plugins";
-var typesService = defineRule69({
+import { defineRule as defineRule75 } from "@oxlint/plugins";
+var typesService = defineRule75({
   meta: {
     type: "problem",
     schema: [
@@ -7399,12 +8180,12 @@ var typesService = defineRule69({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule70 } from "@oxlint/plugins";
+import { defineRule as defineRule76 } from "@oxlint/plugins";
 function isCatchName(node) {
   const key = "key" in node && !(("computed" in node) && node.computed) ? node.key : undefined;
   return key?.type === "Identifier" && key.name === "catch";
 }
-var typesUnknown = defineRule70({
+var typesUnknown = defineRule76({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {
@@ -7459,6 +8240,11 @@ var src_default = eslintCompatPlugin({
     "comments-code": commentsCode,
     "comments-directives": commentsDirectives,
     "copy-dashes": copyDashes,
+    "effect-layer-file": effectLayerFile,
+    "effect-layers": effectLayers,
+    "effect-merge-pipe": effectMergePipe,
+    "effect-schema-first": effectSchemaFirst,
+    "effect-values-first": effectValuesFirst,
     "files-components-only": filesComponentsOnly,
     "files-constants-only": filesConstantsOnly,
     "files-domain-constants": filesDomainConstants,
@@ -7500,6 +8286,7 @@ var src_default = eslintCompatPlugin({
     "tests-modifiers": testsModifiers,
     "tests-titles": testsTitles,
     "types-declarations": typesDeclarations,
+    "types-duplicate": typesDuplicate,
     "types-imported-alias": typesImportedAlias,
     "types-inline": typesInline,
     "types-local-alias": typesLocalAlias,