oxlint-plugin-arch 0.12.2 → 0.12.4

package/dist/index.js

@@ -225,6 +225,39 @@ function astSelectorRule(selector, message) {
     }
   });
 }
+function astIsOneLine(node) {
+  return node.loc.start.line === node.loc.end.line;
+}
+function astIsInlineFunction(node) {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+function astIsCall(node) {
+  return node.type === "CallExpression" || node.type === "NewExpression";
+}
+function astIsPipe(node) {
+  return node.callee.type === "MemberExpression" && astMemberName(node.callee) === "pipe";
+}
+function astChildren(node) {
+  return Object.entries(node).filter(([key]) => !astSkippedKeys.has(key)).map(([, child]) => child);
+}
+function astSome(value, test, enter = () => true) {
+  if (Array.isArray(value)) {
+    return value.some((child) => astSome(child, test, enter));
+  }
+  return astIsNode(value) && (test(value) || enter(value) && astChildren(value).some((child) => astSome(child, test, enter)));
+}
+function astCallDepth(value) {
+  if (Array.isArray(value)) {
+    return Math.max(0, ...value.map(astCallDepth));
+  }
+  if (!astIsNode(value) || astIsInlineFunction(value)) {
+    return 0;
+  }
+  if (astIsCall(value)) {
+    return Math.max(value.arguments.length === 0 ? 0 : 1 + astCallDepth(value.arguments), astCallDepth(value.callee));
+  }
+  return astCallDepth(astChildren(value));
+}
 
 // src/rules/backend/backend-orpc-output.ts
 function backendFindChainCall(expression, method) {
@@ -1786,9 +1819,59 @@ var boundariesTokenOwner = defineRule10({
   }
 });
 
-// src/rules/code/code-constructor.ts
+// src/rules/code/code-branch-once.ts
 import { defineRule as defineRule11 } from "@oxlint/plugins";
-var codeConstructor = defineRule11({
+function codeBranchOnceSubjects(node, source) {
+  if (node.type === "LogicalExpression") {
+    return [...codeBranchOnceSubjects(node.left, source), ...codeBranchOnceSubjects(node.right, source)];
+  }
+  if (node.type === "UnaryExpression" && node.operator === "!") {
+    return codeBranchOnceSubjects(node.argument, source);
+  }
+  if (node.type !== "BinaryExpression" || node.operator !== "===" && node.operator !== "!==") {
+    return [];
+  }
+  const sides = [node.left, node.right];
+  const member = sides.find((side) => side.type === "MemberExpression");
+  const literal = sides.some((side) => side.type === "Literal" && typeof side.value === "string");
+  return member && literal ? [source.getText(member)] : [];
+}
+var codeBranchOnce = defineRule11({
+  meta: {
+    type: "suggestion",
+    messages: {
+      once: "{{subject}} is compared to a string in {{count}} ternaries in this file. Branch on it once and return a record."
+    }
+  },
+  createOnce(context) {
+    let groups = new Map;
+    return {
+      before() {
+        groups = new Map;
+      },
+      ConditionalExpression(node) {
+        for (const subject of new Set(codeBranchOnceSubjects(node.test, context.sourceCode))) {
+          groups.set(subject, [...groups.get(subject) ?? [], node]);
+        }
+      },
+      "Program:exit"() {
+        for (const [subject, ternaries] of groups) {
+          for (const node of ternaries.length > 1 ? ternaries : []) {
+            context.report({
+              node,
+              messageId: "once",
+              data: { subject, count: String(ternaries.length) }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/code/code-constructor.ts
+import { defineRule as defineRule12 } from "@oxlint/plugins";
+var codeConstructor = defineRule12({
   meta: {
     type: "problem",
     schema: [
@@ -1871,9 +1954,285 @@ var codeConstructor = defineRule11({
 // src/rules/code/code-double-negation.ts
 var codeDoubleNegation = astSelectorRule('UnaryExpression[operator="!"] > UnaryExpression[operator="!"]', "Use Boolean(value) or an explicit comparison.");
 
+// src/rules/code/code-function-nesting.ts
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var codeFunctionNesting = defineRule13({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { max: { type: "integer", minimum: 1, default: 4 } }
+      }
+    ],
+    messages: {
+      deep: "Functions nest {{depth}} deep (max {{max}}). Name the inner step."
+    }
+  },
+  createOnce(context) {
+    let max = 4;
+    const check = (node) => {
+      let depth = 0;
+      for (let current = node;current; current = current.parent) {
+        depth += current.type === "FunctionDeclaration" || astIsInlineFunction(current) ? 1 : 0;
+      }
+      if (depth === max + 1) {
+        context.report({
+          node,
+          messageId: "deep",
+          data: { depth: String(depth), max: String(max) }
+        });
+      }
+    };
+    return {
+      before() {
+        max = optionsFirst(context, {}).max ?? 4;
+      },
+      ArrowFunctionExpression: check,
+      FunctionExpression: check,
+      FunctionDeclaration: check
+    };
+  }
+});
+
+// src/rules/code/code-inline.ts
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+
+// src/utils/source.utils.ts
+var sourceDirective = /^\s*(?:\/\s*<(?:reference\b|amd-[\w-]+\b)|@ts-(?:check|ignore|expect-error|nocheck)\b|(?:#|@)__(?:PURE|NO_SIDE_EFFECTS)__\b|@jsx(?:ImportSource|Runtime|Frag)?\b|@vite-ignore\b|(?:[#@]\s*)?sourceMappingURL=|(?:es|ox)lint-(?:disable|enable)|prettier-ignore|biome-ignore|[cv]8 ignore|istanbul ignore|webpack[A-Z])/;
+var sourceLegalBlock = "\x00legal-block\x00";
+var sourceIndentSchema = {
+  anyOf: [
+    { type: "integer", minimum: 0 },
+    { type: "string", enum: ["tab"] }
+  ]
+};
+function sourceCommentText(comment) {
+  const value = (comment.type === "Block" ? comment.value.replace(/^\s*\* ?/gm, "") : comment.value).trimStart();
+  return comment.type === "Block" && comment.value.startsWith("!") ? sourceLegalBlock + value : value;
+}
+function sourceIsDirective(text) {
+  return text.startsWith(sourceLegalBlock) || sourceDirective.test(text);
+}
+function sourceLineIndent(text, offset) {
+  const lineStart = text.lastIndexOf(`
+`, offset - 1) + 1;
+  return /^[\t ]*/.exec(text.slice(lineStart, offset))?.[0] ?? "";
+}
+function sourceIndentUnit(indent = 2) {
+  return indent === "tab" ? "\t" : " ".repeat(indent);
+}
+function sourceNewline(text) {
+  return text.includes(`\r
+`) ? `\r
+` : `
+`;
+}
+function sourceLineStart(text, offset) {
+  return text.lastIndexOf(`
+`, offset - 1) + 1;
+}
+function sourceLineEnd(text, offset) {
+  const end = text.indexOf(`
+`, offset);
+  return end === -1 ? text.length : end;
+}
+function sourceItemGaps(open, items, close) {
+  const edges = [open, ...items.flatMap((item) => item.range), close];
+  return Array.from({ length: items.length + 1 }, (_, index) => [edges[index * 2] ?? open, edges[index * 2 + 1] ?? close]);
+}
+function sourceRespace(fixer, text, gaps, spacing) {
+  const matches = gaps.map((gap) => /^\s*(,?)\s*$/.exec(text.slice(...gap)));
+  if (matches.some((match) => match === null)) {
+    return null;
+  }
+  return gaps.map((gap, index) => fixer.replaceTextRange(gap, `${matches[index]?.[1] ?? ""}${spacing(index, index === gaps.length - 1)}`));
+}
+
+// src/rules/code/code-inline.ts
+function codeInlineIsData(node) {
+  return node.type === "ObjectExpression" || node.type === "ArrayExpression" || (node.type === "TSSatisfiesExpression" || node.type === "TSAsExpression") && codeInlineIsData(node.expression);
+}
+function codeInlineOuterCall(node) {
+  const parent = node.parent;
+  if (!parent || astIsInlineFunction(parent) || parent.type.endsWith("Statement")) {
+    return;
+  }
+  return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : codeInlineOuterCall(parent);
+}
+function codeInlineEnclosingCalls(node) {
+  const outer = codeInlineOuterCall(node);
+  return outer && astIsOneLine(outer) ? 1 + codeInlineEnclosingCalls(outer) : 0;
+}
+var codeInlineWrapped = new Set(["ConditionalExpression", "LogicalExpression", "BinaryExpression", "ArrowFunctionExpression"]);
+var codeInline = defineRule14({
+  meta: {
+    type: "suggestion",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          max: { type: "integer", minimum: 1, default: 160 },
+          nesting: { type: "integer", minimum: 1, default: 2 },
+          allow: optionsPatternSchema,
+          keep: optionsPatternSchema,
+          services: { type: "array", items: { type: "string" } }
+        }
+      }
+    ],
+    messages: {
+      once: "{{name}} is used once: inline it.",
+      trivial: "{{name}} only wraps one call or expression: inline it at each use."
+    }
+  },
+  createOnce(context) {
+    let options = {};
+    let allowed = [];
+    let kept = [];
+    const reads = (node) => {
+      const variable = context.sourceCode.getDeclaredVariables(node).at(0);
+      return variable ? variable.references.filter((reference) => !reference.init) : [];
+    };
+    const top = (node, id, init) => {
+      if (id.type !== "Identifier" || !astIsOneLine(node) || init && codeInlineIsData(init) || optionsPatternsTest(allowed, id.name)) {
+        return;
+      }
+      const uses = reads(node);
+      if (uses.some((reference) => reference.identifier.parent.type === "ExportSpecifier")) {
+        return;
+      }
+      if (uses.length === 1) {
+        context.report({
+          node: id,
+          messageId: "once",
+          data: { name: id.name }
+        });
+        return;
+      }
+      const arrow = init?.type === "ArrowFunctionExpression" && init.body.type !== "BlockStatement" && !astSome(init.body, astIsInlineFunction);
+      const call = init?.type === "CallExpression" && !astSome(init.arguments, astIsInlineFunction) && astCallDepth(init) <= 2;
+      if (!optionsPatternsTest(kept, id.name) && (arrow || call)) {
+        context.report({
+          node: id,
+          messageId: "trivial",
+          data: { name: id.name }
+        });
+      }
+    };
+    const local = (declarator) => {
+      const { id, init } = declarator;
+      const yields = (node) => node.type === "YieldExpression";
+      if (id.type !== "Identifier" || !init || !astIsOneLine(declarator) || codeInlineIsData(init) || astSome(init, yields, (node) => !astIsInlineFunction(node))) {
+        return;
+      }
+      const uses = reads(declarator);
+      const use = uses.at(0)?.identifier;
+      if (!use || uses.length > 1 || optionsPatternsTest(allowed, id.name)) {
+        return;
+      }
+      const text = context.sourceCode.text;
+      const line = text.slice(sourceLineStart(text, use.range[0]), sourceLineEnd(text, use.range[0]));
+      const owner = use.parent.type === "Property" ? use.parent.parent.parent : null;
+      const service = owner && astIsCall(owner) && owner.callee.type === "MemberExpression" && (options.services ?? []).includes(astMemberName(owner.callee) ?? "");
+      let deferred = false;
+      for (let current = use.parent;current && current !== declarator.parent.parent; current = current.parent) {
+        deferred ||= current.type === "FunctionDeclaration" || astIsInlineFunction(current);
+      }
+      const wrapped = codeInlineWrapped.has(init.type) && use.parent.type === "MemberExpression" && use.parent.object === use;
+      if (service || wrapped || deferred || codeInlineEnclosingCalls(use) + astCallDepth(init) > (options.nesting ?? 2) || line.length - id.name.length + context.sourceCode.getText(init).length > (options.max ?? 160)) {
+        return;
+      }
+      context.report({
+        node: id,
+        messageId: "once",
+        data: { name: id.name }
+      });
+    };
+    return {
+      before() {
+        options = optionsFirst(context, {});
+        allowed = optionsPatterns(options.allow);
+        kept = optionsPatterns(options.keep);
+      },
+      VariableDeclaration(node) {
+        if (node.kind === "const" && node.parent.type === "BlockStatement") {
+          node.declarations.forEach(local);
+        }
+      },
+      Program(program) {
+        for (const statement of program.body) {
+          if (statement.type === "VariableDeclaration" && statement.kind === "const") {
+            statement.declarations.forEach((declarator) => top(declarator, declarator.id, declarator.init));
+          }
+          if (statement.type === "FunctionDeclaration" && statement.id) {
+            top(statement, statement.id, null);
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/code/code-justified-call.ts
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var codeJustifiedCall = defineRule15({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["calls"],
+        properties: {
+          calls: { type: "array", items: { type: "string" }, minItems: 1 },
+          comment: { type: "string", default: "SAFETY:" },
+          message: { type: "string" }
+        }
+      }
+    ],
+    messages: {
+      missing: "{{call}} needs a `// {{comment}} <why>` comment on the line above.{{message}}"
+    }
+  },
+  createOnce(context) {
+    let calls = new Set;
+    let comment = "SAFETY:";
+    let message = "";
+    let comments = [];
+    const justified = (line) => {
+      const above = comments.find((candidate) => candidate.loc.end.line === line - 1);
+      if (!above) {
+        return false;
+      }
+      return above.value.trimStart().startsWith(`${comment} `) || above.type === "Line" && justified(above.loc.start.line);
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, { calls: [] });
+        calls = new Set(options.calls);
+        comment = options.comment ?? "SAFETY:";
+        message = options.message ? ` ${options.message}` : "";
+        comments = context.sourceCode.getAllComments();
+      },
+      CallExpression(node) {
+        const call = astDottedName(node.callee);
+        if (call && calls.has(call) && !justified(node.loc.start.line)) {
+          context.report({
+            node,
+            messageId: "missing",
+            data: { call, comment, message }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/code/code-literal-in.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-var codeLiteralIn = defineRule12({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var codeLiteralIn = defineRule16({
   meta: {
     type: "suggestion",
     schema: [
@@ -1914,7 +2273,7 @@ var codeLiteralIn = defineRule12({
 });
 
 // src/rules/code/code-mutable-state.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 var functionScopes = new Set([
   "FunctionDeclaration",
   "FunctionExpression",
@@ -1931,7 +2290,7 @@ function hasAncestor(node, test) {
   }
   return false;
 }
-var codeMutableState = defineRule13({
+var codeMutableState = defineRule17({
   meta: {
     type: "problem",
     schema: [
@@ -1989,7 +2348,7 @@ var codeMutableState = defineRule13({
 });
 
 // src/rules/code/code-object-params.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule18 } from "@oxlint/plugins";
 function isObjectParam(node) {
   if (node.type === "ObjectPattern") {
     return true;
@@ -2003,7 +2362,7 @@ function isObjectParam(node) {
   const annotation = node.typeAnnotation?.typeAnnotation;
   return !annotation || annotation.type === "TSTypeReference" || annotation.type === "TSTypeLiteral" || annotation.type === "TSIntersectionType";
 }
-var codeObjectParams = defineRule14({
+var codeObjectParams = defineRule18({
   meta: {
     type: "problem",
     schema: [
@@ -2052,8 +2411,8 @@ var codeObjectParams = defineRule14({
 });
 
 // src/rules/code/code-paired-call.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var codePairedCall = defineRule15({
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+var codePairedCall = defineRule19({
   meta: {
     type: "problem",
     schema: [
@@ -2137,7 +2496,7 @@ var codePairedCall = defineRule15({
 });
 
 // src/rules/code/code-promise-mutation.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function mutationBinding(node) {
   if (node.type === "Identifier") {
     return node;
@@ -2166,7 +2525,7 @@ function mutationBindings(node) {
   const binding = mutationBinding(node);
   return binding ? [binding] : [];
 }
-var codePromiseMutation = defineRule16({
+var codePromiseMutation = defineRule20({
   meta: {
     type: "problem",
     schema: [
@@ -2258,8 +2617,96 @@ var codePromiseMutation = defineRule16({
 // src/rules/code/code-switch.ts
 var codeSwitch = astSelectorRule("SwitchStatement", "Avoid switch statements.");
 
+// src/rules/code/code-traced.ts
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var codeTraced = defineRule21({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          untraced: { type: "array", items: { type: "string" }, default: ["Effect.fnUntraced"] },
+          exports: optionsPatternSchema,
+          services: { type: "array", items: { type: "string" }, default: ["of"] },
+          skip: optionsPatternSchema,
+          message: { type: "string" }
+        }
+      }
+    ],
+    messages: {
+      surface: "{{message}}"
+    }
+  },
+  createOnce(context) {
+    let untraced = new Set;
+    let services = new Set;
+    let exported = true;
+    let skipped = [];
+    let message = "";
+    const isUntraced = (node) => node?.type === "CallExpression" && untraced.has(astDottedName(node.callee) ?? "");
+    const resolves = (value) => {
+      if (value.type !== "Identifier") {
+        return isUntraced(value);
+      }
+      let scope = context.sourceCode.getScope(value);
+      while (scope && !scope.set.has(value.name)) {
+        scope = scope.upper;
+      }
+      const declaration = scope?.set.get(value.name)?.defs.at(0)?.node;
+      return declaration?.type === "VariableDeclarator" && isUntraced(declaration.init);
+    };
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        const files = optionsPatterns(options.exports);
+        untraced = new Set(options.untraced ?? ["Effect.fnUntraced"]);
+        services = new Set(options.services ?? ["of"]);
+        exported = files.length === 0 || optionsPatternsTest(files, context.filename.replaceAll("\\", "/"));
+        skipped = optionsPatterns(options.skip);
+        message = options.message ?? `An exported function or service method gets a span: replace ${[...untraced].join(", ")} with its traced form.`;
+      },
+      ExportNamedDeclaration(node) {
+        if (!exported || node.declaration?.type !== "VariableDeclaration") {
+          return;
+        }
+        for (const declarator of node.declaration.declarations) {
+          if (isUntraced(declarator.init)) {
+            context.report({
+              node: declarator,
+              messageId: "surface",
+              data: { message }
+            });
+          }
+        }
+      },
+      CallExpression(node) {
+        const service = node.arguments.at(0);
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression" || !services.has(astMemberName(callee) ?? "") || service?.type !== "ObjectExpression") {
+          return;
+        }
+        const tag = callee.object.type === "MemberExpression" ? astMemberName(callee.object) : astDottedName(callee.object);
+        if (optionsPatternsTest(skipped, tag ?? "")) {
+          return;
+        }
+        for (const property of service.properties) {
+          if (property.type === "Property" && resolves(property.value)) {
+            context.report({
+              node: property,
+              messageId: "surface",
+              data: { message }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/code/code-trivial-functions.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule22 } from "@oxlint/plugins";
 var codeTrivialFunctionsBanned = [
   "isRecord",
   "isPlainObject",
@@ -2389,7 +2836,7 @@ function guardStatement(node, state) {
     return guardFallback(declaration.init);
   });
 }
-var codeTrivialFunctions = defineRule17({
+var codeTrivialFunctions = defineRule22({
   meta: {
     type: "problem",
     schema: [
@@ -2519,41 +2966,31 @@ var codeTrivialFunctions = defineRule17({
   }
 });
 
-// src/rules/comments/comments-code.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
-
-// src/utils/source.utils.ts
-var sourceDirective = /^\s*(?:\/\s*<(?:reference\b|amd-[\w-]+\b)|@ts-(?:check|ignore|expect-error|nocheck)\b|(?:#|@)__(?:PURE|NO_SIDE_EFFECTS)__\b|@jsx(?:ImportSource|Runtime|Frag)?\b|@vite-ignore\b|(?:[#@]\s*)?sourceMappingURL=|(?:es|ox)lint-(?:disable|enable)|prettier-ignore|biome-ignore|[cv]8 ignore|istanbul ignore|webpack[A-Z])/;
-var sourceLegalBlock = "\x00legal-block\x00";
-var sourceIndentSchema = {
-  anyOf: [
-    { type: "integer", minimum: 0 },
-    { type: "string", enum: ["tab"] }
-  ]
-};
-function sourceCommentText(comment) {
-  const value = (comment.type === "Block" ? comment.value.replace(/^\s*\* ?/gm, "") : comment.value).trimStart();
-  return comment.type === "Block" && comment.value.startsWith("!") ? sourceLegalBlock + value : value;
-}
-function sourceIsDirective(text) {
-  return text.startsWith(sourceLegalBlock) || sourceDirective.test(text);
-}
-function sourceLineIndent(text, offset) {
-  const lineStart = text.lastIndexOf(`
-`, offset - 1) + 1;
-  return /^[\t ]*/.exec(text.slice(lineStart, offset))?.[0] ?? "";
-}
-function sourceIndentUnit(indent = 2) {
-  return indent === "tab" ? "\t" : " ".repeat(indent);
-}
-function sourceNewline(text) {
-  return text.includes(`\r
-`) ? `\r
-` : `
-`;
-}
+// src/rules/code/code-yield-argument.ts
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var codeYieldArgument = defineRule23({
+  meta: {
+    type: "suggestion",
+    messages: {
+      named: "Yield into a named const first, then pass the name."
+    }
+  },
+  createOnce(context) {
+    return {
+      YieldExpression(node) {
+        const parent = node.parent;
+        const argument = astIsCall(parent) && parent.arguments.some((item) => item === node);
+        const receiver = parent.type === "MemberExpression" && parent.object === node;
+        if (node.delegate && (argument || receiver)) {
+          context.report({ node, messageId: "named" });
+        }
+      }
+    };
+  }
+});
 
 // src/rules/comments/comments-code.ts
+import { defineRule as defineRule24 } from "@oxlint/plugins";
 var commentsLineGap = /^[\t \r\n\u2028\u2029]*$/;
 var commentsLineTerminator = /\r\n|[\n\r\u2028\u2029]/;
 var commentsUnicodeTerminator = /[\u2028\u2029]/;
@@ -2604,7 +3041,7 @@ function commentsFollowsOpeningBrace(text, offset) {
   }
   return false;
 }
-var commentsCode = defineRule18({
+var commentsCode = defineRule24({
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -2768,9 +3205,9 @@ var commentsCode = defineRule18({
 });
 
 // src/rules/comments/comments-directives.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
+import { defineRule as defineRule25 } from "@oxlint/plugins";
 var directive = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?\b(.*)$/s;
-var commentsDirectives = defineRule19({
+var commentsDirectives = defineRule25({
   meta: {
     type: "problem",
     schema: [],
@@ -2798,9 +3235,9 @@ var commentsDirectives = defineRule19({
 });
 
 // src/rules/copy/copy-dashes.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
+import { defineRule as defineRule26 } from "@oxlint/plugins";
 var copyDashesMessage = "Use a comma, colon, period or parentheses instead.";
-var copyDashes = defineRule20({
+var copyDashes = defineRule26({
   meta: {
     type: "suggestion",
     schema: [
@@ -2856,7 +3293,7 @@ var copyDashes = defineRule20({
 });
 
 // src/rules/files/files-components-only.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
+import { defineRule as defineRule27 } from "@oxlint/plugins";
 
 // src/utils/react.utils.ts
 function reactReturnsOutput(program, node) {
@@ -2928,7 +3365,7 @@ function reactIsComponent(program, candidate) {
 function componentName(basename2) {
   return basename2.replace(/\.(tsx?|jsx?)$/, "").replaceAll(/(?:^[-.]*|[-.]+)(.?)/g, (_, char) => char.toUpperCase());
 }
-var filesComponentsOnly = defineRule21({
+var filesComponentsOnly = defineRule27({
   meta: {
     type: "problem",
     schema: [
@@ -3013,7 +3450,7 @@ var filesComponentsOnly = defineRule21({
 });
 
 // src/rules/files/files-constants-only.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule28 } 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);
@@ -3068,7 +3505,7 @@ function collectBindings(program) {
   }
   return bindings;
 }
-var filesConstantsOnly = defineRule22({
+var filesConstantsOnly = defineRule28({
   meta: {
     type: "problem",
     schema: [
@@ -3167,7 +3604,7 @@ var filesConstantsOnly = defineRule22({
 });
 
 // src/rules/files/files-domain-constants.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
+import { defineRule as defineRule29 } from "@oxlint/plugins";
 import { basename as basename2, dirname as dirname2 } from "node:path";
 function isData(expression) {
   const value = astUnwrap(expression);
@@ -3185,7 +3622,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 = defineRule23({
+var filesDomainConstants = defineRule29({
   meta: {
     type: "problem",
     schema: [
@@ -3231,11 +3668,11 @@ var filesDomainConstants = defineRule23({
 });
 
 // src/rules/files/files-exports.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
+import { defineRule as defineRule30 } from "@oxlint/plugins";
 function escapeRegExp(value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var filesExports = defineRule24({
+var filesExports = defineRule30({
   meta: {
     type: "problem",
     schema: [
@@ -3316,11 +3753,11 @@ var filesExports = defineRule24({
 });
 
 // src/rules/files/files-externals.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
+import { defineRule as defineRule31 } 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 filesExternals = defineRule25({
+var filesExternals = defineRule31({
   meta: {
     type: "problem",
     schema: [
@@ -3411,7 +3848,7 @@ var filesExternals = defineRule25({
 });
 
 // src/rules/files/files-factory-keys.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
+import { defineRule as defineRule32 } from "@oxlint/plugins";
 function returnedObject(expression) {
   if (expression?.type === "TSAsExpression" || expression?.type === "TSSatisfiesExpression" || expression?.type === "TSTypeAssertion" || expression?.type === "TSNonNullExpression") {
     return returnedObject(expression.expression);
@@ -3422,7 +3859,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 = defineRule26({
+var filesFactoryKeys = defineRule32({
   meta: {
     type: "problem",
     schema: [
@@ -3540,8 +3977,8 @@ var filesFactoryKeys = defineRule26({
 });
 
 // src/rules/files/files-helpers.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
-var filesHelpers = defineRule27({
+import { defineRule as defineRule33 } from "@oxlint/plugins";
+var filesHelpers = defineRule33({
   meta: {
     type: "problem",
     schema: [
@@ -3589,8 +4026,8 @@ var filesHelpers = defineRule27({
 });
 
 // src/rules/files/files-no-functions.ts
-import { defineRule as defineRule28 } from "@oxlint/plugins";
-var filesNoFunctions = defineRule28({
+import { defineRule as defineRule34 } from "@oxlint/plugins";
+var filesNoFunctions = defineRule34({
   meta: {
     type: "problem",
     schema: [
@@ -3644,8 +4081,8 @@ var filesNoFunctions = defineRule28({
 });
 
 // src/rules/files/files-restricted.ts
-import { defineRule as defineRule29 } from "@oxlint/plugins";
-var filesRestricted = defineRule29({
+import { defineRule as defineRule35 } from "@oxlint/plugins";
+var filesRestricted = defineRule35({
   meta: {
     type: "problem",
     schema: [
@@ -3677,7 +4114,7 @@ var filesRestricted = defineRule29({
 });
 
 // src/rules/files/files-route.ts
-import { defineRule as defineRule30 } from "@oxlint/plugins";
+import { defineRule as defineRule36 } 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)) {
@@ -3697,7 +4134,7 @@ function inspectAdapter(context, item, bannedHooks, banIntrinsicJsx) {
     }
   });
 }
-var filesRoute = defineRule30({
+var filesRoute = defineRule36({
   meta: {
     type: "problem",
     schema: [
@@ -3767,7 +4204,7 @@ var filesRoute = defineRule30({
 });
 
 // src/rules/files/files-types-only.ts
-import { defineRule as defineRule31 } from "@oxlint/plugins";
+import { defineRule as defineRule37 } from "@oxlint/plugins";
 function runtimeImportLocalNames(statement) {
   return statement.specifiers.flatMap((specifier) => specifier.type !== "ImportSpecifier" || specifier.importKind !== "type" ? [specifier.local.name] : []);
 }
@@ -3936,7 +4373,7 @@ function runtimeKind(node) {
   }
   return node.type === "FunctionDeclaration" ? "function" : "variable";
 }
-var filesTypesOnly = defineRule31({
+var filesTypesOnly = defineRule37({
   meta: {
     type: "problem",
     schema: [
@@ -4043,9 +4480,66 @@ var filesTypesOnly = defineRule31({
   }
 });
 
+// src/rules/layout/layout-arrow-body.ts
+import { defineRule as defineRule38 } from "@oxlint/plugins";
+var layoutArrowBody = defineRule38({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { max: { type: "integer", minimum: 1, default: 160 } }
+      }
+    ],
+    messages: {
+      sameLine: "Start the arrow body on the same line as =>. When the line is too long, break its arguments."
+    }
+  },
+  createOnce(context) {
+    let max = 160;
+    return {
+      before() {
+        max = optionsFirst(context, {}).max ?? 160;
+      },
+      ArrowFunctionExpression(node) {
+        const source = context.sourceCode;
+        const body = node.body;
+        const arrow = source.getTokenBefore(body, { filter: (token) => token.value === "=>" });
+        const next = arrow ? source.getTokenAfter(arrow) : null;
+        if (body.type === "BlockStatement" || !arrow || !next || next.loc.start.line === arrow.loc.end.line || source.commentsExistBetween(arrow, next)) {
+          return;
+        }
+        let root = body;
+        let calls = 0;
+        while (root.type === "CallExpression" && root.callee.type === "MemberExpression") {
+          calls += 1;
+          root = root.callee.object;
+        }
+        const open = astIsCall(body) && astIsOneLine(body) ? source.getTokenAfter(body.typeArguments ?? body.callee) : null;
+        const callEnd = open ? open.range[1] : sourceLineEnd(source.text, next.range[0]);
+        const headEnd = calls >= 2 && astIsOneLine(body) ? root.range[1] : callEnd;
+        if (arrow.loc.end.column + 1 + source.text.slice(next.range[0], headEnd).length > max) {
+          return;
+        }
+        context.report({
+          node: body,
+          messageId: "sameLine",
+          fix: (fixer) => fixer.replaceTextRange([arrow.range[1], next.range[0]], " ")
+        });
+      }
+    };
+  }
+});
+
 // src/rules/layout/layout-call-arguments.ts
-import { defineRule as defineRule32 } from "@oxlint/plugins";
-var layoutCallArguments = defineRule32({
+import { defineRule as defineRule39 } 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 = defineRule39({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4063,18 +4557,42 @@ var layoutCallArguments = defineRule32({
             type: "integer",
             minimum: 1,
             default: 2
+          },
+          split: {
+            type: "boolean",
+            default: true
+          },
+          hug: {
+            type: "object",
+            additionalProperties: false,
+            required: ["max"],
+            properties: { max: layoutCallArgumentsMax }
+          },
+          join: {
+            type: "object",
+            additionalProperties: false,
+            required: ["max"],
+            properties: {
+              max: layoutCallArgumentsMax,
+              nesting: layoutCallArgumentsMax,
+              keep: { type: "array", items: { type: "string" } }
+            }
           }
         }
       }
     ],
     messages: {
-      multiline: "A call with {{min}}+ arguments puts each argument on its own line."
+      multiline: "A call with {{min}}+ arguments puts each argument on its own line.",
+      hug: "Put every argument on its own line. Only a last callback, object or array may hug the call, after simple arguments.",
+      prefer: "Hug the last argument: it is a callback, object or array after simple arguments.",
+      join: "This fits on one line, so keep it on one line."
     }
   },
   createOnce(context) {
+    let options = {};
     let minArguments = 3;
     let indent = 2;
-    const check = (node) => {
+    const split = (node) => {
       const args = node.arguments;
       const last = args.at(-1);
       const source = context.sourceCode;
@@ -4111,25 +4629,109 @@ var layoutCallArguments = defineRule32({
         })
       });
     };
+    const hug = (node, max) => {
+      const source = context.sourceCode;
+      const text = source.text;
+      const args = node.arguments;
+      const first = args.at(0);
+      const last = args.at(-1);
+      const open = source.getTokenAfter(node.typeArguments ?? node.callee);
+      const close = source.getLastToken(node);
+      if (!first || !last || !open || !close || args.every(astIsOneLine) || source.getCommentsInside(node).length > 0) {
+        return;
+      }
+      const leading = args.slice(0, -1);
+      const canHug = !astIsPipe(node) && leading.every((arg) => astIsOneLine(arg) && astCallDepth(arg) <= 1) && layoutCallArgumentsHuggable(last);
+      const gaps = sourceItemGaps(open.range[1], args, close.range[0]);
+      if (first.loc.start.line > open.loc.end.line) {
+        const head = [...leading.map((arg) => source.getText(arg)), text.slice(last.range[0], sourceLineEnd(text, last.range[0]))];
+        const hugged = `${text.slice(sourceLineStart(text, open.range[0]), open.range[1])}${head.join(", ")}`;
+        if (canHug && args.length <= 2 && hugged.length <= max) {
+          context.report({
+            node,
+            messageId: "prefer",
+            fix: (fixer) => sourceRespace(fixer, text, gaps, (index, end) => index === 0 || end ? "" : " ")
+          });
+        }
+        return;
+      }
+      if (astIsOneLine(node) || canHug) {
+        return;
+      }
+      const newline = sourceNewline(text);
+      const base = sourceLineIndent(text, open.range[0]);
+      const inner = `${base}${" ".repeat(indent)}`;
+      context.report({
+        node,
+        messageId: "hug",
+        fix: (fixer) => sourceRespace(fixer, text, gaps, (_, end) => `${newline}${end ? base : inner}`)
+      });
+    };
+    const join3 = (node, items, open, close) => {
+      const source = context.sourceCode;
+      const text = source.text;
+      const first = items.at(0);
+      if (!first || !open || !close || items.length > 2 || first.loc.start.line === open.loc.end.line || !items.every(astIsOneLine) || source.commentsExistBetween(open, close)) {
+        return;
+      }
+      const inside = items.map((item) => source.getText(item)).join(", ");
+      const before = text.slice(sourceLineStart(text, open.range[0]), open.range[1]);
+      const after = text.slice(close.range[0], sourceLineEnd(text, close.range[0]));
+      if (`${before}${inside}${after}`.length > (options.join?.max ?? 0)) {
+        return;
+      }
+      const gaps = sourceItemGaps(open.range[1], items, close.range[0]);
+      context.report({
+        node,
+        messageId: "join",
+        fix: (fixer) => sourceRespace(fixer, text, gaps, (index, end) => index === 0 || end ? "" : " ")
+      });
+    };
+    const call = (node) => {
+      const source = context.sourceCode;
+      if (options.split !== false) {
+        split(node);
+      }
+      if (options.hug) {
+        hug(node, options.hug.max);
+      }
+      if (options.join && !(options.join.keep ?? []).includes(source.getText(node.callee)) && !(astIsPipe(node) && node.arguments.length > 1) && astCallDepth(node) <= (options.join.nesting ?? Number.POSITIVE_INFINITY)) {
+        join3(node, node.arguments, source.getTokenAfter(node.typeArguments ?? node.callee), source.getLastToken(node));
+      }
+    };
+    const parameters = (node) => {
+      const source = context.sourceCode;
+      const first = node.params.at(0);
+      const last = node.params.at(-1);
+      if (!options.join || !first || !last) {
+        return;
+      }
+      join3(node, node.params, source.getTokenBefore(first, { filter: (token) => token.value === "(" }), source.getTokenAfter(last, { filter: (token) => token.value === ")" }));
+    };
     return {
       before() {
-        const options = optionsFirst(context, {});
+        options = optionsFirst(context, {});
         minArguments = options.min ?? 3;
         indent = options.indent ?? 2;
       },
-      CallExpression: check,
-      NewExpression: check
+      CallExpression: call,
+      NewExpression: call,
+      FunctionExpression: parameters,
+      FunctionDeclaration: parameters,
+      ArrowFunctionExpression: parameters,
+      TSFunctionType: parameters,
+      TSMethodSignature: parameters
     };
   }
 });
 
 // src/rules/layout/layout-call-array.ts
-import { defineRule as defineRule33 } from "@oxlint/plugins";
+import { defineRule as defineRule40 } from "@oxlint/plugins";
 var layoutCallArrayDefaultCallees = ["Promise.all", "Promise.allSettled"];
 function layoutCallArrayRoot(node) {
   return node.type === "MemberExpression" ? layoutCallArrayRoot(node.object) : node;
 }
-var layoutCallArray = defineRule33({
+var layoutCallArray = defineRule40({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4244,9 +4846,56 @@ var layoutCallArray = defineRule33({
   }
 });
 
+// src/rules/layout/layout-call-depth.ts
+import { defineRule as defineRule41 } from "@oxlint/plugins";
+function layoutCallDepthOuter(node) {
+  const parent = node.parent;
+  if (!parent || parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression" || parent.type.endsWith("Statement")) {
+    return;
+  }
+  return astIsCall(parent) && parent.arguments.some((argument) => argument === node) ? parent : layoutCallDepthOuter(parent);
+}
+var layoutCallDepth = defineRule41({
+  meta: {
+    type: "layout",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { max: { type: "integer", minimum: 1, default: 2 } }
+      }
+    ],
+    messages: {
+      deep: "Calls nest {{depth}} deep on one line (max {{max}}). Break the outer call or name an inner value."
+    }
+  },
+  createOnce(context) {
+    let max = 2;
+    const check = (node) => {
+      const depth = astCallDepth(node);
+      const outer = layoutCallDepthOuter(node);
+      if (!astIsOneLine(node) || depth <= max || outer !== undefined && astIsOneLine(outer) && astCallDepth(outer) > max) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: "deep",
+        data: { depth: String(depth), max: String(max) }
+      });
+    };
+    return {
+      before() {
+        max = optionsFirst(context, {}).max ?? 2;
+      },
+      CallExpression: check,
+      NewExpression: check
+    };
+  }
+});
+
 // src/rules/layout/layout-chain.ts
-import { defineRule as defineRule34 } from "@oxlint/plugins";
-var layoutChain = defineRule34({
+import { defineRule as defineRule42 } from "@oxlint/plugins";
+var layoutChain = defineRule42({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4364,9 +5013,65 @@ var layoutChain = defineRule34({
   }
 });
 
+// src/rules/layout/layout-items.ts
+import { defineRule as defineRule43 } from "@oxlint/plugins";
+var layoutItems = defineRule43({
+  meta: {
+    type: "layout",
+    fixable: "whitespace",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { indent: { ...sourceIndentSchema, default: 2 } }
+      }
+    ],
+    messages: {
+      object: "A multi-line object puts each property on its own line.",
+      array: "A multi-line array puts each element on its own line."
+    }
+  },
+  createOnce(context) {
+    let indentUnit = sourceIndentUnit();
+    const check = (node) => {
+      const source = context.sourceCode;
+      const items = node.type === "ObjectExpression" ? node.properties : node.elements;
+      const present = items.filter((item) => item !== null);
+      const open = source.getFirstToken(node);
+      const close = source.getLastToken(node);
+      if (!open || !close || astIsOneLine(node) || present.length < 2) {
+        return;
+      }
+      const packed = [open, ...present].some((item, index) => {
+        const next = present.at(index);
+        return next !== undefined && item.loc.end.line === next.loc.start.line;
+      });
+      if (!packed) {
+        return;
+      }
+      const text = source.text;
+      const newline = sourceNewline(text);
+      const base = sourceLineIndent(text, node.range[0]);
+      const gaps = sourceItemGaps(open.range[1], present, close.range[0]);
+      context.report({
+        node,
+        messageId: node.type === "ObjectExpression" ? "object" : "array",
+        fix: (fixer) => present.length === items.length ? sourceRespace(fixer, text, gaps, (_, end) => `${newline}${base}${end ? "" : indentUnit}`) : null
+      });
+    };
+    return {
+      before() {
+        indentUnit = sourceIndentUnit(optionsFirst(context, {}).indent);
+      },
+      ObjectExpression: check,
+      ArrayExpression: check
+    };
+  }
+});
+
 // src/rules/layout/layout-jsx-attributes.ts
-import { defineRule as defineRule35 } from "@oxlint/plugins";
-var layoutJsxAttributes = defineRule35({
+import { defineRule as defineRule44 } from "@oxlint/plugins";
+var layoutJsxAttributes = defineRule44({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4430,8 +5135,8 @@ var layoutJsxAttributes = defineRule35({
 });
 
 // src/rules/layout/layout-key-value.ts
-import { defineRule as defineRule36 } from "@oxlint/plugins";
-var layoutKeyValue = defineRule36({
+import { defineRule as defineRule45 } from "@oxlint/plugins";
+var layoutKeyValue = defineRule45({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4467,11 +5172,11 @@ var layoutKeyValue = defineRule36({
 });
 
 // src/rules/layout/layout-object.ts
-import { defineRule as defineRule37 } from "@oxlint/plugins";
+import { defineRule as defineRule46 } from "@oxlint/plugins";
 function layoutObjectIsWhitespace(text) {
   return /^[\t\n\r\f ]*$/.test(text);
 }
-var layoutObject = defineRule37({
+var layoutObject = defineRule46({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4555,7 +5260,7 @@ var layoutObject = defineRule37({
 });
 
 // src/rules/layout/layout-padding.ts
-import { defineRule as defineRule38 } from "@oxlint/plugins";
+import { defineRule as defineRule47 } from "@oxlint/plugins";
 var layoutPaddingControl = new Set([
   "IfStatement",
   "ForStatement",
@@ -4584,7 +5289,7 @@ function layoutPaddingKind(node) {
 function layoutPaddingIsMultilineVariable(node, kind) {
   return kind === "variable" && node.loc.start.line !== node.loc.end.line;
 }
-var layoutPadding = defineRule38({
+var layoutPadding = defineRule47({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4672,13 +5377,48 @@ var layoutPadding = defineRule38({
   }
 });
 
+// src/rules/layout/layout-pipe.ts
+import { defineRule as defineRule48 } from "@oxlint/plugins";
+var layoutPipe = defineRule48({
+  meta: {
+    type: "layout",
+    messages: {
+      after: "No ).pipe( after a call that spans lines. Name the value and pipe the name, or pass the call to the step data-first.",
+      step: "A pipe step may span lines only through a callback, object or array. Name this call first, then pass the name."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type === "MemberExpression" && astMemberName(callee) === "pipe" && astIsCall(callee.object) && !astIsOneLine(callee.object) && callee.property.loc.start.line === callee.object.loc.end.line) {
+          context.report({ node: callee.property, messageId: "after" });
+        }
+        if (!astIsPipe(node)) {
+          return;
+        }
+        for (const step of node.arguments) {
+          for (const argument of astIsCall(step) ? step.arguments : []) {
+            if (astIsCall(argument) && !astIsOneLine(argument)) {
+              context.report({ node: argument, messageId: "step" });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/layout/layout-ternary.ts
-import { defineRule as defineRule39 } from "@oxlint/plugins";
+import { defineRule as defineRule49 } from "@oxlint/plugins";
+function layoutTernaryLines(node) {
+  return node.loc.end.line - node.loc.start.line + 1;
+}
 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 = defineRule39({
+var layoutTernary = defineRule49({
   meta: {
     type: "layout",
     fixable: "whitespace",
@@ -4696,11 +5436,23 @@ var layoutTernary = defineRule39({
             type: "integer",
             minimum: 1,
             default: 2
+          },
+          fit: {
+            type: "boolean",
+            default: true
+          },
+          branch: {
+            type: "object",
+            additionalProperties: false,
+            required: ["max"],
+            properties: { max: { type: "integer", minimum: 1 } }
           }
         }
       }
     ],
     messages: {
+      long: "This ternary branch spans {{lines}} lines (max {{max}}). Name it.",
+      yield: "A yield* ternary takes one-line operands. Name the multi-line branch.",
       join: "Keep this conditional on one line ({{length}} columns; limit {{max}}, except in template literals).",
       split: "This conditional does not fit on one line ({{length}} of {{max}} columns); break before `?` and `:`."
     }
@@ -4708,14 +5460,38 @@ var layoutTernary = defineRule39({
   createOnce(context) {
     let maxLength = 160;
     let indent = 2;
+    let fit = true;
+    let branchMax;
+    const branch = (node, max) => {
+      const long = [node.consequent, node.alternate].filter((operand) => layoutTernaryLines(operand) > max);
+      for (const operand of long) {
+        context.report({
+          node: operand,
+          messageId: "long",
+          data: { lines: String(layoutTernaryLines(operand)), max: String(max) }
+        });
+      }
+      const yielded = node.parent.type === "YieldExpression" && node.parent.delegate;
+      if (yielded && long.length === 0 && [node.test, node.consequent, node.alternate].some((operand) => layoutTernaryLines(operand) > 1)) {
+        context.report({ node, messageId: "yield" });
+      }
+    };
     return {
       before() {
         const options = optionsFirst(context, {});
         maxLength = options.max ?? 160;
         indent = options.indent ?? 2;
+        fit = options.fit ?? true;
+        branchMax = options.branch?.max;
       },
       ConditionalExpression(node) {
         const source = context.sourceCode;
+        if (branchMax !== undefined) {
+          branch(node, branchMax);
+        }
+        if (!fit) {
+          return;
+        }
         const operands = [node.test, node.consequent, node.alternate];
         if (node.parent.type === "ConditionalExpression" || operands.some((operand) => operand.type === "ConditionalExpression" || operand.loc.start.line !== operand.loc.end.line) || source.getCommentsInside(node).length > 0) {
           return;
@@ -4762,9 +5538,9 @@ var layoutTernary = defineRule39({
 });
 
 // src/rules/naming/naming-declarations.ts
-import { defineRule as defineRule40 } from "@oxlint/plugins";
+import { defineRule as defineRule50 } from "@oxlint/plugins";
 var namingDeclarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
-var namingDeclarations = defineRule40({
+var namingDeclarations = defineRule50({
   meta: {
     type: "problem",
     schema: [
@@ -4843,7 +5619,7 @@ var namingDeclarations = defineRule40({
 });
 
 // src/rules/naming/naming-exports.ts
-import { defineRule as defineRule41 } from "@oxlint/plugins";
+import { defineRule as defineRule51 } from "@oxlint/plugins";
 var namingExportsScopeProperties = {
   scope: { type: "string", enum: ["exports", "functions", "declarations"] },
   types: { type: "boolean" },
@@ -4869,7 +5645,7 @@ function matchTemplate(basename3, template, placeholder = "[a-z0-9-]+") {
   }
   return new RegExp(`^${pattern}$`).exec(basename3)?.groups ?? null;
 }
-var namingExports = defineRule41({
+var namingExports = defineRule51({
   meta: {
     type: "problem",
     schema: {
@@ -5003,10 +5779,10 @@ var namingExports = defineRule41({
 });
 
 // src/rules/naming/naming-file.ts
-import { defineRule as defineRule42 } from "@oxlint/plugins";
+import { defineRule as defineRule52 } from "@oxlint/plugins";
 import { readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
-var namingFile = defineRule42({
+var namingFile = defineRule52({
   meta: {
     type: "problem",
     schema: {
@@ -5076,9 +5852,9 @@ var namingFile = defineRule42({
 });
 
 // src/rules/naming/naming-folder.ts
-import { defineRule as defineRule43 } from "@oxlint/plugins";
+import { defineRule as defineRule53 } from "@oxlint/plugins";
 import { posix as posix2 } from "node:path";
-var namingFolder = defineRule43({
+var namingFolder = defineRule53({
   meta: {
     type: "problem",
     schema: [
@@ -5152,9 +5928,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 defineRule44 } from "@oxlint/plugins";
+import { defineRule as defineRule54 } from "@oxlint/plugins";
 var reactMemoNames = ["memo", "useMemo", "useCallback"];
-var reactMemo = defineRule44({
+var reactMemo = defineRule54({
   meta: {
     type: "problem",
     schema: [],
@@ -5189,7 +5965,7 @@ var reactMemo = defineRule44({
 });
 
 // src/rules/react/react-props.ts
-import { defineRule as defineRule45 } from "@oxlint/plugins";
+import { defineRule as defineRule55 } from "@oxlint/plugins";
 function reactPropsTarget(node) {
   if (node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression") {
     return { fn: node };
@@ -5216,7 +5992,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 = defineRule45({
+var reactProps = defineRule55({
   meta: {
     type: "problem",
     schema: [
@@ -5314,7 +6090,7 @@ var reactProps = defineRule45({
 });
 
 // src/rules/schemas/schemas-inline.ts
-import { defineRule as defineRule46 } from "@oxlint/plugins";
+import { defineRule as defineRule56 } from "@oxlint/plugins";
 
 // src/utils/schemas.utils.ts
 var schemasElementOptionsSchema = {
@@ -5350,7 +6126,7 @@ function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMetho
 }
 
 // src/rules/schemas/schemas-inline.ts
-var schemasInline = defineRule46({
+var schemasInline = defineRule56({
   meta: {
     type: "problem",
     schema: [schemasElementOptionsSchema],
@@ -5399,11 +6175,11 @@ var schemasInline = defineRule46({
 });
 
 // src/rules/schemas/schemas-local.ts
-import { defineRule as defineRule47 } from "@oxlint/plugins";
+import { defineRule as defineRule57 } 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 = defineRule47({
+var schemasLocal = defineRule57({
   meta: {
     type: "problem",
     schema: [
@@ -5528,8 +6304,8 @@ var schemasLocal = defineRule47({
 });
 
 // src/rules/schemas/schemas-rederive.ts
-import { defineRule as defineRule48 } from "@oxlint/plugins";
-var schemasRederive = defineRule48({
+import { defineRule as defineRule58 } from "@oxlint/plugins";
+var schemasRederive = defineRule58({
   meta: {
     type: "problem",
     schema: [
@@ -5575,7 +6351,7 @@ var schemasRederive = defineRule48({
 });
 
 // src/rules/schemas/schemas-single-use.ts
-import { defineRule as defineRule49 } from "@oxlint/plugins";
+import { defineRule as defineRule59 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -5589,7 +6365,7 @@ function isScalarSchema(node, namespaces, structuralMethods) {
   }
   return node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods);
 }
-var schemasSingleUse = defineRule49({
+var schemasSingleUse = defineRule59({
   meta: {
     type: "suggestion",
     schema: [schemasElementOptionsSchema],
@@ -5665,7 +6441,7 @@ var schemasSingleUse = defineRule49({
 });
 
 // src/rules/tests/tests-assertions.ts
-import { defineRule as defineRule50 } from "@oxlint/plugins";
+import { defineRule as defineRule60 } from "@oxlint/plugins";
 var testsAssertionsModifiers = new Set(["for", "each", "concurrent", "sequential", "only", "skip"]);
 var testsAssertionsFunctions = [
   "expect",
@@ -5855,7 +6631,7 @@ function isAssertedTest(registration, sourceCode, state) {
   }
   return rows.length > 0 && rows.every((row) => hasAssertion(callback, row.bindings, new Set, state));
 }
-var testsAssertions = defineRule50({
+var testsAssertions = defineRule60({
   meta: {
     type: "problem",
     schema: [
@@ -5981,8 +6757,8 @@ var testsAssertions = defineRule50({
 });
 
 // src/rules/tests/tests-concurrent-db.ts
-import { defineRule as defineRule51 } from "@oxlint/plugins";
-var testsConcurrentDb = defineRule51({
+import { defineRule as defineRule61 } from "@oxlint/plugins";
+var testsConcurrentDb = defineRule61({
   meta: {
     type: "problem",
     schema: [{ type: "object", properties: { message: { type: "string" } }, additionalProperties: false }],
@@ -6019,7 +6795,7 @@ var testsConcurrentDb = defineRule51({
 });
 
 // src/rules/tests/tests-modifiers.ts
-import { defineRule as defineRule52 } from "@oxlint/plugins";
+import { defineRule as defineRule62 } from "@oxlint/plugins";
 var testsModifiersNames = ["test", "it", "describe", "suite"];
 var testsModifiersPackages = new Set(["vitest", "bun:test", "@playwright/test", "@jest/globals"]);
 var testsModifiersBanned = new Set(["only", "skip", "todo"]);
@@ -6038,7 +6814,7 @@ function modifierName(node) {
   const property = astMemberName(node);
   return object && property ? `${object}.${property}` : undefined;
 }
-var testsModifiers = defineRule52({
+var testsModifiers = defineRule62({
   meta: {
     type: "problem",
     schema: [
@@ -6089,9 +6865,9 @@ var testsModifiers = defineRule52({
 });
 
 // src/rules/tests/tests-titles.ts
-import { defineRule as defineRule53 } from "@oxlint/plugins";
+import { defineRule as defineRule63 } from "@oxlint/plugins";
 var testsTitlesModifiers = new Set(["only", "skip", "concurrent", "sequential", "todo", "each", "for"]);
-var testsTitles = defineRule53({
+var testsTitles = defineRule63({
   meta: {
     type: "suggestion",
     schema: [
@@ -6166,11 +6942,11 @@ var testsTitles = defineRule53({
 });
 
 // src/rules/types/types-declarations.ts
-import { defineRule as defineRule54 } from "@oxlint/plugins";
+import { defineRule as defineRule64 } from "@oxlint/plugins";
 function isValuePattern(source) {
   return /^\^?=/.test(source);
 }
-var typesDeclarations = defineRule54({
+var typesDeclarations = defineRule64({
   meta: {
     type: "problem",
     schema: [
@@ -6213,7 +6989,7 @@ var typesDeclarations = defineRule54({
 });
 
 // src/rules/types/types-imported-alias.ts
-import { defineRule as defineRule55 } from "@oxlint/plugins";
+import { defineRule as defineRule65 } from "@oxlint/plugins";
 function importedAliasTarget(declaration, imports) {
   if (declaration?.type !== "TSTypeAliasDeclaration") {
     return;
@@ -6225,7 +7001,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 = defineRule55({
+var typesImportedAlias = defineRule65({
   meta: {
     type: "problem",
     schema: [],
@@ -6287,7 +7063,7 @@ var typesImportedAlias = defineRule55({
 });
 
 // src/rules/types/types-inline.ts
-import { defineRule as defineRule56 } from "@oxlint/plugins";
+import { defineRule as defineRule66 } from "@oxlint/plugins";
 function parameterAnnotation(parameter) {
   if (parameter.type === "TSParameterProperty") {
     return parameterAnnotation(parameter.parameter);
@@ -6297,7 +7073,7 @@ function parameterAnnotation(parameter) {
   }
   return parameter.typeAnnotation;
 }
-var typesInline = defineRule56({
+var typesInline = defineRule66({
   meta: {
     type: "problem",
     schema: [
@@ -6373,8 +7149,8 @@ var typesInline = defineRule56({
 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 defineRule57 } from "@oxlint/plugins";
-var typesNamespaceImport = defineRule57({
+import { defineRule as defineRule67 } from "@oxlint/plugins";
+var typesNamespaceImport = defineRule67({
   meta: {
     type: "suggestion",
     schema: [
@@ -6416,8 +7192,8 @@ var typesNamespaceImport = defineRule57({
 });
 
 // src/rules/types/types-service.ts
-import { defineRule as defineRule58 } from "@oxlint/plugins";
-var typesService = defineRule58({
+import { defineRule as defineRule68 } from "@oxlint/plugins";
+var typesService = defineRule68({
   meta: {
     type: "problem",
     schema: [],
@@ -6443,12 +7219,12 @@ var typesService = defineRule58({
 });
 
 // src/rules/types/types-unknown.ts
-import { defineRule as defineRule59 } from "@oxlint/plugins";
+import { defineRule as defineRule69 } 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 = defineRule59({
+var typesUnknown = defineRule69({
   meta: { type: "problem", schema: [], messages: { forbidden: "Use an owned domain type rather than unknown." } },
   createOnce(context) {
     return {
@@ -6485,15 +7261,21 @@ var src_default = eslintCompatPlugin({
     "boundaries-rpc-database": boundariesRpcDatabase,
     "boundaries-tanstack": boundariesTanstack,
     "boundaries-token-owner": boundariesTokenOwner,
+    "code-branch-once": codeBranchOnce,
     "code-constructor": codeConstructor,
     "code-double-negation": codeDoubleNegation,
+    "code-function-nesting": codeFunctionNesting,
+    "code-inline": codeInline,
+    "code-justified-call": codeJustifiedCall,
     "code-literal-in": codeLiteralIn,
     "code-mutable-state": codeMutableState,
     "code-object-params": codeObjectParams,
     "code-paired-call": codePairedCall,
     "code-promise-mutation": codePromiseMutation,
     "code-switch": codeSwitch,
+    "code-traced": codeTraced,
     "code-trivial-functions": codeTrivialFunctions,
+    "code-yield-argument": codeYieldArgument,
     "comments-code": commentsCode,
     "comments-directives": commentsDirectives,
     "copy-dashes": copyDashes,
@@ -6508,13 +7290,17 @@ var src_default = eslintCompatPlugin({
     "files-restricted": filesRestricted,
     "files-route": filesRoute,
     "files-types-only": filesTypesOnly,
+    "layout-arrow-body": layoutArrowBody,
     "layout-call-arguments": layoutCallArguments,
     "layout-call-array": layoutCallArray,
+    "layout-call-depth": layoutCallDepth,
     "layout-chain": layoutChain,
+    "layout-items": layoutItems,
     "layout-jsx-attributes": layoutJsxAttributes,
     "layout-key-value": layoutKeyValue,
     "layout-object": layoutObject,
     "layout-padding": layoutPadding,
+    "layout-pipe": layoutPipe,
     "layout-ternary": layoutTernary,
     "naming-declarations": namingDeclarations,
     "naming-exports": namingExports,