oxlint-plugin-arch 0.2.1 → 0.2.2

package/dist/index.js

@@ -0,0 +1,1984 @@
+// src/index.ts
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+// src/rules/export-file-prefix.ts
+import { defineRule } from "@oxlint/plugins";
+
+// src/utils/helpers/ast.ts
+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);
+  for (const [key, value] of Object.entries(node)) {
+    if (!["parent", "type", "start", "end", "range", "loc"].includes(key)) {
+      astVisit(value, [...ancestors, node], callback);
+    }
+  }
+}
+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 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/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((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.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);
+}
+function declarationsCollectNamed(root) {
+  const result = [];
+  astVisit(root, [], (node, ancestors) => {
+    if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSTypeAliasDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSEnumDeclaration") && node.id?.name) {
+      result.push({ name: node.id.name, node });
+      return;
+    }
+    if (node.type === "VariableDeclarator" && node.id.type === "Identifier" && !ancestors.some((ancestor) => ancestor.type === "ForStatement" || ancestor.type === "ForInStatement" || ancestor.type === "ForOfStatement")) {
+      result.push({ name: node.id.name, node });
+    }
+  });
+  return result;
+}
+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 [];
+  });
+}
+// 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;
+}
+
+// src/utils/helpers/factories.ts
+function factoriesExpandTemplate(template, groups) {
+  return template.replaceAll(/\{([^}]+)\}/g, (placeholder, key) => {
+    const group = groups[key.toLowerCase()];
+    if (!group) {
+      return placeholder;
+    }
+    return /^[A-Z]/.test(key) ? namingPascalCase(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/options.ts
+function optionsFirst(context, fallback) {
+  return context.options[0] ?? fallback;
+}
+// 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/rules/export-file-prefix.ts
+var exportFilePrefix = defineRule({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        stem: { type: "string", enum: ["before-first-dot", "full-basename"] },
+        normalize: { type: "string", enum: ["remove-separators", "none"] },
+        allDeclarations: { type: "boolean" },
+        allowPattern: { type: "string" }
+      }
+    }],
+    messages: {
+      prefix: "'{{name}}' must start with file prefix '{{prefix}}'."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const options2 = optionsFirst(context, {
+          stem: "before-first-dot",
+          normalize: "remove-separators"
+        });
+        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
+        const stem = options2.stem === "full-basename" ? basename : basename.split(".")[0] ?? "";
+        const prefix = options2.normalize === "none" ? stem : stem.replaceAll(/[-_]/g, "").toLowerCase();
+        const allowed = options2.allowPattern ? new RegExp(options2.allowPattern) : null;
+        const names = options2.allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).map((binding) => ({
+          name: binding.localName ?? binding.exportedName,
+          node: binding.node
+        }));
+        const seen = new Set;
+        for (const item of names) {
+          const key = `${item.name}:${item.node.start}:${item.node.end}`;
+          const comparableName = options2.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
+          if (seen.has(key) || allowed?.test(item.name) || comparableName.startsWith(prefix)) {
+            continue;
+          }
+          seen.add(key);
+          context.report({
+            node: item.node,
+            messageId: "prefix",
+            data: { name: item.name, prefix }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/export-name-pattern.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+var exportNamePattern = defineRule2({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        pattern: { type: "string" },
+        flags: { type: "string" },
+        ignoreTypeExports: { type: "boolean" },
+        allDeclarations: { type: "boolean" },
+        allowPattern: { type: "string" }
+      },
+      required: ["pattern"]
+    }],
+    messages: {
+      pattern: "'{{name}}' must match {{pattern}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const {
+          pattern,
+          flags,
+          ignoreTypeExports = false,
+          allDeclarations = false,
+          allowPattern
+        } = optionsFirst(context);
+        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const names = allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).flatMap((binding) => ignoreTypeExports && binding.typeOnly ? [] : [{ name: binding.localName ?? binding.exportedName, node: binding.node }]);
+        const seen = new Set;
+        for (const item of names) {
+          const key = `${item.name}:${item.node.start}:${item.node.end}`;
+          if (seen.has(key) || allowed?.test(item.name) || new RegExp(pattern, flags).test(item.name)) {
+            continue;
+          }
+          seen.add(key);
+          context.report({
+            node: item.node,
+            messageId: "pattern",
+            data: { name: item.name, pattern }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/filename-export-name.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var filenameExportName = defineRule3({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        file: { type: "string" },
+        export: { type: "string" },
+        mode: { type: "string", enum: ["all", "some"] },
+        placeholderPattern: { type: "string" },
+        allDeclarations: { type: "boolean" }
+      },
+      required: ["file", "export"]
+    }],
+    messages: {
+      mismatch: "Function '{{actual}}' must match '{{expected}}'."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const {
+          file,
+          export: exportTemplate,
+          mode = "all",
+          placeholderPattern,
+          allDeclarations = false
+        } = optionsFirst(context);
+        const groups = namingMatchTemplate(namingFileBasename(context.filename), file, placeholderPattern);
+        if (!groups) {
+          return;
+        }
+        const expected = factoriesExpandTemplate(exportTemplate, groups);
+        const functions = allDeclarations ? declarationsCollectFunctions(program) : exportsCollectFunctions(program);
+        if (mode === "some") {
+          if (!functions.some((item) => item.name === expected)) {
+            const first = functions.at(0);
+            context.report({
+              node: first?.node ?? program,
+              messageId: "mismatch",
+              data: { actual: first?.name ?? "<none>", expected }
+            });
+          }
+          return;
+        }
+        for (const item of functions) {
+          if (item.name !== expected) {
+            context.report({
+              node: item.node,
+              messageId: "mismatch",
+              data: { actual: item.name, expected }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/filename-match.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+var filenameMatch = defineRule4({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        pattern: { type: "string" },
+        message: { type: "string" },
+        flags: { type: "string" }
+      },
+      required: ["pattern", "message"]
+    }],
+    messages: {
+      mismatch: "{{message}}"
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { pattern, message, flags } = optionsFirst(context);
+        if (!new RegExp(pattern, flags).test(namingFileBasename(context.filename))) {
+          context.report({
+            node: program,
+            messageId: "mismatch",
+            data: { message }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/folder-prefix.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var folderPrefix = defineRule5({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        singularize: { type: "string", enum: ["none", "trailing-s"] },
+        separators: { type: "array", items: { type: "string" } },
+        after: { type: "string" }
+      }
+    }],
+    messages: {
+      prefix: "File '{{file}}' must start with folder name '{{folder}}' or an allowed singular form."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const {
+          singularize = "trailing-s",
+          separators = ["-"],
+          after
+        } = optionsFirst(context, {});
+        const filename = namingPosixPath(context.filename);
+        const folders = after ? namingSegmentsAfter(filename, after) : [namingDirSegments(filename).at(-1) ?? ""];
+        if (!folders) {
+          return;
+        }
+        const resolved = folders.length > 0 ? folders : [namingDirSegments(filename).at(-1) ?? ""];
+        const separator = separators[0] ?? "-";
+        const prefixes = namingFolderPrefixes(resolved, separator, singularize);
+        const file = namingFileBasename(filename);
+        const stem = file.replace(/\.(tsx?|jsx?)$/, "");
+        const valid = prefixes.some((prefix) => stem === prefix || separators.some((item) => stem.startsWith(`${prefix}${item}`)));
+        if (!valid) {
+          context.report({
+            node: program,
+            messageId: "prefix",
+            data: { file, folder: prefixes[0] ?? "" }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-extra-exports.ts
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var noExtraExports = defineRule6({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        names: { type: "array", items: { type: "string" } },
+        domainStem: { type: "string", enum: ["before-first-dot", "full-basename"] },
+        allowTypeExports: { type: "boolean" }
+      },
+      required: ["names"]
+    }],
+    messages: {
+      extraExport: "Export '{{name}}' is not allowed; expected one of: {{allowed}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const options2 = optionsFirst(context);
+        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
+        const domain = options2.domainStem === "full-basename" ? basename : basename.split(".")[0] ?? "";
+        const allowed = options2.names.map((template) => template.replaceAll("{Domain}", namingPascalCase(domain)).replaceAll("{domain}", namingCamelCase(domain)));
+        for (const binding of exportsCollect(program)) {
+          if (options2.allowTypeExports && binding.typeOnly) {
+            continue;
+          }
+          const name = binding.localName ?? binding.exportedName;
+          if (!allowed.includes(name)) {
+            context.report({
+              node: binding.node,
+              messageId: "extraExport",
+              data: { name, allowed: allowed.join(", ") }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-extra-factory-keys.ts
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var noExtraFactoryKeys = defineRule7({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        keys: { type: "array", items: { type: "string" } },
+        factoryPattern: { type: "string" }
+      },
+      required: ["keys"]
+    }],
+    messages: {
+      extraKey: "Factory '{{factory}}' must not return key '{{key}}'; allowed keys: {{allowed}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { keys, factoryPattern = "^make[A-Z]" } = optionsFirst(context);
+        for (const factory of factoriesCollectTopLevel(program, new RegExp(factoryPattern))) {
+          for (const object of factoriesDirectlyReturnedObjects(factory)) {
+            for (const property of object.properties) {
+              const key = factoriesObjectPropertyName(property);
+              if (!key || !keys.includes(key)) {
+                context.report({
+                  node: property,
+                  messageId: "extraKey",
+                  data: { factory: factory.name, key: key ?? "<computed or spread>", allowed: keys.join(", ") }
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-file-level-helpers.ts
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var noFileLevelHelpers = defineRule8({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allowPattern: { type: "string" },
+        detectComponents: { type: "boolean" },
+        hookPattern: { type: "string" }
+      }
+    }],
+    messages: {
+      helper: "File-level helper {{name}} must move inside its owning component or hook."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const {
+          allowPattern,
+          detectComponents = true,
+          hookPattern = "^use[A-Z]"
+        } = optionsFirst(context, {});
+        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const hooks = new RegExp(hookPattern);
+        for (const candidate of declarationsFileLevelFunctionCandidates(program)) {
+          if (detectComponents && reactComponentsIsLike(program, candidate) || hooks.test(candidate.name) || allowed?.test(candidate.name)) {
+            continue;
+          }
+          context.report({
+            node: candidate.node,
+            messageId: "helper",
+            data: { name: candidate.name }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-imported-type-alias.ts
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+function importedAliasTarget(declaration, imports) {
+  if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeAnnotation.type !== "TSTypeReference" || declaration.typeAnnotation.typeName.type !== "Identifier" || !imports.has(declaration.typeAnnotation.typeName.name)) {
+    return;
+  }
+  return declaration.typeAnnotation.typeName.name;
+}
+function specifierLocalName(specifier) {
+  return specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
+}
+var noImportedTypeAlias = defineRule9({
+  meta: {
+    type: "problem",
+    schema: [],
+    messages: {
+      alias: "Exported type '{{alias}}' must not re-alias imported type '{{name}}'."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const imports = new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" ? statement.specifiers.map((specifier) => specifier.local.name) : []));
+        const aliases = new Map;
+        for (const statement of program.body) {
+          const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+          const imported = declaration && declaration.type.endsWith("Declaration") ? importedAliasTarget(declaration, imports) : undefined;
+          if (declaration?.type === "TSTypeAliasDeclaration" && imported) {
+            aliases.set(declaration.id.name, imported);
+          }
+        }
+        for (const statement of program.body) {
+          if (statement.type !== "ExportNamedDeclaration") {
+            continue;
+          }
+          const inline = importedAliasTarget(statement.declaration, imports);
+          if (inline && statement.declaration?.type === "TSTypeAliasDeclaration") {
+            context.report({
+              node: statement.declaration,
+              messageId: "alias",
+              data: { alias: statement.declaration.id.name, name: inline }
+            });
+          }
+          for (const specifier of statement.specifiers) {
+            const local = specifierLocalName(specifier);
+            const imported = aliases.get(local);
+            if (imported) {
+              context.report({
+                node: specifier,
+                messageId: "alias",
+                data: { alias: local, name: imported }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-inline-schema-elements.ts
+import { defineRule as defineRule10 } from "@oxlint/plugins";
+var noInlineSchemaElements = defineRule10({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        namespaces: { type: "array", items: { type: "string" } },
+        methods: { type: "array", items: { type: "string" } },
+        structuralMethods: { type: "array", items: { type: "string" } },
+        allowZodScalars: { type: "boolean" }
+      }
+    }],
+    defaultOptions: [{
+      namespaces: ["z"],
+      methods: ["array", "union", "record", "tuple"],
+      structuralMethods: ["array", "discriminatedUnion", "intersection", "lazy", "object", "record", "tuple", "union"],
+      allowZodScalars: true
+    }],
+    messages: { inline: "z.{{method}}() elements must use named schemas." }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") {
+          return;
+        }
+        const options2 = optionsFirst(context);
+        const namespaces = new Set(options2.namespaces);
+        const method = astStaticMemberName(node.callee);
+        if (!schemasIsCall(node, namespaces) || !method || !options2.methods.includes(method)) {
+          return;
+        }
+        for (const element of schemasElements(node)) {
+          if (!schemasIsAllowedElement(element, options2.allowZodScalars, namespaces, new Set(options2.structuralMethods))) {
+            context.report({
+              node: element,
+              messageId: "inline",
+              data: { method }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-local-schema-construction.ts
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var defaultRuntimeImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
+var defaultConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
+function formatMessage(template, data) {
+  return Object.entries(data).reduce((result, [key, value]) => result.replaceAll(`{{${key}}}`, value), template);
+}
+var noLocalSchemaConstruction = defineRule11({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        packages: { type: "array", items: { type: "string" } },
+        namespaces: { type: "array", items: { type: "string" } },
+        allowIn: { type: "array", items: { type: "string" } },
+        allowPathPatterns: { type: "array", items: { type: "string" } },
+        message: { type: "string" },
+        runtimeImportMessage: { type: "string" },
+        constructionMessage: { type: "string" }
+      }
+    }],
+    defaultOptions: [{
+      packages: ["zod"],
+      namespaces: ["z"]
+    }],
+    messages: {
+      runtimeImport: "{{message}}",
+      construction: "{{message}}"
+    }
+  },
+  createOnce(context) {
+    let constructors = new Set;
+    return {
+      before() {
+        const {
+          namespaces = ["z"],
+          allowIn = [],
+          allowPathPatterns = []
+        } = optionsFirst(context, {});
+        const filename = namingPosixPath(context.filename);
+        constructors = new Set(namespaces);
+        if (allowIn.some((suffix) => filename.endsWith(suffix)) || allowPathPatterns.some((pattern) => new RegExp(pattern).test(filename))) {
+          return false;
+        }
+      },
+      ImportDeclaration(node) {
+        const {
+          packages = ["zod"],
+          message,
+          runtimeImportMessage
+        } = optionsFirst(context, {});
+        if (!schemasIsRuntimeImport(node, new Set(packages))) {
+          return;
+        }
+        for (const name of schemasRuntimeImportLocals(node)) {
+          constructors.add(name);
+        }
+        context.report({
+          node,
+          messageId: "runtimeImport",
+          data: {
+            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, { source: node.source.value })
+          }
+        });
+      },
+      ExportNamedDeclaration(node) {
+        const {
+          packages = ["zod"],
+          message,
+          runtimeImportMessage
+        } = optionsFirst(context, {});
+        if (!schemasIsRuntimeReexport(node, new Set(packages)) || !node.source) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "runtimeImport",
+          data: {
+            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, { source: node.source.value })
+          }
+        });
+      },
+      ExportAllDeclaration(node) {
+        const {
+          packages = ["zod"],
+          message,
+          runtimeImportMessage
+        } = optionsFirst(context, {});
+        if (!schemasIsRuntimeReexport(node, new Set(packages))) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "runtimeImport",
+          data: {
+            message: formatMessage(runtimeImportMessage ?? message ?? defaultRuntimeImportMessage, { source: node.source.value })
+          }
+        });
+      },
+      CallExpression(node) {
+        if (!schemasIsConstruction(node, constructors)) {
+          return;
+        }
+        const { message, constructionMessage } = optionsFirst(context, {});
+        context.report({
+          node,
+          messageId: "construction",
+          data: {
+            message: formatMessage(constructionMessage ?? message ?? defaultConstructionMessage, {})
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-rederive-schema.ts
+import { defineRule as defineRule12 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule12({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        from: { type: "array", items: { type: "string" } },
+        namespaces: { type: "array", items: { type: "string" } },
+        operators: { type: "array", items: { type: "string" } }
+      },
+      required: ["from"]
+    }],
+    messages: {
+      rederive: "Do not derive {{operator}} from imported schema {{schema}}; import its DTO type."
+    }
+  },
+  createOnce(context) {
+    let imported = new Set;
+    return {
+      Program(program) {
+        const { from } = optionsFirst(context);
+        imported = new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" && from.includes(statement.source.value) ? statement.specifiers.map((specifier) => specifier.local.name) : []));
+      },
+      TSTypeReference(node) {
+        const {
+          namespaces = ["z"],
+          operators = ["infer", "input"]
+        } = optionsFirst(context);
+        const operator = schemasTypeOperator(node, new Set(namespaces), new Set(operators));
+        const parameter = node.typeArguments?.params[0];
+        if (!operator || parameter?.type !== "TSTypeQuery" || parameter.exprName.type !== "Identifier" || !imported.has(parameter.exprName.name)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "rederive",
+          data: { operator, schema: parameter.exprName.name }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-restricted-files.ts
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule13({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        message: { type: "string" }
+      },
+      required: ["message"]
+    }],
+    messages: {
+      restricted: "{{message}}"
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { message } = optionsFirst(context);
+        context.report({
+          node: program,
+          messageId: "restricted",
+          data: { message }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-restricted-token.ts
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+function tokenIsTypeOnlyImport(node) {
+  const parent = node.parent;
+  if (parent?.type === "ImportSpecifier") {
+    return parent.importKind === "type" || parent.parent.type === "ImportDeclaration" && parent.parent.importKind === "type";
+  }
+  return (parent?.type === "ImportDefaultSpecifier" || parent?.type === "ImportNamespaceSpecifier") && parent.parent.type === "ImportDeclaration" && parent.parent.importKind === "type";
+}
+var noRestrictedToken = defineRule14({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        token: { type: "string" },
+        allowIn: { type: "array", items: { type: "string" } },
+        allowPathPatterns: { type: "array", items: { type: "string" } }
+      },
+      required: ["token", "allowIn"]
+    }],
+    messages: {
+      restricted: "'{{token}}' may only appear in configured owner paths."
+    }
+  },
+  createOnce(context) {
+    return {
+      before() {
+        const options2 = optionsFirst(context);
+        const filename = namingPosixPath(context.filename);
+        const allowed = options2.allowIn.some((suffix) => filename.endsWith(suffix)) || (options2.allowPathPatterns ?? []).some((pattern) => new RegExp(pattern).test(filename));
+        if (allowed) {
+          return false;
+        }
+      },
+      Identifier(node) {
+        const { token } = optionsFirst(context);
+        if (node.name === token && !tokenIsTypeOnlyImport(node)) {
+          context.report({
+            node,
+            messageId: "restricted",
+            data: { token }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-runtime-in-types.ts
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var noRuntimeInTypes = defineRule15({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allow: {
+          type: "array",
+          items: { type: "string", enum: ["class", "default", "enum", "function", "variable"] }
+        }
+      }
+    }],
+    messages: {
+      runtimeValue: "Types files must not contain runtime value {{name}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { allow = [] } = optionsFirst(context, {});
+        for (const statement of program.body) {
+          const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+          if (!declaration) {
+            continue;
+          }
+          if (declarationsIsRuntime(declaration)) {
+            if (!declaration.declare && !allow.includes(declarationsRuntimeKind(declaration))) {
+              context.report({
+                node: declaration,
+                messageId: "runtimeValue",
+                data: { name: declarationsRuntimeName(declaration) }
+              });
+            }
+            continue;
+          }
+          if (!allow.includes("default") && statement.type === "ExportDefaultDeclaration" && declaration.type !== "TSInterfaceDeclaration" && declaration.type !== "TSTypeAliasDeclaration") {
+            context.report({
+              node: statement,
+              messageId: "runtimeValue",
+              data: { name: "default" }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-single-use-scalar-schema.ts
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+function isScalarSchema(node, namespaces, structuralMethods) {
+  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
+    return false;
+  }
+  if (schemasIsCall(node, namespaces)) {
+    const method = astStaticMemberName(node.callee);
+    return Boolean(method && !structuralMethods.has(method));
+  }
+  const modifier = astStaticMemberName(node.callee);
+  return Boolean(modifier && !structuralMethods.has(modifier) && node.callee.object.type === "CallExpression" && isScalarSchema(node.callee.object, namespaces, structuralMethods));
+}
+function isDirectObjectField(identifier, ancestors, namespaces, structuralMethods) {
+  const property = ancestors.at(-1);
+  const object = ancestors.at(-2);
+  const call = ancestors.at(-3);
+  if (property?.type !== "Property" || property.value !== identifier || object?.type !== "ObjectExpression" || call?.type !== "CallExpression" || !schemasIsCall(call, namespaces)) {
+    return false;
+  }
+  const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
+  return Boolean(method === "object" && structuralMethods.has(method) && call.arguments.includes(object));
+}
+function isAllowedStructuralElement(identifier, initializer, ancestors, options2, namespaces, structuralMethods) {
+  if (!options2.allowZodScalars || !schemasIsAllowedElement(initializer, true, namespaces, structuralMethods)) {
+    return false;
+  }
+  const parent = ancestors.at(-1);
+  const call = parent?.type === "ArrayExpression" ? ancestors.at(-2) : parent;
+  if (call?.type !== "CallExpression" || !schemasIsCall(call, namespaces)) {
+    return false;
+  }
+  const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
+  return Boolean(method && options2.methods.includes(method) && schemasElements(call).includes(identifier));
+}
+var noSingleUseScalarSchema = defineRule16({
+  meta: {
+    type: "suggestion",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        namespaces: { type: "array", items: { type: "string" } },
+        methods: { type: "array", items: { type: "string" } },
+        structuralMethods: { type: "array", items: { type: "string" } },
+        allowZodScalars: { type: "boolean" }
+      }
+    }],
+    defaultOptions: [{
+      namespaces: ["z"],
+      methods: ["array", "union", "record", "tuple"],
+      structuralMethods: ["and", "array", "discriminatedUnion", "intersection", "lazy", "object", "or", "pipe", "record", "transform", "tuple", "union"],
+      allowZodScalars: true
+    }],
+    messages: { inline: "Inline single-use scalar schema {{name}} at its only structural use." }
+  },
+  create(context) {
+    const candidates = [];
+    return {
+      VariableDeclaration(node) {
+        if (node.kind !== "const") {
+          return;
+        }
+        for (const declarator of node.declarations) {
+          if (declarator.id.type === "Identifier" && declarator.init) {
+            candidates.push(declarator);
+          }
+        }
+      },
+      "Program:exit"(program) {
+        const options2 = optionsFirst(context);
+        const namespaces = new Set(options2.namespaces);
+        const structuralMethods = new Set(options2.structuralMethods);
+        const exportedNames = new Set(exportsCollect(program).flatMap((binding) => binding.localName ? [binding.localName] : []));
+        for (const declarator of candidates) {
+          const name = declarator.id.type === "Identifier" ? declarator.id.name : undefined;
+          const initializer = declarator.init;
+          if (!name || !initializer || exportedNames.has(name) || !isScalarSchema(initializer, namespaces, structuralMethods)) {
+            continue;
+          }
+          const variable = context.sourceCode.getDeclaredVariables(declarator).find((candidate) => candidate.name === name);
+          const references = variable?.references.filter((reference2) => reference2.isRead()) ?? [];
+          if (references.length !== 1) {
+            continue;
+          }
+          const reference = references[0];
+          const identifier = reference.identifier;
+          const ancestors = context.sourceCode.getAncestors(identifier);
+          const inlineable = isDirectObjectField(identifier, ancestors, namespaces, structuralMethods) || isAllowedStructuralElement(identifier, initializer, ancestors, options2, namespaces, structuralMethods);
+          if (inlineable) {
+            context.report({
+              node: declarator.id,
+              messageId: "inline",
+              data: { name }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-top-level-functions.ts
+import { defineRule as defineRule17 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule17({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        banReExports: { type: "boolean" },
+        allowPattern: { type: "string" }
+      }
+    }],
+    defaultOptions: [{ banReExports: true }],
+    messages: {
+      noFunction: "Files in this scope must not contain top-level function {{name}}.",
+      noReExport: "Files in this scope must not re-export values."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { banReExports, allowPattern } = optionsFirst(context);
+        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        for (const statement of program.body) {
+          if (banReExports && (statement.type === "ExportAllDeclaration" || statement.type === "ExportNamedDeclaration" && statement.source)) {
+            context.report({ node: statement, messageId: "noReExport" });
+            continue;
+          }
+          const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+          if (declaration?.type === "FunctionDeclaration") {
+            if (!allowed?.test(declarationsFunctionName(declaration))) {
+              context.report({
+                node: declaration,
+                messageId: "noFunction",
+                data: { name: declarationsFunctionName(declaration) }
+              });
+            }
+            continue;
+          }
+          if (declaration?.type !== "VariableDeclaration") {
+            continue;
+          }
+          for (const item of declaration.declarations) {
+            if ((item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression") && !allowed?.test(declarationsFunctionName(item))) {
+              context.report({
+                node: item,
+                messageId: "noFunction",
+                data: { name: declarationsFunctionName(item) }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-trivial-functions.ts
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var noTrivialFunctions = defineRule18({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allowPattern: { type: "string" }
+      }
+    }],
+    messages: {
+      trivial: "Function {{name}} does nothing useful; inline it at the call site."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { allowPattern } = optionsFirst(context, {});
+        const allowed = allowPattern ? new RegExp(allowPattern) : null;
+        const seen = new Set;
+        for (const item of [...exportsCollectFunctions(program), ...declarationsTopLevelUnexportedFunctions(program)]) {
+          const key = `${item.name}:${item.node.start}:${item.node.end}`;
+          if (seen.has(key) || allowed?.test(item.name) || !declarationsIsTrivialFunction(item.node)) {
+            continue;
+          }
+          seen.add(key);
+          context.report({
+            node: item.node,
+            messageId: "trivial",
+            data: { name: item.name }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-unescaped-like.ts
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule19({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        methods: { type: "array", items: { type: "string" } },
+        sanitizers: { type: "array", items: { type: "string" } },
+        allowSanitizedBindings: { type: "boolean" }
+      },
+      required: ["methods", "sanitizers"]
+    }],
+    messages: { unescaped: ".{{method}}() values must use a configured sanitizer." }
+  },
+  createOnce(context) {
+    let sanitized = new Set;
+    return {
+      Program(program) {
+        const { sanitizers: sanitizers2, allowSanitizedBindings = true } = optionsFirst(context);
+        sanitized = allowSanitizedBindings ? sanitizersConfiguredBindings(program, new Set(sanitizers2)) : new Set;
+      },
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") {
+          return;
+        }
+        const { methods, sanitizers: sanitizers2 } = optionsFirst(context);
+        const method = astStaticMemberName(node.callee);
+        if (!method || !methods.includes(method)) {
+          return;
+        }
+        const value = node.arguments.at(-1);
+        const allowedIdentifier = value?.type === "Identifier" && sanitized.has(value.name);
+        if (!sanitizersCallsConfigured(value, new Set(sanitizers2)) && !allowedIdentifier) {
+          context.report({
+            node: value ?? node,
+            messageId: "unescaped",
+            data: { method }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/only-export-components.ts
+import { defineRule as defineRule20 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule20({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        matchFileName: { type: "boolean" }
+      }
+    }],
+    messages: {
+      nonComponent: "Export '{{name}}' must be a React component or type.",
+      nameMismatch: "Component export '{{name}}' must match '{{expected}}' or its prefix."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { matchFileName = true } = optionsFirst(context, {});
+        const expected = reactComponentsPascalFromBasename(namingFileBasename(context.filename));
+        const components = [];
+        for (const candidate of reactComponentsExportCandidates(program)) {
+          if (candidate.typeOnly) {
+            continue;
+          }
+          if (!reactComponentsIsLike(program, candidate)) {
+            context.report({
+              node: candidate.node,
+              messageId: "nonComponent",
+              data: { name: candidate.name, expected }
+            });
+            continue;
+          }
+          components.push(candidate);
+        }
+        if (components.length === 0 || !matchFileName) {
+          return;
+        }
+        const expectedKey = expected.toLowerCase();
+        const exact = components.some((candidate) => candidate.name.toLowerCase() === expectedKey);
+        const allPrefixed = components.every((candidate) => candidate.name.toLowerCase().startsWith(expectedKey));
+        if (!exact && !allPrefixed) {
+          for (const candidate of components) {
+            context.report({
+              node: candidate.node,
+              messageId: "nameMismatch",
+              data: { name: candidate.name, expected }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-file-factory.ts
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var requireFileFactory = defineRule21({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        factory: { type: "string" },
+        allDeclarations: { type: "boolean" }
+      },
+      required: ["factory"]
+    }],
+    messages: {
+      factory: "Function '{{actual}}' must be named '{{expected}}'."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { factory, allDeclarations = false } = optionsFirst(context);
+        const stem = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
+        const expected = factory.replaceAll("{Stem}", namingPascalCase(stem)).replaceAll("{stem}", stem);
+        const functions = allDeclarations ? declarationsCollectFunctions(program) : exportsCollectFunctions(program);
+        if (functions.length === 0) {
+          context.report({
+            node: program,
+            messageId: "factory",
+            data: { actual: "<none>", expected }
+          });
+          return;
+        }
+        for (const item of functions) {
+          if (item.name !== expected) {
+            context.report({
+              node: item.node,
+              messageId: "factory",
+              data: { actual: item.name, expected }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-object-params.ts
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var requireObjectParams = defineRule22({
+  meta: {
+    type: "problem",
+    schema: [],
+    messages: {
+      objectParams: "Exported function {{name}} must accept at most one object parameter."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        for (const item of exportsCollectFunctions(program)) {
+          if (item.node.params.length > 1 || item.node.params.some((param) => !declarationsIsObjectParam(param))) {
+            context.report({
+              node: item.node,
+              messageId: "objectParams",
+              data: { name: item.name }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-orpc-output.ts
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule23({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        composers: { type: "array", items: { type: "string" } },
+        handlerMethod: { type: "string" },
+        outputMethod: { type: "string" }
+      },
+      required: ["composers"]
+    }],
+    messages: {
+      missing: "oRPC procedures must declare .output() before .handler().",
+      invalid: "oRPC .output() must use a named schema or configured composer with a named schema."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") {
+          return;
+        }
+        const { composers, handlerMethod = "handler", outputMethod = "output" } = optionsFirst(context);
+        if (astStaticMemberName(node.callee) !== handlerMethod) {
+          return;
+        }
+        const output = orpcFindChainCall(node.callee.object, outputMethod);
+        if (!output) {
+          context.report({ node, messageId: "missing" });
+          return;
+        }
+        if (!orpcIsNamedOrComposedArgument(output.arguments[0], new Set(composers))) {
+          context.report({ node: output, messageId: "invalid" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-paired-call.ts
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+var requirePairedCall = defineRule24({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        when: { type: "string" },
+        require: { type: "string" }
+      },
+      required: ["when", "require"]
+    }],
+    messages: {
+      paired: "{{when}} requires a call to {{require}} in the same file."
+    }
+  },
+  createOnce(context) {
+    let aliases = new Map;
+    let firstWhen = null;
+    let sawRequired = false;
+    return {
+      before() {
+        aliases = new Map;
+        firstWhen = null;
+        sawRequired = false;
+      },
+      Program(program) {
+        aliases = astImportedCallAliases(program);
+      },
+      CallExpression(node) {
+        const { when, require: require2 } = optionsFirst(context);
+        const name = astResolvedCallName(node, aliases);
+        if (name === when && !firstWhen) {
+          firstWhen = node;
+        }
+        if (name === require2) {
+          sawRequired = true;
+        }
+      },
+      after() {
+        if (!firstWhen || sawRequired) {
+          return;
+        }
+        const { when, require: require2 } = optionsFirst(context);
+        context.report({
+          node: firstWhen,
+          messageId: "paired",
+          data: { when, require: require2 }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/route-surface.ts
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+var routeSurface = defineRule25({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        exportName: { type: "string" },
+        bannedHooks: { type: "array", items: { type: "string" } },
+        banIntrinsicJsx: { type: "boolean" }
+      }
+    }],
+    defaultOptions: [{ exportName: "Route", bannedHooks: ["useState", "useEffect", "useMutation"], banIntrinsicJsx: true }],
+    messages: {
+      extraExport: "Route files may only export '{{expected}}'; found '{{actual}}'.",
+      hostJsx: "Route adapter {{name}} must not render intrinsic JSX.",
+      bannedHook: "Route adapter {{name}} must not call {{hook}}."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { exportName, bannedHooks, banIntrinsicJsx } = optionsFirst(context);
+        for (const binding of exportsCollect(program)) {
+          if (binding.exportedName !== exportName) {
+            context.report({
+              node: binding.node,
+              messageId: "extraExport",
+              data: { expected: exportName, actual: binding.exportedName }
+            });
+          }
+        }
+        const banned = new Set(bannedHooks);
+        for (const item of declarationsTopLevelUnexportedFunctions(program)) {
+          routesInspectFunction(context, item, banned, banIntrinsicJsx);
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_default = eslintCompatPlugin({
+  meta: { name: "arch" },
+  rules: {
+    "export-file-prefix": exportFilePrefix,
+    "export-name-pattern": exportNamePattern,
+    "filename-export-name": filenameExportName,
+    "filename-match": filenameMatch,
+    "folder-prefix": folderPrefix,
+    "no-extra-exports": noExtraExports,
+    "no-extra-factory-keys": noExtraFactoryKeys,
+    "no-file-level-helpers": noFileLevelHelpers,
+    "no-imported-type-alias": noImportedTypeAlias,
+    "no-inline-schema-elements": noInlineSchemaElements,
+    "no-local-schema-construction": noLocalSchemaConstruction,
+    "no-rederive-schema": noRederiveSchema,
+    "no-restricted-files": noRestrictedFiles,
+    "no-restricted-token": noRestrictedToken,
+    "no-runtime-in-types": noRuntimeInTypes,
+    "no-single-use-scalar-schema": noSingleUseScalarSchema,
+    "no-top-level-functions": noTopLevelFunctions,
+    "no-trivial-functions": noTrivialFunctions,
+    "no-unescaped-like": noUnescapedLike,
+    "only-export-components": onlyExportComponents,
+    "require-file-factory": requireFileFactory,
+    "require-object-params": requireObjectParams,
+    "require-orpc-output": requireOrpcOutput,
+    "require-paired-call": requirePairedCall,
+    "route-surface": routeSurface
+  }
+});
+export {
+  src_default as default
+};