oxlint-plugin-arch 0.3.4 → 0.5.0

package/dist/rules/module-policy/index.js

@@ -0,0 +1,1743 @@
+// src/rules/module-policy/index.ts
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+// src/utils/helpers/syntax.ts
+import { defineRule } from "@oxlint/plugins";
+function syntaxRule(selector, message) {
+  return defineRule({
+    meta: { type: "problem", schema: [], messages: { forbidden: message } },
+    createOnce(context) {
+      return {
+        [selector]: (node) => context.report({ node, messageId: "forbidden" })
+      };
+    }
+  });
+}
+
+// src/rules/module-policy/service-types.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+var serviceTypes = defineRule2({
+  meta: {
+    type: "problem",
+    schema: [],
+    messages: {
+      domain: "Move this type to its domain types file; only the matching factory-derived Service alias belongs here."
+    }
+  },
+  createOnce(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        context.report({ node, messageId: "domain" });
+      },
+      TSTypeAliasDeclaration(node) {
+        const type = node.typeAnnotation;
+        const argument = type.type === "TSTypeReference" ? type.typeArguments?.params[0] : undefined;
+        const factory = argument?.type === "TSTypeQuery" && argument.exprName.type === "Identifier" ? argument.exprName.name : undefined;
+        if (node.id.name.endsWith("Service") && type.type === "TSTypeReference" && type.typeName.type === "Identifier" && type.typeName.name === "ReturnType" && type.typeArguments?.params.length === 1 && factory === `make${node.id.name}`) {
+          return;
+        }
+        context.report({ node, messageId: "domain" });
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/service-functions.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+
+// src/utils/helpers/ast.ts
+var astVisitSkip = new Set(["parent", "type", "start", "end", "range", "loc", "tokens", "comments"]);
+function astIsNode(value) {
+  return value !== null && typeof value === "object" && typeof Reflect.get(value, "type") === "string";
+}
+function astVisit(node, ancestors, callback) {
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      astVisit(child, ancestors, callback);
+    }
+    return;
+  }
+  if (!astIsNode(node)) {
+    return;
+  }
+  callback(node, ancestors);
+  ancestors.push(node);
+  for (const key in node) {
+    if (Object.hasOwn(node, key) && !astVisitSkip.has(key)) {
+      astVisit(Reflect.get(node, key), ancestors, callback);
+    }
+  }
+  ancestors.pop();
+}
+function astContainsJsx(node) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === "JSXElement" || candidate.type === "JSXFragment") {
+      found = true;
+    }
+  });
+  return found;
+}
+function astNearestFunction(ancestors) {
+  return [...ancestors].reverse().find((node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
+}
+function astDirectReturnExpressions(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return [node.body];
+  }
+  const expressions = [];
+  astVisit(node.body, [node], (candidate, ancestors) => {
+    if (candidate.type === "ReturnStatement" && candidate.argument && astNearestFunction(ancestors) === node) {
+      expressions.push(candidate.argument);
+    }
+  });
+  return expressions;
+}
+function astStaticMemberName(node) {
+  return !node.computed && node.property.type === "Identifier" ? node.property.name : undefined;
+}
+function astDottedName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type !== "MemberExpression") {
+    return;
+  }
+  const object = astDottedName(node.object);
+  const property = astStaticMemberName(node);
+  return object && property ? `${object}.${property}` : undefined;
+}
+function astCallName(node) {
+  if (node.callee.type === "Identifier") {
+    return node.callee.name;
+  }
+  return node.callee.type === "MemberExpression" ? astStaticMemberName(node.callee) : undefined;
+}
+function astImportedCallAliases(program) {
+  const aliases = new Map;
+  for (const statement of program.body) {
+    if (statement.type !== "ImportDeclaration") {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type !== "ImportSpecifier") {
+        continue;
+      }
+      const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+      if (imported !== specifier.local.name) {
+        aliases.set(specifier.local.name, imported);
+      }
+    }
+  }
+  return aliases;
+}
+function astResolvedCallName(node, aliases) {
+  const name = astCallName(node);
+  return name ? aliases.get(name) ?? name : undefined;
+}
+// src/utils/helpers/comments.ts
+var COMMENTS_DIRECTIVE = /^\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 COMMENTS_DISABLE_NEXT_LINE = /^(?:eslint|oxlint)-disable-next-line\b/;
+var COMMENTS_LEGAL_BLOCK = "\x00legal-block\x00";
+function commentsNormalizedValue(comment) {
+  const value = (comment.type === "Block" ? comment.value.replace(/^\s*\* ?/gm, "") : comment.value).trimStart();
+  return comment.type === "Block" && comment.value.startsWith("!") ? COMMENTS_LEGAL_BLOCK + value : value;
+}
+function commentsIsDirective(value) {
+  return value.startsWith(COMMENTS_LEGAL_BLOCK) || COMMENTS_DIRECTIVE.test(value);
+}
+function commentsIsDisableNextLine(value) {
+  return COMMENTS_DISABLE_NEXT_LINE.test(value);
+}
+function commentsIsWhy(value) {
+  return value.startsWith("Why: ");
+}
+function commentsIsJsdoc(source, comment) {
+  return comment.type === "Block" && source.startsWith("/**", comment.range[0]);
+}
+// src/utils/helpers/trivial.ts
+function trivialExpression(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return node.body;
+  }
+  if (!node.body || node.body.type !== "BlockStatement")
+    return null;
+  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
+  if (statements.length !== 1)
+    return null;
+  const statement = statements[0];
+  if (statement.type === "ReturnStatement")
+    return statement.argument;
+  return statement.type === "ExpressionStatement" ? statement.expression : null;
+}
+function trivialUnwrap(expression) {
+  if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "ChainExpression") {
+    return trivialUnwrap(expression.expression);
+  }
+  return expression.type === "AwaitExpression" ? trivialUnwrap(expression.argument) : expression;
+}
+function trivialCallRoot(expression) {
+  if (expression.type === "Identifier")
+    return expression.name;
+  if (expression.type === "MemberExpression" && !expression.computed && !expression.optional) {
+    return trivialCallRoot(expression.object);
+  }
+  return;
+}
+function trivialIsForwarder(node, expression) {
+  const value = trivialUnwrap(expression);
+  if (value.type === "Literal")
+    return !("regex" in value);
+  if (value.type === "TemplateLiteral")
+    return value.expressions.length === 0;
+  if (value.type === "Identifier")
+    return true;
+  if (value.type !== "CallExpression" || value.optional)
+    return false;
+  const root = trivialCallRoot(value.callee);
+  if (!root || node.params.some((param) => param.type !== "Identifier"))
+    return false;
+  const parameters = node.params.flatMap((param) => param.type === "Identifier" ? [param.name] : []);
+  const arguments_ = value.arguments;
+  const receiver = value.callee.type === "MemberExpression" ? root : undefined;
+  const forwarded = parameters.filter((name) => name !== receiver);
+  return arguments_.length === forwarded.length && arguments_.every((argument, index) => argument.type === "Identifier" && argument.name === forwarded[index]);
+}
+
+// src/utils/helpers/declarations.ts
+function declarationsTopLevelUnexportedFunctions(program) {
+  return program.body.flatMap((statement) => {
+    if (statement.type === "FunctionDeclaration") {
+      return [{ name: statement.id?.name ?? "<anonymous>", node: statement }];
+    }
+    if (statement.type !== "VariableDeclaration") {
+      return [];
+    }
+    return statement.declarations.flatMap((item) => item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression" ? [{ name: item.id.type === "Identifier" ? item.id.name : "<anonymous>", node: item.init }] : []);
+  });
+}
+function declarationsFileLevelFunctionCandidates(program) {
+  const result = [];
+  for (const statement of program.body) {
+    const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+    if (declaration?.type === "FunctionDeclaration") {
+      result.push({ name: declaration.id?.name ?? "<anonymous>", node: declaration });
+      continue;
+    }
+    if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") {
+      continue;
+    }
+    for (const item of declaration.declarations) {
+      if (item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression") {
+        result.push({
+          name: item.id.type === "Identifier" ? item.id.name : "<anonymous>",
+          node: declaration,
+          initializer: item.init
+        });
+      }
+    }
+  }
+  return result;
+}
+function declarationsIsObjectParam(node) {
+  if (node.type === "ObjectPattern") {
+    return true;
+  }
+  if (node.type === "TSParameterProperty") {
+    return declarationsIsObjectParam(node.parameter);
+  }
+  const annotation = node.typeAnnotation?.typeAnnotation;
+  return !annotation || annotation.type === "TSTypeReference" || annotation.type === "TSTypeLiteral" || annotation.type === "TSIntersectionType";
+}
+function declarationsFunctionName(node) {
+  if (node.type === "VariableDeclarator") {
+    return node.id.type === "Identifier" ? node.id.name : "<anonymous>";
+  }
+  return node.id?.name ?? "<anonymous>";
+}
+function declarationsIsRuntime(node) {
+  return node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration";
+}
+function declarationsRuntimeName(node) {
+  if (node.type === "VariableDeclaration") {
+    return node.declarations.map((item) => item.id.type === "Identifier" ? item.id.name : "<anonymous>").join(", ");
+  }
+  return node.id?.name ?? "<anonymous>";
+}
+function declarationsRuntimeKind(node) {
+  if (node.type === "ClassDeclaration") {
+    return "class";
+  }
+  if (node.type === "TSEnumDeclaration") {
+    return "enum";
+  }
+  if (node.type === "FunctionDeclaration") {
+    return "function";
+  }
+  return "variable";
+}
+function declarationsUnwrapExpression(node) {
+  if (node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression") {
+    return declarationsUnwrapExpression(node.expression);
+  }
+  if (node.type === "ChainExpression") {
+    return declarationsUnwrapExpression(node.expression);
+  }
+  return node.type === "AwaitExpression" && node.argument ? declarationsUnwrapExpression(node.argument) : node;
+}
+function declarationsIsTrivialExpression(node) {
+  const value = declarationsUnwrapExpression(node);
+  if (value.type === "Identifier" || value.type === "ThisExpression" || value.type === "MetaProperty" || value.type.endsWith("Literal")) {
+    return true;
+  }
+  if (value.type === "TemplateLiteral") {
+    return value.expressions.length === 0;
+  }
+  if (value.type === "MemberExpression" || value.type === "CallExpression" || value.type === "NewExpression" || value.type === "TaggedTemplateExpression") {
+    return true;
+  }
+  return value.type === "LogicalExpression" && declarationsIsTrivialExpression(value.left) && declarationsIsTrivialExpression(value.right);
+}
+function declarationsIsTrivialFunction(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return declarationsIsTrivialExpression(node.body);
+  }
+  if (!node.body || node.body.type !== "BlockStatement") {
+    return false;
+  }
+  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
+  if (statements.length === 0) {
+    return true;
+  }
+  if (statements.length > 1) {
+    return false;
+  }
+  const statement = statements[0];
+  if (statement.type === "ReturnStatement") {
+    return !statement.argument || declarationsIsTrivialExpression(statement.argument);
+  }
+  return statement.type === "ExpressionStatement" && declarationsIsTrivialExpression(statement.expression);
+}
+var declarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
+function declarationsNamedKind(node, ancestors) {
+  if (node.type === "FunctionDeclaration") {
+    return "function";
+  }
+  if (node.type === "ClassDeclaration") {
+    return "class";
+  }
+  if (node.type === "TSTypeAliasDeclaration") {
+    return "type";
+  }
+  if (node.type === "TSInterfaceDeclaration") {
+    return "interface";
+  }
+  if (node.type === "TSEnumDeclaration") {
+    return "enum";
+  }
+  if (node.type !== "VariableDeclarator") {
+    return;
+  }
+  const declaration = ancestors.findLast((ancestor) => ancestor.type === "VariableDeclaration");
+  return declaration?.type === "VariableDeclaration" && (declaration.kind === "const" || declaration.kind === "let" || declaration.kind === "var") ? declaration.kind : undefined;
+}
+function declarationsCollectNamed(root, kinds) {
+  const allowed = kinds && kinds.length > 0 ? new Set(kinds) : null;
+  const result = [];
+  astVisit(root, [], (node, ancestors) => {
+    const kind = declarationsNamedKind(node, ancestors);
+    const name = node.type === "VariableDeclarator" && node.id.type === "Identifier" ? node.id.name : ("id" in node) && node.id && ("name" in node.id) ? node.id.name : undefined;
+    if (!kind || !name || allowed && !allowed.has(kind)) {
+      return;
+    }
+    if (node.type === "VariableDeclarator" && ancestors.some((ancestor) => ancestor.type === "ForStatement" || ancestor.type === "ForInStatement" || ancestor.type === "ForOfStatement")) {
+      return;
+    }
+    result.push({ name, node, kind });
+  });
+  return result;
+}
+function declarationsInsideForLoop(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement") {
+      return true;
+    }
+  }
+  return false;
+}
+function declarationsNamedFromNode(node) {
+  if (node.type === "VariableDeclarator") {
+    const kind = declarationsNamedKind(node, [node.parent]);
+    return kind && node.id.type === "Identifier" && !declarationsInsideForLoop(node) ? { name: node.id.name, node, kind } : undefined;
+  }
+  const kind = declarationsNamedKind(node, []);
+  const name = "id" in node && node.id && "name" in node.id ? node.id.name : undefined;
+  return kind && name ? { name, node, kind } : undefined;
+}
+function declarationsCollectFunctions(root) {
+  return declarationsCollectNamed(root).flatMap((item) => {
+    if (item.node.type === "FunctionDeclaration") {
+      return [{ name: item.name, node: item.node }];
+    }
+    if (item.node.type === "VariableDeclarator" && (item.node.init?.type === "FunctionExpression" || item.node.init?.type === "ArrowFunctionExpression")) {
+      return [{ name: item.name, node: item.node.init }];
+    }
+    return [];
+  });
+}
+function declarationsPublicServiceMethods(program) {
+  return program.body.flatMap((statement) => {
+    if (statement.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "VariableDeclaration" || statement.declaration.kind !== "const")
+      return [];
+    return statement.declaration.declarations.flatMap((binding) => {
+      if (binding.id.type !== "Identifier" || !binding.init)
+        return [];
+      const value = trivialUnwrap(binding.init);
+      if (value.type !== "ObjectExpression" || value.properties.length === 0)
+        return [];
+      const methods = value.properties.flatMap((property) => property.type === "Property" && property.method && property.kind === "init" && !property.computed && property.key.type === "Identifier" && property.value.type === "FunctionExpression" ? [{ name: property.key.name, node: property.value, binding }] : []);
+      return methods.length === value.properties.length ? methods : [];
+    });
+  });
+}
+// src/utils/helpers/exports.ts
+function moduleExportName(node) {
+  return node.type === "Identifier" ? node.name : node.value;
+}
+function declarationBindings(declaration) {
+  if (!declaration || declaration.type === "TSModuleDeclaration") {
+    return [];
+  }
+  if (declaration.type === "VariableDeclaration") {
+    return declaration.declarations.map((item) => ({
+      exportedName: item.id.type === "Identifier" ? item.id.name : "<anonymous>",
+      localName: item.id.type === "Identifier" ? item.id.name : undefined,
+      node: declaration,
+      declaration,
+      initializer: item.init,
+      typeOnly: false,
+      default: false,
+      reExport: false
+    }));
+  }
+  const name = declaration.id?.name ?? "<anonymous>";
+  return [
+    {
+      exportedName: name,
+      localName: declaration.id?.name,
+      node: declaration,
+      declaration,
+      typeOnly: declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || declaration.type === "TSDeclareFunction",
+      default: false,
+      reExport: false
+    }
+  ];
+}
+function localBindings(program) {
+  const result = new Map;
+  for (const statement of program.body) {
+    if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") {
+      continue;
+    }
+    if (statement.type.endsWith("Declaration")) {
+      for (const binding of declarationBindings(statement)) {
+        if (binding.localName) {
+          result.set(binding.localName, binding);
+        }
+      }
+    }
+  }
+  return result;
+}
+function exportsCollect(program) {
+  const locals = localBindings(program);
+  return program.body.flatMap((statement) => {
+    if (statement.type === "ExportAllDeclaration") {
+      return [
+        {
+          exportedName: "*",
+          node: statement,
+          typeOnly: statement.exportKind === "type",
+          default: false,
+          reExport: true
+        }
+      ];
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      if (statement.declaration.type === "Identifier") {
+        const local = locals.get(statement.declaration.name);
+        return [
+          {
+            ...local ?? {
+              exportedName: "default",
+              node: statement,
+              typeOnly: false,
+              default: true,
+              reExport: false
+            },
+            exportedName: "default",
+            localName: local?.localName ?? statement.declaration.name,
+            default: true
+          }
+        ];
+      }
+      if (statement.declaration.type.endsWith("Declaration")) {
+        const bindings = declarationBindings(statement.declaration);
+        return bindings.length > 0 ? bindings.map((binding) => ({ ...binding, exportedName: "default", default: true })) : [{ exportedName: "default", node: statement, typeOnly: false, default: true, reExport: false }];
+      }
+      return [{ exportedName: "default", node: statement, typeOnly: false, default: true, reExport: false }];
+    }
+    if (statement.type !== "ExportNamedDeclaration") {
+      return [];
+    }
+    return [
+      ...declarationBindings(statement.declaration),
+      ...statement.specifiers.map((specifier) => {
+        const localName = moduleExportName(specifier.local);
+        const local = locals.get(localName);
+        return {
+          ...local ?? {
+            exportedName: moduleExportName(specifier.exported),
+            node: specifier,
+            typeOnly: false,
+            default: false,
+            reExport: Boolean(statement.source)
+          },
+          exportedName: moduleExportName(specifier.exported),
+          localName,
+          node: local?.node ?? specifier,
+          typeOnly: specifier.exportKind === "type" || statement.exportKind === "type" || Boolean(local?.typeOnly),
+          default: moduleExportName(specifier.exported) === "default",
+          reExport: Boolean(statement.source)
+        };
+      })
+    ];
+  });
+}
+function exportsCollectFunctions(program) {
+  return exportsCollect(program).flatMap((binding) => {
+    const name = binding.localName ?? binding.exportedName;
+    if (binding.declaration?.type === "FunctionDeclaration") {
+      return [{ name, node: binding.declaration }];
+    }
+    return binding.initializer?.type === "FunctionExpression" || binding.initializer?.type === "ArrowFunctionExpression" ? [{ name, node: binding.initializer }] : [];
+  });
+}
+// src/utils/helpers/naming.ts
+function namingPosixPath(filePath) {
+  return filePath.replaceAll("\\", "/");
+}
+function namingFileBasename(filePath) {
+  const normalized = namingPosixPath(filePath);
+  const slash = normalized.lastIndexOf("/");
+  return slash === -1 ? normalized : normalized.slice(slash + 1);
+}
+function namingDirSegments(filePath) {
+  const parts = namingPosixPath(filePath).split("/").filter(Boolean);
+  return parts.slice(0, -1);
+}
+function namingSegmentsAfter(filePath, after) {
+  const dirs = namingDirSegments(filePath);
+  const marker = after.split("/").filter(Boolean);
+  if (marker.length === 0) {
+    return;
+  }
+  for (let index = dirs.length - marker.length;index >= 0; index -= 1) {
+    if (marker.every((part, offset) => dirs[index + offset] === part)) {
+      return dirs.slice(index + marker.length);
+    }
+  }
+}
+function namingFolderPrefixes(folders, separator, singularize) {
+  const joined = folders.join(separator);
+  const last = folders.at(-1) ?? "";
+  const prefixes = [joined];
+  if (singularize === "trailing-s" && last.endsWith("s") && last.length > 1) {
+    prefixes.push([...folders.slice(0, -1), last.slice(0, -1)].join(separator));
+  }
+  return prefixes.filter(Boolean);
+}
+function namingPascalCase(value) {
+  return value.split(/[-_\s.]+/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+function namingCamelCase(value) {
+  const next = namingPascalCase(value);
+  return `${next.charAt(0).toLowerCase()}${next.slice(1)}`;
+}
+function namingMatchTemplate(basename, template, placeholderPattern = "[a-z0-9-]+") {
+  let pattern = "";
+  let index = 0;
+  while (index < template.length) {
+    const char = template[index];
+    if (char === "{") {
+      const end = template.indexOf("}", index);
+      if (end === -1) {
+        return null;
+      }
+      const key = template.slice(index + 1, end);
+      pattern += `(?<${key}>${placeholderPattern})`;
+      index = end + 1;
+      continue;
+    }
+    pattern += /[.+^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
+    index += 1;
+  }
+  return new RegExp(`^${pattern}$`).exec(basename)?.groups ?? null;
+}
+var namingStemModes = ["before-first-dot", "full-basename"];
+function namingNormalized(value, normalize) {
+  return normalize === "none" ? value : value.replaceAll(/[-_.]/g, "").toLowerCase();
+}
+function namingFileStem(basename, mode = "before-first-dot", trailingRoles = [], roleSeparators = [".", "-"]) {
+  const stem = mode === "full-basename" ? basename : basename.split(".")[0] ?? "";
+  const roles = [...new Set(trailingRoles.filter(Boolean))].sort((left, right) => right.length - left.length);
+  const separators = [...new Set(roleSeparators.filter(Boolean))];
+  if (roles.length === 0 || separators.length === 0) {
+    return stem;
+  }
+  let remaining = stem;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const role of roles) {
+      for (const separator of separators) {
+        const suffix = `${separator}${role}`;
+        if (remaining.length > suffix.length && remaining.endsWith(suffix)) {
+          remaining = remaining.slice(0, -suffix.length);
+          changed = true;
+          break;
+        }
+      }
+      if (changed) {
+        break;
+      }
+    }
+  }
+  return remaining;
+}
+function namingFilePrefixes(stem, normalize = "remove-separators", singularize = "none") {
+  const prefixes = [namingNormalized(stem, normalize)];
+  const parts = stem.split(/[-_]+/).filter(Boolean);
+  const last = parts.at(-1) ?? "";
+  if (singularize === "trailing-s" && last.endsWith("s") && last.length > 1) {
+    prefixes.push(namingNormalized([...parts.slice(0, -1), last.slice(0, -1)].join("-"), normalize));
+  }
+  return [...new Set(prefixes.filter(Boolean))];
+}
+
+// src/utils/helpers/factories.ts
+function factoriesExpandTemplate(template, groups, camelCase = false) {
+  return template.replaceAll(/\{([^}]+)\}/g, (placeholder, key) => {
+    const group = groups[key.toLowerCase()];
+    if (!group) {
+      return placeholder;
+    }
+    if (/^[A-Z]/.test(key)) {
+      return namingPascalCase(group);
+    }
+    return camelCase ? namingCamelCase(group) : group;
+  });
+}
+function factoriesCollectTopLevel(program, pattern) {
+  return program.body.flatMap((statement) => {
+    const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+    if (declaration?.type === "FunctionDeclaration") {
+      const name = declaration.id?.name ?? "<anonymous>";
+      return pattern.test(name) ? [{ name, node: declaration }] : [];
+    }
+    if (declaration?.type !== "VariableDeclaration") {
+      return [];
+    }
+    return declaration.declarations.flatMap((item) => item.id.type === "Identifier" && pattern.test(item.id.name) && (item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression") ? [{ name: item.id.name, node: item.init }] : []);
+  });
+}
+function factoriesDirectlyReturnedObjects(factory) {
+  if (factory.node.type === "ArrowFunctionExpression" && factory.node.body.type === "ObjectExpression") {
+    return [factory.node.body];
+  }
+  const result = [];
+  astVisit(factory.node.body, [factory.node], (node, ancestors) => {
+    if (node.type === "ReturnStatement" && node.argument?.type === "ObjectExpression" && astNearestFunction(ancestors) === factory.node) {
+      result.push(node.argument);
+    }
+  });
+  return result;
+}
+function factoriesObjectPropertyName(property) {
+  if (property.type === "SpreadElement" || property.computed) {
+    return;
+  }
+  if (property.key.type === "Identifier") {
+    return property.key.name;
+  }
+  return property.key.type === "Literal" && typeof property.key.value === "string" ? property.key.value : undefined;
+}
+// src/utils/helpers/guards.ts
+var guardsPrimitiveNames = new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "undefined",
+  "bigint",
+  "symbol",
+  "function"
+]);
+function guardsValue(node, state) {
+  const value = trivialUnwrap(node);
+  if (value.type === "Identifier")
+    return state.values.has(value.name);
+  return value.type === "MemberExpression" && value.computed && value.object.type === "Identifier" && state.values.has(value.object.name) && value.property.type === "Identifier" && state.values.has(value.property.name);
+}
+function guardsFallback(node) {
+  return node.type === "Literal" && !("regex" in node) || node.type === "Identifier" && node.name === "undefined" || node.type === "ArrayExpression" && node.elements.length === 0 || node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function guardsPredicate(expression, state) {
+  const node = trivialUnwrap(expression);
+  if (node.type === "Identifier")
+    return state.predicates.has(node.name);
+  if (node.type === "UnaryExpression" && node.operator === "!")
+    return guardsPredicate(node.argument, state);
+  if (node.type === "LogicalExpression" && (node.operator === "&&" || node.operator === "||")) {
+    return guardsPredicate(node.left, state) && guardsPredicate(node.right, state);
+  }
+  if (node.type === "BinaryExpression" && ["===", "!==", "==", "!="].includes(node.operator)) {
+    for (const [left, right] of [
+      [node.left, node.right],
+      [node.right, node.left]
+    ]) {
+      if (left.type === "UnaryExpression" && left.operator === "typeof" && right.type === "Literal" && typeof right.value === "string" && guardsPrimitiveNames.has(right.value) && guardsValue(left.argument, state)) {
+        state.primitive = true;
+        return true;
+      }
+      if (left.type !== "PrivateIdentifier" && guardsValue(left, state) && (right.type === "Literal" && right.value === null || right.type === "Identifier" && right.name === "undefined"))
+        return true;
+    }
+  }
+  if (node.type === "CallExpression" && !node.optional && node.arguments.length === 1 && node.arguments[0].type !== "SpreadElement" && guardsValue(node.arguments[0], state) && node.callee.type === "MemberExpression" && !node.callee.computed && !node.callee.optional && node.callee.object.type === "Identifier" && node.callee.object.name === "Array" && node.callee.property.type === "Identifier" && node.callee.property.name === "isArray" && state.globalArray(node.callee.object)) {
+    state.primitive = true;
+    return true;
+  }
+  return false;
+}
+function guardsResult(node, state) {
+  const value = trivialUnwrap(node);
+  if (guardsValue(value, state) || guardsFallback(value) || guardsPredicate(value, state))
+    return true;
+  return value.type === "ConditionalExpression" && guardsPredicate(value.test, state) && guardsResult(value.consequent, state) && guardsResult(value.alternate, state);
+}
+function guardsStatement(node, state) {
+  if (node.type === "EmptyStatement" || node.type === "ExpressionStatement" && Boolean(node.directive))
+    return true;
+  if (node.type === "ReturnStatement" && node.argument) {
+    state.returned = true;
+    return guardsResult(node.argument, state);
+  }
+  if (node.type === "BlockStatement")
+    return node.body.every((statement) => guardsStatement(statement, state));
+  if (node.type === "IfStatement") {
+    return guardsPredicate(node.test, state) && guardsStatement(node.consequent, state) && (!node.alternate || guardsStatement(node.alternate, state));
+  }
+  if (node.type === "VariableDeclaration" && node.kind === "const") {
+    return node.declarations.every((declaration) => {
+      if (declaration.id.type !== "Identifier" || !declaration.init)
+        return false;
+      if (guardsValue(declaration.init, state)) {
+        state.values.add(declaration.id.name);
+        return true;
+      }
+      if (guardsPredicate(declaration.init, state)) {
+        state.predicates.add(declaration.id.name);
+        return true;
+      }
+      return guardsFallback(declaration.init);
+    });
+  }
+  return false;
+}
+function guardsIsGenericHelper(node, globalArray) {
+  if (!node.body || node.params.length === 0 || node.params.some((param) => param.type !== "Identifier"))
+    return false;
+  const state = {
+    values: new Set(node.params.flatMap((param) => param.type === "Identifier" ? [param.name] : [])),
+    predicates: new Set,
+    primitive: false,
+    returned: false,
+    globalArray
+  };
+  if (node.body.type !== "BlockStatement")
+    return guardsResult(node.body, state) && state.primitive;
+  return node.body.body.every((statement) => guardsStatement(statement, state)) && state.primitive && state.returned;
+}
+// src/utils/helpers/layout.ts
+var layoutIndentSchema = {
+  anyOf: [
+    { type: "integer", minimum: 0 },
+    { type: "string", enum: ["tab"] }
+  ]
+};
+function layoutLineIndent(text, offset) {
+  const lineStart = text.lastIndexOf(`
+`, offset - 1) + 1;
+  return /^[\t ]*/.exec(text.slice(lineStart, offset))?.[0] ?? "";
+}
+function layoutIndentUnit(indent = 2) {
+  return indent === "tab" ? "\t" : " ".repeat(indent);
+}
+function layoutNewline(text) {
+  return text.includes(`\r
+`) ? `\r
+` : `
+`;
+}
+// src/utils/helpers/options.ts
+function optionsFirst(context, fallback) {
+  return context.options[0] ?? fallback;
+}
+var optionsPatternSchema = {
+  anyOf: [{ type: "string" }, { type: "array", items: { type: "string" }, minItems: 1 }]
+};
+function optionsPatterns(pattern, flags) {
+  return pattern === undefined ? [] : [pattern].flat().map((source) => new RegExp(source, flags));
+}
+function optionsOptionalPatterns(pattern, flags) {
+  return optionsPatterns(pattern === undefined ? undefined : [pattern].flat().filter((source) => source !== ""), flags);
+}
+function optionsPatternLabel(pattern) {
+  return pattern === undefined ? "" : [pattern].flat().join(" | ");
+}
+function optionsPatternsTest(patterns, value) {
+  return patterns.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  });
+}
+// src/utils/helpers/orpc.ts
+function orpcFindChainCall(expression, method) {
+  if (expression.type === "CallExpression") {
+    if (expression.callee.type === "MemberExpression" && astStaticMemberName(expression.callee) === method) {
+      return expression;
+    }
+    if (expression.callee.type === "MemberExpression") {
+      return orpcFindChainCall(expression.callee.object, method);
+    }
+  }
+  if (expression.type === "MemberExpression") {
+    return orpcFindChainCall(expression.object, method);
+  }
+  if (expression.type === "ChainExpression") {
+    return orpcFindChainCall(expression.expression, method);
+  }
+}
+function orpcIsNamedOrComposedArgument(argument, composers) {
+  if (argument?.type === "Identifier") {
+    return true;
+  }
+  return argument?.type === "CallExpression" && argument.callee.type === "Identifier" && composers.has(argument.callee.name) && argument.arguments[0]?.type === "Identifier";
+}
+// src/utils/helpers/react-components.ts
+function reactComponentsExportCandidates(program) {
+  return exportsCollect(program).map((binding) => ({
+    ...binding,
+    name: binding.localName ?? binding.exportedName
+  }));
+}
+function importedPropsWithChildren(program) {
+  return new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" && statement.source.value === "react" ? statement.specifiers.flatMap((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "PropsWithChildren" ? [specifier.local.name] : []) : []));
+}
+function containsNamedTypeReference(node, names) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === "TSTypeReference" && candidate.typeName.type === "Identifier" && names.has(candidate.typeName.name)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function returnsReactChildren(program, node, expressions) {
+  const returnedNames = new Set(expressions.flatMap((expression) => expression.type === "Identifier" ? [expression.name] : []));
+  const propsWithChildren = importedPropsWithChildren(program);
+  return node.params.some((param) => {
+    if (param.type !== "ObjectPattern") {
+      return false;
+    }
+    const returnsChild = param.properties.some((property) => property.type === "Property" && property.value.type === "Identifier" && returnedNames.has(property.value.name));
+    return returnsChild && containsNamedTypeReference(param.typeAnnotation, propsWithChildren);
+  });
+}
+function reactComponentsFunctionReturnsOutput(program, node) {
+  const expressions = astDirectReturnExpressions(node);
+  return expressions.some((expression) => astContainsJsx(expression) || expression.type === "Literal" && expression.value === null) || returnsReactChildren(program, node, expressions);
+}
+function functionReturnsLocalComponent(program, node) {
+  const componentNames = new Set;
+  astVisit(node.body, [node], (candidate, ancestors) => {
+    if (candidate.type === "FunctionDeclaration" && candidate !== node && candidate.id?.name && /^[A-Z]/.test(candidate.id.name) && astNearestFunction(ancestors) === node && reactComponentsFunctionReturnsOutput(program, candidate)) {
+      componentNames.add(candidate.id.name);
+    }
+  });
+  return astDirectReturnExpressions(node).some((expression) => expression.type === "Identifier" && componentNames.has(expression.name));
+}
+function componentFactoryNames(program) {
+  return new Set(program.body.flatMap((statement) => statement.type === "FunctionDeclaration" && statement.id?.name && functionReturnsLocalComponent(program, statement) ? [statement.id.name] : []));
+}
+function isComponentInitializer(program, initializer) {
+  if (!initializer) {
+    return false;
+  }
+  if (initializer.type === "ArrowFunctionExpression" || initializer.type === "FunctionExpression") {
+    return reactComponentsFunctionReturnsOutput(program, initializer);
+  }
+  if (initializer.type !== "CallExpression") {
+    return false;
+  }
+  const name = astCallName(initializer);
+  if (name === "forwardRef" || name === "memo") {
+    return initializer.arguments.some((argument) => argument.type !== "SpreadElement" && isComponentInitializer(program, argument));
+  }
+  if (name === "lazy") {
+    return initializer.arguments.some((argument) => argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression");
+  }
+  return Boolean(name?.startsWith("create") && componentFactoryNames(program).has(name));
+}
+function reactComponentsIsLike(program, candidate) {
+  if (!/^[A-Z]/.test(candidate.name)) {
+    return false;
+  }
+  const declaration = candidate.declaration ?? candidate.node;
+  if (declaration.type === "FunctionDeclaration") {
+    return reactComponentsFunctionReturnsOutput(program, declaration);
+  }
+  return declaration.type === "VariableDeclaration" && isComponentInitializer(program, candidate.initializer);
+}
+function reactComponentsPascalFromBasename(basename) {
+  return basename.replace(/\.(tsx?|jsx?)$/, "").split(/[-.]/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+// src/utils/helpers/routes.ts
+function routesInspectFunction(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)) {
+      context.report({
+        node,
+        messageId: "hostJsx",
+        data: { name: item.name }
+      });
+    }
+    if (node.type === "CallExpression") {
+      const name = astCallName(node);
+      if (name && bannedHooks.has(name)) {
+        context.report({
+          node,
+          messageId: "bannedHook",
+          data: { hook: name, name: item.name }
+        });
+      }
+    }
+  });
+}
+// src/utils/helpers/sanitizers.ts
+function sanitizersCallsConfigured(node, names) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === "CallExpression" && candidate.callee.type === "Identifier" && names.has(candidate.callee.name)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function sanitizersConfiguredBindings(program, names) {
+  const result = new Set;
+  for (const statement of program.body) {
+    const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+    if (declaration?.type !== "VariableDeclaration") {
+      continue;
+    }
+    for (const item of declaration.declarations) {
+      if (item.id.type === "Identifier" && sanitizersCallsConfigured(item.init, names)) {
+        result.add(item.id.name);
+      }
+    }
+  }
+  return result;
+}
+// src/utils/helpers/schemas.ts
+function schemasIsRuntimeSpecifier(specifier) {
+  return specifier.type !== "ImportSpecifier" || specifier.importKind !== "type";
+}
+function schemasMemberRootName(node) {
+  if (node.object.type === "Identifier") {
+    return node.object.name;
+  }
+  return node.object.type === "MemberExpression" ? schemasMemberRootName(node.object) : undefined;
+}
+function schemasIsPackage(source, packages) {
+  return packages.has(source) || [...packages].some((pkg) => source.startsWith(`${pkg}/`));
+}
+function schemasIsCall(node, namespaces) {
+  return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && namespaces.has(node.callee.object.name);
+}
+function schemasRuntimeImportLocals(node) {
+  return node.importKind === "type" ? [] : node.specifiers.flatMap((specifier) => schemasIsRuntimeSpecifier(specifier) ? [specifier.local.name] : []);
+}
+function schemasIsRuntimeImport(node, packages) {
+  return schemasIsPackage(node.source.value, packages) && (node.specifiers.length === 0 ? node.importKind !== "type" : schemasRuntimeImportLocals(node).length > 0);
+}
+function schemasIsRuntimeReexport(node, packages) {
+  if (!node.source || !schemasIsPackage(node.source.value, packages) || node.exportKind === "type") {
+    return false;
+  }
+  return node.type === "ExportAllDeclaration" || node.specifiers.length === 0 || node.specifiers.some((specifier) => specifier.exportKind !== "type");
+}
+function schemasIsConstruction(node, constructors) {
+  if (node.callee.type === "Identifier") {
+    return constructors.has(node.callee.name);
+  }
+  if (node.callee.type !== "MemberExpression") {
+    return false;
+  }
+  const root = schemasMemberRootName(node.callee);
+  return Boolean(root && constructors.has(root));
+}
+function schemasElements(node) {
+  return node.arguments.flatMap((argument) => argument.type === "ArrayExpression" ? argument.elements.filter((element) => element !== null) : [argument]);
+}
+function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMethods) {
+  if (node.type === "Identifier") {
+    return true;
+  }
+  if (!allowScalars || node.type !== "CallExpression" || !schemasIsCall(node, namespaces)) {
+    return false;
+  }
+  const name = node.callee.type === "MemberExpression" ? astStaticMemberName(node.callee) : undefined;
+  return Boolean(name && !structuralMethods.has(name));
+}
+function schemasTypeOperator(node, namespaces, operators) {
+  return node.typeName.type === "TSQualifiedName" && node.typeName.left.type === "Identifier" && namespaces.has(node.typeName.left.name) && operators.has(node.typeName.right.name) ? node.typeName.right.name : undefined;
+}
+// src/utils/helpers/boundaries.ts
+import { resolve, dirname } from "node:path";
+function boundaryResolveTarget(options, file, source) {
+  const owner = [...options.web, ...options.backend].sort((a, b) => b.length - a.length).find((root) => file.startsWith(root + "/"));
+  const web = owner && options.web.includes(owner) ? owner : undefined;
+  const alias = Object.entries(options.aliases).sort(([a], [b]) => b.length - a.length).find(([prefix]) => source === prefix || source.startsWith(`${prefix}/`));
+  return alias ? resolve(alias[1], source.slice(alias[0].length).replace(/^\//, "")).replaceAll("\\", "/") : source.startsWith(".") ? resolve(dirname(file), source).replaceAll("\\", "/") : source.startsWith("@/") && web ? `${web}/${source.slice(2)}` : source.startsWith("#/") && owner ? `${owner}/${source.slice(2)}` : source.startsWith("#services/") && owner ? `${owner}/services/${source.slice(10)}` : source;
+}
+// src/rules/module-policy/service-functions.ts
+var serviceFunctions = defineRule3({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          frontend: { type: "boolean" },
+          allowLocalHelpers: { type: "boolean" },
+          allowReturnedMethods: { type: "boolean" },
+          singleExport: { type: "boolean" },
+          message: { type: "string" }
+        }
+      }
+    ],
+    messages: {
+      helper: "{{name}}: {{message}}",
+      exports: "{{message}}"
+    }
+  },
+  createOnce(context) {
+    let operation;
+    let operations = new Set;
+    let allowLocalHelpers = false;
+    let allowReturnedMethods = false;
+    let message = "";
+    function owner(node) {
+      for (let parent = node.parent;parent; parent = parent.parent) {
+        if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression")
+          return parent;
+        if (parent.type === "Program")
+          return;
+      }
+      return;
+    }
+    function insideOperation(node) {
+      for (let parent = node.parent;parent; parent = parent.parent) {
+        if (operations.has(parent))
+          return true;
+      }
+      return false;
+    }
+    function returnedMethod(node) {
+      if (!allowReturnedMethods || !operation || owner(node) !== operation)
+        return false;
+      return context.sourceCode.getDeclaredVariables(node).some((variable) => variable.references.some((reference) => {
+        const property = reference.identifier.parent;
+        if (property.type !== "Property" || property.value !== reference.identifier || property.parent.type !== "ObjectExpression")
+          return false;
+        const object = property.parent;
+        if (object.parent.type !== "ReturnStatement" || object.parent.argument !== object)
+          return false;
+        return owner(object) === operation;
+      }));
+    }
+    return {
+      Program(program) {
+        const options = optionsFirst(context, {});
+        const candidates = declarationsFileLevelFunctionCandidates(program);
+        const exported = exportsCollectFunctions(program);
+        operation = exported.length === 1 ? exported[0].node : undefined;
+        operations = new Set(options.frontend && !options.singleExport ? exported.map((entry) => entry.node) : operation ? [operation] : []);
+        if (options.frontend && !options.singleExport) {
+          for (const method of declarationsPublicServiceMethods(program))
+            operations.add(method.node);
+        }
+        allowLocalHelpers = options.frontend || (options.allowLocalHelpers ?? false);
+        allowReturnedMethods = options.allowReturnedMethods ?? false;
+        message = options.message ?? (options.frontend ? "Frontend service modules expose public domain operations. Keep operation-only helpers inside their public operation and genuinely shared helpers in domain .utils.ts; file-level private functions are forbidden." : allowLocalHelpers ? "Keep this helper inside the one exported operation; domain .utils.ts is only for genuinely shared logic." : "This service contract does not allow private helpers. Keep its existing factory/operation contract; domain .utils.ts is only for genuinely shared logic. Do not add a fake factory or public helper export.");
+        if (options.singleExport) {
+          const bindings = exportsCollect(program);
+          if (bindings.length !== 1 || !operation || bindings[0].default || bindings[0].reExport || bindings[0].typeOnly) {
+            context.report({
+              node: program,
+              messageId: "exports",
+              data: {
+                message: options.message ?? "Export exactly one named operation. Do not export helpers, types, constants or re-exports."
+              }
+            });
+          }
+        }
+        for (const candidate of candidates) {
+          if ((options.frontend && !options.singleExport || candidates.length === 1) && exported.some((entry) => entry.name === candidate.name)) {
+            continue;
+          }
+          context.report({ node: candidate.node, messageId: "helper", data: { message, name: candidate.name } });
+        }
+      },
+      FunctionDeclaration(node) {
+        if (node.parent.type === "Program" || node.parent.type === "ExportNamedDeclaration") {
+          return;
+        }
+        if (returnedMethod(node) || allowLocalHelpers && insideOperation(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "helper",
+          data: { message, name: node.id?.type === "Identifier" ? node.id.name : "<anonymous>" }
+        });
+      },
+      VariableDeclarator(node) {
+        if (node.init?.type !== "ArrowFunctionExpression" && node.init?.type !== "FunctionExpression") {
+          return;
+        }
+        if (node.parent.parent?.type === "Program" || node.parent.parent?.type === "ExportNamedDeclaration") {
+          return;
+        }
+        if (returnedMethod(node))
+          return;
+        if (allowLocalHelpers && insideOperation(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "helper",
+          data: { message, name: node.id.type === "Identifier" ? node.id.name : "<anonymous>" }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/domain-constants.ts
+import { basename, dirname as dirname2 } from "node:path";
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+var domainConstants = defineRule4({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { includeData: { type: "boolean" }, allowServiceMethods: { type: "boolean" } }
+      }
+    ],
+    messages: {
+      forbidden: "'{{name}}' belongs in '{{file}}' under this module-data policy. Use a domain-prefixed name; do not invent a factory to silence the rule."
+    }
+  },
+  createOnce(context) {
+    let serviceObjects = new Set;
+    function data(expression) {
+      const value = trivialUnwrap(expression);
+      if (value.type === "Literal" || value.type === "ArrayExpression" || value.type === "ObjectExpression")
+        return true;
+      if (value.type === "TemplateLiteral")
+        return value.expressions.every(data);
+      if (value.type === "UnaryExpression")
+        return data(value.argument);
+      if (value.type === "BinaryExpression" || value.type === "LogicalExpression")
+        return value.left.type !== "PrivateIdentifier" && data(value.left) && data(value.right);
+      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;
+    }
+    return {
+      Program(program) {
+        serviceObjects = new Set(optionsFirst(context, {}).allowServiceMethods ? declarationsPublicServiceMethods(program).map((method) => method.binding) : []);
+      },
+      VariableDeclarator(node) {
+        if (serviceObjects.has(node))
+          return;
+        const declaration = node.parent;
+        if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const" || declaration.parent.type !== "Program" && declaration.parent.type !== "ExportNamedDeclaration")
+          return;
+        const options = optionsFirst(context, {});
+        if (node.id.type === "Identifier" && /^[A-Z][A-Z0-9_]+$/.test(node.id.name) || options.includeData && node.init && data(node.init)) {
+          const file = context.filename.replaceAll("\\", "/");
+          const owner = file.includes("/services/") && dirname2(file).split("/").at(-1) !== "services" ? basename(dirname2(file)) : basename(file).split(".")[0].replace(/-(?:action|query)$/, "");
+          context.report({
+            node,
+            messageId: "forbidden",
+            data: {
+              name: node.id.type === "Identifier" ? node.id.name : "<destructured binding>",
+              file: `${owner}.constants.ts`
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/test-modifiers.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var testModifiers = defineRule5({
+  meta: {
+    type: "problem",
+    schema: [],
+    messages: {
+      modifier: "Focused, skipped and placeholder tests are not allowed."
+    }
+  },
+  createOnce(context) {
+    let names = new Set;
+    return {
+      before() {
+        names = new Set(["test", "it", "describe", "suite"]);
+      },
+      ImportDeclaration(node) {
+        if (!["vitest", "bun:test", "@playwright/test", "@jest/globals"].includes(node.source.value)) {
+          return;
+        }
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier") {
+            continue;
+          }
+          const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+          if (["test", "it", "describe", "suite"].includes(imported)) {
+            names.add(specifier.local.name);
+          }
+        }
+      },
+      MemberExpression(node) {
+        const name = astDottedName(node);
+        if (!name) {
+          return;
+        }
+        const parts = name.split(".");
+        if (names.has(parts[0]) && ["only", "skip", "todo"].includes(parts.at(-1) ?? "")) {
+          context.report({ node, messageId: "modifier" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/reasoned-directives.ts
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var directives = defineRule6({
+  meta: {
+    type: "problem",
+    schema: [],
+    messages: {
+      directive: "Lint disables must name specific rules and explain why after --."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program() {
+        for (const comment of context.sourceCode.getAllComments()) {
+          const match = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?\b(.*)$/s.exec(comment.value);
+          if (!match) {
+            continue;
+          }
+          const [rules, ...reason] = match[1].split("--");
+          if (rules.trim() && reason.join("--").trim()) {
+            continue;
+          }
+          context.report({ loc: comment.loc, messageId: "directive" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/tanstack-runtime.ts
+import { builtinModules } from "node:module";
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var tanstackRuntime = defineRule7({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          web: { type: "array", items: { type: "string" } },
+          backend: { type: "array", items: { type: "string" } },
+          aliases: { type: "object", additionalProperties: { type: "string" } },
+          backendPackages: { type: "array", items: { type: "string" } },
+          rpcClients: { type: "array", items: { type: "string" } },
+          serverImports: { type: "array", items: { type: "string" } },
+          clientImports: { type: "array", items: { type: "string" } },
+          allowComputedImportsIn: { type: "array", items: { type: "string" } }
+        },
+        required: ["web", "backend", "aliases", "backendPackages", "rpcClients"]
+      }
+    ],
+    messages: {
+      runtime: "{{source}} is not valid here: {{reason}}.",
+      computed: "Use a literal dynamic import so runtime ownership can be checked, or declare this exact file in allowComputedImportsIn after reviewing its targets."
+    }
+  },
+  createOnce(context) {
+    let options;
+    let file = "";
+    let serverFile = false;
+    let rscFile = false;
+    let shared = false;
+    const runtimeIdentifiers = new Set;
+    const imports = new Map;
+    const boundaries = [];
+    function imported(node) {
+      const entry = imports.get(node.name);
+      if (!entry)
+        return;
+      let scope = context.sourceCode.getScope(node);
+      while (scope) {
+        const variable = scope.set.get(node.name);
+        if (variable)
+          return variable.defs.some((definition) => definition.name.range[0] === entry.node.start) ? entry.name : undefined;
+        scope = scope.upper;
+      }
+      return;
+    }
+    function factory(node) {
+      if (node.type === "Identifier")
+        return imported(node);
+      if (node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
+        if (node.object.type === "Identifier" && imported(node.object) === "*")
+          return node.property.name;
+        if (["handler", "server", "client", "middleware", "validator", "inputValidator"].includes(node.property.name))
+          return factory(node.object);
+      }
+      if (node.type === "CallExpression")
+        return factory(node.callee);
+      return;
+    }
+    function boundary(position) {
+      return boundaries.filter((entry) => position >= entry.start && position < entry.end).sort((a, b) => b.start - a.start)[0];
+    }
+    function serverPosition(position, staticImport = false) {
+      const entry = boundary(position);
+      if (entry)
+        return entry.side === "server" && (!staticImport || entry.kind !== "createIsomorphicFn" || options.rpcClients.includes(file));
+      return serverFile;
+    }
+    function report(node, source, reason) {
+      context.report({ node, messageId: "runtime", data: { source, reason } });
+    }
+    function check(node, source, typeOnly, reExport = false, renderer) {
+      if (typeOnly)
+        return;
+      const target = boundaryResolveTarget(options, file, source);
+      const matches = (values) => values?.some((value) => source === value || source.startsWith(value + "/"));
+      const backend = options.backend.some((path) => target.startsWith(path + "/")) || options.backendPackages.some((name) => source === name || source.startsWith(name + "/") && /\/(?:server|rpc)(?:\/|$)/.test(source.slice(name.length)));
+      const server = Boolean(renderer) || builtinModules.includes(source) || source === "@orpc/server" || backend || /\.server(?:\.[cm]?[jt]sx?)?$/.test(target) || /^(?:node:|bun(?::|$)|cloudflare:)/.test(source) || /^@tanstack\/(?:react|solid|vue)-start\/(?:server|server-only)(?:\/|$)/.test(source) || /^react-dom\/server(?:\.|\/|$)/.test(source) || matches(options.serverImports);
+      const client = /(?:\/hooks\/|\.client-only(?:\.|$))/.test(target) || /^(?:react-dom\/client|@tanstack\/(?:react|solid|vue)-start\/client-only)(?:\/|$)/.test(source) || matches(options.clientImports);
+      if (client && (serverFile || rscFile || shared) && boundary(node.start)?.side !== "client") {
+        const references = node.type === "ImportDeclaration" ? context.sourceCode.getDeclaredVariables(node).flatMap((variable) => variable.references.filter((reference) => runtimeIdentifiers.has(reference.identifier.range[0]))) : [];
+        if (!shared && references.length && references.every((reference) => boundary(reference.identifier.range[0])?.side === "client"))
+          return;
+        report(node, source, "browser-only dependencies do not belong in server/RSC or shared modules");
+        return;
+      }
+      if (!server)
+        return;
+      if (shared) {
+        report(node, source, "shared utilities/constants/lib cannot import runtime server dependencies");
+        return;
+      }
+      if (reExport && !serverFile) {
+        report(node, source, "server dependencies must not be re-exported as a public runtime API");
+        return;
+      }
+      if (node.type === "ImportDeclaration") {
+        if (serverFile)
+          return;
+        const references = context.sourceCode.getDeclaredVariables(node).filter((variable) => !renderer || variable.name === renderer.local.name).flatMap((variable) => variable.references.filter((reference) => runtimeIdentifiers.has(reference.identifier.range[0])));
+        if (references.length && references.every((reference) => serverPosition(reference.identifier.range[0], true)))
+          return;
+      } else if (serverPosition(node.start))
+        return;
+      report(node, source, "use an inline imported TanStack server boundary; static isomorphic server imports belong only to the configured RPC owner");
+    }
+    function global(node) {
+      const serverNames = ["process", "Bun", "Deno", "Buffer", "__dirname", "__filename", "require"];
+      const browserNames = [
+        "window",
+        "document",
+        "navigator",
+        "localStorage",
+        "sessionStorage",
+        "location",
+        "history",
+        "screen",
+        "HTMLElement",
+        "Element",
+        "HTMLInputElement",
+        "ResizeObserver",
+        "MutationObserver",
+        "IntersectionObserver",
+        "FileReader",
+        "matchMedia",
+        "getComputedStyle",
+        "requestAnimationFrame",
+        "cancelAnimationFrame",
+        "alert",
+        "confirm",
+        "prompt"
+      ];
+      const member = node.parent.type === "MemberExpression" && node.parent.object === node && node.name === "globalThis" ? node.parent : undefined;
+      const name = member && !member.computed && member.property.type === "Identifier" ? member.property.name : member?.computed && member.property.type === "Literal" && typeof member.property.value === "string" ? member.property.value : node.name;
+      if (!serverNames.includes(name) && !browserNames.includes(name))
+        return;
+      let scope = context.sourceCode.getScope(node);
+      while (scope) {
+        const variable = scope.set.get(node.name);
+        if (variable?.defs.length)
+          return;
+        scope = scope.upper;
+      }
+      const references = context.sourceCode.getScope(node).references;
+      if (!references.some((reference) => reference.identifier.range[0] === node.start && runtimeIdentifiers.has(reference.identifier.range[0])))
+        return;
+      if (serverNames.includes(name) && (shared || !serverPosition(node.start)))
+        report(node, name, "server globals require a server execution boundary");
+      if (browserNames.includes(name) && (serverFile || rscFile) && boundary(node.start)?.side !== "client")
+        report(node, name, "browser globals are unavailable during server execution");
+    }
+    return {
+      Program(program) {
+        options = optionsFirst(context);
+        file = context.filename.replaceAll("\\", "/");
+        serverFile = /\.server\.[cm]?[jt]sx?$/.test(file);
+        rscFile = /\.rsc\.[cm]?[jt]sx?$/.test(file);
+        shared = /\.(?:utils|constants)\.[cm]?[jt]sx?$/.test(file) || options.web.some((path) => file.startsWith(path + "/lib/"));
+        runtimeIdentifiers.clear();
+        imports.clear();
+        boundaries.length = 0;
+        for (const statement of program.body) {
+          if (statement.type !== "ImportDeclaration" || statement.importKind === "type")
+            continue;
+          if (/^(?:react|@tanstack\/react-(?:query|router))$/.test(statement.source.value)) {
+            for (const specifier of statement.specifiers) {
+              if (specifier.type === "ImportNamespaceSpecifier" || specifier.type === "ImportDefaultSpecifier")
+                imports.set(specifier.local.name, { node: specifier.local, name: "client-hooks" });
+            }
+          }
+          if (["@tanstack/react-start/rsc", "@tanstack/react-start-rsc"].includes(statement.source.value)) {
+            for (const specifier of statement.specifiers) {
+              if (specifier.type === "ImportNamespaceSpecifier")
+                imports.set(specifier.local.name, { node: specifier.local, name: "rsc-renderers" });
+            }
+          }
+          if (statement.source.value !== "@tanstack/react-start")
+            continue;
+          for (const specifier of statement.specifiers) {
+            if (specifier.type === "ImportSpecifier" && specifier.importKind !== "type")
+              imports.set(specifier.local.name, {
+                node: specifier.local,
+                name: specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value
+              });
+            if (specifier.type === "ImportNamespaceSpecifier")
+              imports.set(specifier.local.name, { node: specifier.local, name: "*" });
+          }
+        }
+        astVisit(program, [], (node, ancestors) => {
+          if (node.type === "Identifier" && !ancestors.some((ancestor) => ancestor.type.startsWith("TS") && ![
+            "TSAsExpression",
+            "TSSatisfiesExpression",
+            "TSNonNullExpression",
+            "TSInstantiationExpression"
+          ].includes(ancestor.type)))
+            runtimeIdentifiers.add(node.start);
+          if (node.type !== "CallExpression")
+            return;
+          const kind = factory(node.callee);
+          const method = node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" ? node.callee.property.name : undefined;
+          const side = kind === "createServerOnlyFn" || kind === "createServerFn" && method === "handler" || ["createIsomorphicFn", "createMiddleware"].includes(kind ?? "") && method === "server" ? "server" : kind === "createClientOnlyFn" || ["createIsomorphicFn", "createMiddleware"].includes(kind ?? "") && method === "client" ? "client" : undefined;
+          const callback = node.arguments[0];
+          if (kind && side && callback && (callback.type === "FunctionExpression" || callback.type === "ArrowFunctionExpression"))
+            boundaries.push({ start: callback.start, end: callback.end, side, kind });
+        });
+      },
+      ImportDeclaration(node) {
+        const typeOnly = node.importKind === "type" || node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
+        check(node, node.source.value, typeOnly);
+        if (!typeOnly && ["@tanstack/react-start/rsc", "@tanstack/react-start-rsc"].includes(node.source.value)) {
+          for (const specifier of node.specifiers) {
+            if (specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && ["renderServerComponent", "renderToReadableStream"].includes(specifier.imported.name))
+              check(node, node.source.value, false, false, specifier);
+          }
+        }
+        if (!typeOnly && (serverFile || rscFile) && /^(?:react|@tanstack\/react-(?:query|router))$/.test(node.source.value)) {
+          for (const specifier of node.specifiers) {
+            if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type" || specifier.imported.type !== "Identifier")
+              continue;
+            if (/^use[A-Z]/.test(specifier.imported.name) && specifier.imported.name !== "useId") {
+              const references = context.sourceCode.getDeclaredVariables(node).filter((variable) => variable.name === specifier.local.name).flatMap((variable) => variable.references.filter((reference) => runtimeIdentifiers.has(reference.identifier.range[0])));
+              if (!references.length || !references.every((reference) => boundary(reference.identifier.range[0])?.side === "client"))
+                report(specifier, specifier.imported.name, "client hooks do not belong in server/RSC services");
+            }
+          }
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source)
+          check(node, node.source.value, node.exportKind === "type" || node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.exportKind === "type"), true);
+      },
+      ExportAllDeclaration(node) {
+        check(node, node.source.value, node.exportKind === "type", true);
+      },
+      ImportExpression(node) {
+        if (node.source.type === "Literal" && typeof node.source.value === "string")
+          check(node, node.source.value, false);
+        else if (!options.allowComputedImportsIn?.includes(file))
+          context.report({ node, messageId: "computed" });
+      },
+      MemberExpression(node) {
+        const name = !node.computed && node.property.type === "Identifier" ? node.property.name : node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : undefined;
+        if (name && ["renderServerComponent", "renderToReadableStream"].includes(name) && node.object.type === "Identifier" && imported(node.object) === "rsc-renderers" && (shared || !serverPosition(node.start, true)))
+          report(node, name, "server renderers require a server execution boundary");
+        if ((serverFile || rscFile) && name && /^use[A-Z]/.test(name) && name !== "useId" && node.object.type === "Identifier" && imported(node.object) === "client-hooks" && boundary(node.start)?.side !== "client")
+          report(node, name, "client hooks do not belong in server/RSC services");
+      },
+      Identifier: global
+    };
+  }
+});
+
+// src/rules/module-policy/import-boundaries.ts
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+import { resolve as resolve2, basename as basename2 } from "node:path";
+var importBoundaries = defineRule8({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          web: { type: "array", items: { type: "string" } },
+          backend: { type: "array", items: { type: "string" } },
+          packages: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
+          fileRoles: { type: "array", items: { type: "string" } },
+          portableLib: { type: "boolean" },
+          backendPackages: { type: "array", items: { type: "string" } },
+          publicEntrypoints: { type: "array", items: { type: "string" } },
+          appPackages: { type: "array", items: { type: "string" } },
+          aliases: { type: "object", additionalProperties: { type: "string" } }
+        },
+        required: ["web", "backend", "packages", "backendPackages", "publicEntrypoints", "appPackages", "aliases"]
+      }
+    ],
+    messages: {
+      boundary: "{{source}} violates the module boundary: {{reason}}."
+    }
+  },
+  createOnce(context) {
+    function check(node, source, typeOnly, reExport = false) {
+      const options = optionsFirst(context);
+      const file = context.filename.replaceAll("\\", "/");
+      const contains = (directory, candidate) => candidate === directory || candidate.startsWith(`${directory}/`);
+      const roots = [...options.web, ...options.backend].sort((a, b) => b.length - a.length);
+      const owner = roots.find((path) => contains(path, file));
+      const web = owner && options.web.includes(owner) ? owner : undefined;
+      const target = boundaryResolveTarget(options, file, source);
+      const backendImport = options.backend.some((path) => contains(path, target)) || options.backendPackages.some((name) => source === name || source.startsWith(`${name}/`));
+      let reason;
+      if (web && backendImport && !options.publicEntrypoints.includes(source)) {
+        reason = "frontend code uses only public backend entry points";
+      }
+      if ((Array.isArray(options.packages) ? options.packages : [options.packages]).some((path) => path && contains(path, file)) && (backendImport || options.web.some((path) => contains(path, target)) || options.appPackages.some((name) => source === name || source.startsWith(`${name}/`)))) {
+        reason = "shared packages do not import app internals";
+      }
+      if (file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) && !typeOnly) {
+        reason = "service dependencies are injected rather than read from the registry";
+      }
+      if (/\.(?:types|constants)\.ts$/.test(file) && !typeOnly && /\/(?:core\/|services\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/))/.test(target)) {
+        reason = "domain types/constants use type-only imports from implementations";
+      }
+      if (file.endsWith(".client.ts") && !typeOnly && /^(react|react-dom)(\/|$)/.test(source)) {
+        reason = "client services are React-free; use hooks for React behavior";
+      }
+      if (options.fileRoles?.length) {
+        const targetOwner = roots.find((path) => contains(path, target));
+        const domain = (path, appRoot) => {
+          const relative = path.slice(appRoot.length + 1);
+          if (relative.startsWith("types/") && relative.endsWith(".types.ts"))
+            return relative.slice("types/".length).split(".")[0];
+          if (!relative.startsWith("services/"))
+            return;
+          const parts = relative.slice("services/".length).split("/");
+          return parts.length > 1 ? parts[0] : parts[0].split(".")[0].replace(/-(?:action|query|driver)$/, "");
+        };
+        const sameDomain = owner && targetOwner && owner === targetOwner && domain(file, owner) && domain(file, owner) === domain(target, targetOwner);
+        const targetStem = target.replace(/\.[cm]?[jt]sx?$/, "");
+        const concept = options.fileRoles.some((role) => targetStem.endsWith(`.${role}`));
+        const publicSurface = /\.(?:service|client|server|rsc|utils)$/.test(targetStem) && !/\/(?:[^/]+)-(?:action|query)\./.test(targetStem);
+        const privateTarget = concept || targetOwner && domain(target, targetOwner) && !publicSurface && !/\.(?:types|constants)$/.test(targetStem);
+        if (privateTarget && !sameDomain) {
+          reason = "private domain files stay in the same domain and application; use its service API or shared utilities";
+        }
+        if (privateTarget && reExport && /\.(?:service|client|server|rsc|utils)\.ts$/.test(file) && !/\/(?:[^/]+)-(?:action|query)\./.test(file)) {
+          reason = "public service and utility surfaces must not re-export private domain internals";
+        }
+      }
+      if (options.portableLib && web && contains(`${web}/lib`, file)) {
+        const portableTarget = target.startsWith("/") ? resolve2(target).replaceAll("\\", "/") : target;
+        const appService = roots.some((path) => contains(`${path}/services`, portableTarget));
+        const backendTarget = options.backend.some((path) => contains(path, portableTarget));
+        const appPackage = options.appPackages.some((name) => source === name || source.startsWith(`${name}/`));
+        const appType = roots.some((path) => contains(`${path}/types`, portableTarget));
+        const stem = basename2(file).replace(/\.[cm]?[jt]sx?$/, "").replace(/\.utils$/, "");
+        const ownType = typeOnly && !reExport && portableTarget.replace(/\.[cm]?[jt]sx?$/, "") === `${web}/types/${stem}.types`;
+        if (backendImport || backendTarget || appService || appPackage) {
+          reason = "portable frontend lib does not import application services or application APIs";
+        } else if (appType && !ownType) {
+          reason = `portable frontend lib may only type-import its own contract '${web}/types/${stem}.types.ts'; app type re-exports are forbidden`;
+        }
+      }
+      if (reason) {
+        context.report({
+          node,
+          messageId: "boundary",
+          data: { source, reason }
+        });
+      }
+    }
+    return {
+      Program(program) {
+        const exported = new Set(exportsCollect(program).filter((binding) => !binding.reExport).map((binding) => binding.localName));
+        for (const statement of program.body) {
+          if (statement.type !== "ImportDeclaration")
+            continue;
+          for (const specifier of statement.specifiers) {
+            if (exported.has(specifier.local.name))
+              check(specifier, statement.source.value, statement.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type", true);
+          }
+        }
+      },
+      ImportDeclaration(node) {
+        check(node, node.source.value, node.importKind === "type" || node.specifiers.length > 0 && node.specifiers.every((item) => item.type === "ImportSpecifier" && item.importKind === "type"));
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          check(node, node.source.value, node.exportKind === "type", true);
+        }
+      },
+      ExportAllDeclaration(node) {
+        check(node, node.source.value, node.exportKind === "type", true);
+      },
+      ImportExpression(node) {
+        if (node.source.type === "Literal" && typeof node.source.value === "string") {
+          check(node, node.source.value, false);
+        }
+      },
+      TSImportType(node) {
+        const options = optionsFirst(context);
+        const file = context.filename.replaceAll("\\", "/");
+        if (options.portableLib && options.web.some((path) => file.startsWith(`${path}/lib/`))) {
+          check(node, node.source.value, true);
+        }
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/memoization.ts
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var memoization = defineRule9({
+  meta: {
+    type: "problem",
+    schema: [],
+    messages: {
+      memo: "Use the React Compiler rather than manual memoization."
+    }
+  },
+  createOnce(context) {
+    let namespaces = new Set;
+    return {
+      before() {
+        namespaces = new Set(["React"]);
+      },
+      ImportDeclaration(node) {
+        if (node.source.value !== "react") {
+          return;
+        }
+        for (const item of node.specifiers) {
+          if (item.type === "ImportSpecifier") {
+            const name = item.imported.type === "Identifier" ? item.imported.name : item.imported.value;
+            if (["memo", "useMemo", "useCallback"].includes(name)) {
+              context.report({ node: item, messageId: "memo" });
+            }
+          } else {
+            namespaces.add(item.local.name);
+          }
+        }
+      },
+      MemberExpression(node) {
+        const name = astDottedName(node)?.split(".");
+        if (name?.length === 2 && namespaces.has(name[0]) && ["memo", "useMemo", "useCallback"].includes(name[1])) {
+          context.report({ node, messageId: "memo" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/index.ts
+var module_policy_default = eslintCompatPlugin({
+  meta: { name: "modules" },
+  rules: {
+    "dynamic-classes": syntaxRule(':matches(JSXAttribute[name.name="className"] TemplateLiteral[expressions.length>0], JSXAttribute[name.name="className"] BinaryExpression[operator="+"])', "Write complete class names instead of constructing them dynamically."),
+    "backend-switch": syntaxRule("SwitchStatement", "Use ts-pattern in backend application code."),
+    "concurrent-db": syntaxRule('CallExpression[callee.object.name="test"][callee.property.name="concurrent"] ObjectPattern > Property[key.name="db"]', "Obtain an isolated database fixture for concurrent tests."),
+    "domain-constants": domainConstants,
+    "double-negation": syntaxRule('UnaryExpression[operator="!"] > UnaryExpression[operator="!"]', "Use Boolean(value) or an explicit comparison."),
+    "empty-effect": syntaxRule(':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."),
+    "import-boundaries": importBoundaries,
+    "tanstack-runtime": tanstackRuntime,
+    "local-type-alias": syntaxRule("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."),
+    "no-unknown": syntaxRule("TSUnknownKeyword", "Use an owned domain type rather than unknown."),
+    memoization,
+    "pascal-interface": syntaxRule("TSInterfaceDeclaration:not([id.name=/^[A-Z][a-zA-Z0-9]*$/])", "Use PascalCase for interfaces."),
+    "reasoned-directives": directives,
+    "rpc-database": syntaxRule("CallExpression[callee.property.name=/^(selectFrom|insertInto|updateTable|deleteFrom|mergeInto|executeQuery)$/]", "RPC handlers delegate database work to services."),
+    "service-functions": serviceFunctions,
+    "service-types": serviceTypes,
+    "shape-suffix": syntaxRule(":matches(VariableDeclarator, FunctionDeclaration, ClassDeclaration, TSInterfaceDeclaration, TSTypeAliasDeclaration)[id.name=/Shape$/]", "Name this declaration for its domain role rather than the Shape suffix."),
+    "test-modifiers": testModifiers
+  }
+});
+export {
+  module_policy_default as default
+};