oxlint-plugin-arch 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.2.5
+
+- Add `no-inline-types` to require named object and function types in function signatures, with separate parameter, return, and function-type options.
+- Add `only-export-constants` to restrict exports to local `const` bindings, with opt-ins for function values, type exports, and re-exports.
+- Add `no-member-comments` to remove comments on object/type members while preserving directives and optional `Why:` explanations.
+- Document the new rule options and syntax-only limits, extend the full configuration example to all 30 rules, and sync the optional vendored skill assets.
+
+## 0.2.4
+
+- Add `trailingRoles` and `roleSeparators` so `export-file-prefix`, `declaration-name`, and `no-extra-exports` can treat `onchain-utils.ts` like `onchain.utils.ts`.
+
 ## 0.2.3
 
 - Add `declaration-name` so selected declarations can follow a file prefix or pattern per glob.

package/README.md

@@ -41,23 +41,24 @@ Then point `jsPlugins[].specifier` at the copied entry file instead of the packa
 ## Configuration examples
 
 - [`examples/minimal.oxlint.config.ts`](examples/minimal.oxlint.config.ts) — three small rules showing plugin registration, glob ownership, and options.
-- [`examples/full.oxlint.config.ts`](examples/full.oxlint.config.ts) — all 27 rules across representative component, action, service, route, API, schema, and database scopes.
+- [`examples/full.oxlint.config.ts`](examples/full.oxlint.config.ts) — all 30 rules across representative component, action, service, constant, route, API, schema, and database scopes.
 
 Copy the shapes that match your repository; do not copy globs or naming policy blindly.
 
 ## Rules
 
-- `declaration-name` — require selected declarations to match a filename-derived prefix or a consumer pattern.
-- `export-file-prefix` — require export names, or every function and type, to start with a filename-derived prefix, optionally singularized.
+- `declaration-name` — require selected declarations to match a filename-derived prefix or a consumer pattern. Optional `trailingRoles` treat `onchain-utils.ts` like `onchain.utils.ts`.
+- `export-file-prefix` — require export names, or every function and type, to start with a filename-derived prefix, optionally singularized. Optional `trailingRoles` drop a configured role suffix from that prefix.
 - `export-name-pattern` — require export names, or every function and type, to match a configured regular expression.
 - `filename-export-name` — derive expected function names from filename templates, optionally including locals.
 - `filename-match` — require filenames to match a configured pattern.
 - `folder-prefix` — require filenames to start with their parent folder name, or the folders after a configured root.
-- `no-extra-exports` — restrict files to configured export templates.
+- `no-extra-exports` — restrict files to configured export templates. Optional `trailingRoles` apply to `{Domain}` the same way as the prefix rules.
 - `no-extra-factory-keys` — restrict direct factory return keys.
 - `no-file-level-helpers` — keep unapproved helpers out of module scope.
 - `no-imported-type-alias` — reject exported aliases that only rename imported types.
 - `no-inline-schema-elements` — require named schemas inside configured combinators.
+- `no-inline-types` — require named object and function types in parameter and return annotations. See [options and scope](#no-inline-types).
 - `no-local-schema-construction` — reject runtime schema-library imports and local schema construction, with consumer-chosen severity, messages, and path exceptions.
 - `no-rederive-schema` — reject type derivation from configured imported schemas.
 - `no-restricted-files` — reject files selected by a consumer-owned forbidden glob.
@@ -67,8 +68,10 @@ Copy the shapes that match your repository; do not copy globs or naming policy b
 - `no-top-level-functions` — reject top-level functions and optional re-exports.
 - `no-trivial-functions` — reject empty or passthrough top-level functions.
 - `no-type-declarations` — reject type aliases and interfaces in matched files.
+- `no-member-comments` — remove leading and same-line trailing comments on object-type members: interface properties and methods, index/call/construct signatures, type-literal members (including inline function parameter types), object literal properties, and object spreads. Autofix removes the comment and any blank line that followed it, consumes the spacing in front of a trailing comment so no line is left with trailing whitespace, and never removes the member. A contiguous run of comments is reported once and removed by a single fix, so `--fix` converges in one pass. `allowWhy` defaults to `true`: comments beginning with `Why: ` (after whitespace/JSDoc decoration), including contiguous `//` continuation lines, are preserved. Set `{ allowWhy: false }` to ban those too. The rule checks the prefix, not whether the rationale is meaningful. Directive comments are always preserved, whatever `allowWhy` says: `@ts-ignore`, `@ts-expect-error`, `@ts-nocheck`, `eslint-`/`oxlint-disable`/`enable`, `prettier-ignore`, `biome-ignore`, `c8`/`v8`/`istanbul ignore`, and webpack magic comments. Declaration, function-body, class-field, enum-member, union-member, and plain function-parameter comments are out of scope, as are comments inside destructuring patterns and array literals. Enable with `'arch/no-member-comments': ['error', { allowWhy: true }]` in a `**/*.{ts,tsx}` override.
 - `no-unescaped-like` — require configured sanitizers for configured query methods.
 - `only-export-components` — allow only React component and type exports.
+- `only-export-constants` — allow only local `const` exports, with opt-ins for function values, types, and re-exports. See [options and scope](#only-export-constants).
 - `require-file-factory` — derive and require a filename-based factory function.
 - `require-object-params` — require exported functions to use object-shaped parameters.
 - `require-orpc-output` — require named oRPC output schemas.
@@ -77,6 +80,62 @@ Copy the shapes that match your repository; do not copy globs or naming policy b
 
 Every rule file includes plain-English behavior and examples. Rule tests under `src/tests/` show complete option shapes.
 
+### `no-inline-types`
+
+Require named types in function signatures, including local functions, callbacks, methods, constructors, and overloads. Checks explicit annotations only; inferred types, variable annotations, generic constraints, and named type/interface definitions are not changed or banned. Use `no-type-declarations` separately to control where named types may live.
+
+| Option | Default | Behavior |
+| --- | --- | --- |
+| `parameters` | `true` | Check parameter annotations, including destructuring, defaults, rest parameters, and constructor parameter properties. |
+| `returns` | `true` | Check explicit return annotations. |
+| `functionTypes` | `true` | Also reject inline function and constructor types. When `false`, object types nested inside those annotations are still checked. |
+
+Object/function types nested in arrays, tuples, unions, intersections, or generic arguments are checked too (`Promise<{ id: string }>` fails). A rejected outer type is reported once, not again for each nested member.
+
+```ts
+// In the consumer's override for service files:
+'arch/no-inline-types': ['error', {
+  parameters: true,
+  returns: true,
+  functionTypes: true,
+}]
+
+// Pass
+function save(input: SaveInput): SaveResult { return persist(input) }
+// Fail
+function save(input: { id: string }): { ok: boolean } { return persist(input) }
+```
+
+### `only-export-constants`
+
+Require every runtime export to reference a local `const` binding. Supports direct exports, destructuring, renamed exports, and default exports of local constants. Non-exported declarations are unrestricted.
+
+| Option | Default | Behavior |
+| --- | --- | --- |
+| `allowFunctionValues` | `false` | Allow function-valued `const` bindings, not exported function declarations. |
+| `allowTypeExports` | `false` | Allow type aliases, interfaces, and type-only exports, including type-only re-exports. |
+| `allowReExports` | `false` | Allow runtime re-exports (`export ... from`, `export *`) and exports of imported bindings. Their declaration kind cannot be verified locally. |
+
+`let`, `var`, function/class/enum/namespace declarations, class-valued constants, bare default expressions, and TypeScript `export =` / `export as namespace` are rejected. Name the default value with a local `const` first. Type-only re-exports use `allowTypeExports`, independently of `allowReExports`.
+
+This is a syntax rule, not a deep-immutability or runtime-type check. It recognizes direct function/class values, TypeScript expression wrappers, and local identifier aliases. It does not infer values returned by calls, imported values, member accesses, destructuring, or object contents. Objects and arrays do not need `as const` or `Object.freeze()`.
+
+```ts
+// In the consumer's override for constant files:
+'arch/only-export-constants': ['error', {
+  allowFunctionValues: false,
+  allowTypeExports: false,
+  allowReExports: false,
+}]
+
+// Pass
+const retryLimit = 3
+export { retryLimit }
+// Fail
+export let retryCount = 0
+export const retry = () => run()
+```
+
 ## Development
 
 ```bash

package/dist/index.js

@@ -181,7 +181,7 @@ function declarationsIsTrivialFunction(node) {
   if (!node.body || node.body.type !== "BlockStatement") {
     return false;
   }
-  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
+  const statements = node.body.body.filter((statement) => statement.type !== "EmptyStatement" && !(statement.type === "ExpressionStatement" && statement.directive));
   if (statements.length === 0) {
     return true;
   }
@@ -422,9 +422,37 @@ function namingMatchTemplate(basename, template, placeholderPattern = "[a-z0-9-]
   }
   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);
@@ -699,7 +727,9 @@ var declarationName = defineRule({
         },
         pattern: { type: "string" },
         flags: { type: "string" },
-        stem: { type: "string", enum: ["before-first-dot", "full-basename"] },
+        stem: { type: "string", enum: [...namingStemModes] },
+        trailingRoles: { type: "array", items: { type: "string" } },
+        roleSeparators: { type: "array", items: { type: "string" } },
         normalize: { type: "string", enum: ["remove-separators", "none"] },
         singularize: { type: "string", enum: ["none", "trailing-s"] },
         allowPattern: { type: "string" }
@@ -713,19 +743,19 @@ var declarationName = defineRule({
   createOnce(context) {
     return {
       Program(program) {
-        const options2 = optionsFirst(context, {
+        const options = optionsFirst(context, {
           stem: "before-first-dot",
           normalize: "remove-separators"
         });
-        const allowed = options2.allowPattern ? new RegExp(options2.allowPattern) : null;
-        const expected = options2.pattern ? new RegExp(options2.pattern, options2.flags) : null;
+        const allowed = options.allowPattern ? new RegExp(options.allowPattern) : null;
+        const expected = options.pattern ? new RegExp(options.pattern, options.flags) : null;
         const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, "");
-        const stem = options2.stem === "full-basename" ? basename : basename.split(".")[0] ?? "";
-        const prefixes = namingFilePrefixes(stem, options2.normalize ?? "remove-separators", options2.singularize ?? "none");
+        const stem = namingFileStem(basename, options.stem, options.trailingRoles, options.roleSeparators);
+        const prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
         const seen = new Set;
-        for (const item of declarationsCollectNamed(program, options2.kinds)) {
+        for (const item of declarationsCollectNamed(program, options.kinds)) {
           const key = `${item.name}:${item.node.start}:${item.node.end}`;
-          const comparableName = options2.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
+          const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
           const matches = expected ? expected.test(item.name) : prefixes.some((prefix) => comparableName.startsWith(prefix));
           if (seen.has(key) || allowed?.test(item.name) || matches) {
             continue;
@@ -734,7 +764,7 @@ var declarationName = defineRule({
           context.report({
             node: item.node,
             messageId: expected ? "pattern" : "prefix",
-            data: expected ? { name: item.name, pattern: options2.pattern ?? "" } : { name: item.name, prefix: prefixes.join(" or ") }
+            data: expected ? { name: item.name, pattern: options.pattern ?? "" } : { name: item.name, prefix: prefixes.join(" or ") }
           });
         }
       }
@@ -751,7 +781,9 @@ var exportFilePrefix = defineRule2({
       type: "object",
       additionalProperties: false,
       properties: {
-        stem: { type: "string", enum: ["before-first-dot", "full-basename"] },
+        stem: { type: "string", enum: [...namingStemModes] },
+        trailingRoles: { type: "array", items: { type: "string" } },
+        roleSeparators: { type: "array", items: { type: "string" } },
         normalize: { type: "string", enum: ["remove-separators", "none"] },
         singularize: { type: "string", enum: ["none", "trailing-s"] },
         allDeclarations: { type: "boolean" },
@@ -765,22 +797,22 @@ var exportFilePrefix = defineRule2({
   createOnce(context) {
     return {
       Program(program) {
-        const options2 = optionsFirst(context, {
+        const options = 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 prefixes = namingFilePrefixes(stem, options2.normalize ?? "remove-separators", options2.singularize ?? "none");
-        const allowed = options2.allowPattern ? new RegExp(options2.allowPattern) : null;
-        const names = options2.allDeclarations ? declarationsCollectNamed(program) : exportsCollect(program).map((binding) => ({
+        const stem = namingFileStem(basename, options.stem, options.trailingRoles, options.roleSeparators);
+        const prefixes = namingFilePrefixes(stem, options.normalize ?? "remove-separators", options.singularize ?? "none");
+        const allowed = options.allowPattern ? new RegExp(options.allowPattern) : null;
+        const names = options.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();
+          const comparableName = options.normalize === "none" ? item.name : item.name.replaceAll("_", "").toLowerCase();
           if (seen.has(key) || allowed?.test(item.name) || prefixes.some((prefix) => comparableName.startsWith(prefix))) {
             continue;
           }
@@ -1003,7 +1035,9 @@ var noExtraExports = defineRule7({
       additionalProperties: false,
       properties: {
         names: { type: "array", items: { type: "string" } },
-        domainStem: { type: "string", enum: ["before-first-dot", "full-basename"] },
+        domainStem: { type: "string", enum: [...namingStemModes] },
+        trailingRoles: { type: "array", items: { type: "string" } },
+        roleSeparators: { type: "array", items: { type: "string" } },
         allowTypeExports: { type: "boolean" }
       },
       required: ["names"]
@@ -1015,12 +1049,12 @@ var noExtraExports = defineRule7({
   createOnce(context) {
     return {
       Program(program) {
-        const options2 = optionsFirst(context);
+        const options = 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)));
+        const domain = namingFileStem(basename, options.domainStem, options.trailingRoles, options.roleSeparators);
+        const allowed = options.names.map((template) => template.replaceAll("{Domain}", namingPascalCase(domain)).replaceAll("{domain}", namingCamelCase(domain)));
         for (const binding of exportsCollect(program)) {
-          if (options2.allowTypeExports && binding.typeOnly) {
+          if (options.allowTypeExports && binding.typeOnly) {
             continue;
           }
           const name = binding.localName ?? binding.exportedName;
@@ -1210,14 +1244,14 @@ var noInlineSchemaElements = defineRule11({
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const options2 = optionsFirst(context);
-        const namespaces = new Set(options2.namespaces);
+        const options = optionsFirst(context);
+        const namespaces = new Set(options.namespaces);
         const method = astStaticMemberName(node.callee);
-        if (!schemasIsCall(node, namespaces) || !method || !options2.methods.includes(method)) {
+        if (!schemasIsCall(node, namespaces) || !method || !options.methods.includes(method)) {
           return;
         }
         for (const element of schemasElements(node)) {
-          if (!schemasIsAllowedElement(element, options2.allowZodScalars, namespaces, new Set(options2.structuralMethods))) {
+          if (!schemasIsAllowedElement(element, options.allowZodScalars, namespaces, new Set(options.structuralMethods))) {
             context.report({
               node: element,
               messageId: "inline",
@@ -1230,14 +1264,76 @@ var noInlineSchemaElements = defineRule11({
   }
 });
 
-// src/rules/no-local-schema-construction.ts
+// src/rules/no-inline-types.ts
 import { defineRule as defineRule12 } from "@oxlint/plugins";
+function parameterAnnotation(parameter) {
+  if (parameter.type === "TSParameterProperty") {
+    return parameterAnnotation(parameter.parameter);
+  }
+  if (parameter.type === "AssignmentPattern") {
+    return parameterAnnotation(parameter.left);
+  }
+  return parameter.typeAnnotation;
+}
+var noInlineTypes = defineRule12({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        parameters: { type: "boolean" },
+        returns: { type: "boolean" },
+        functionTypes: { type: "boolean" }
+      }
+    }],
+    messages: {
+      inlineType: "Use a named type instead of an inline {{kind}} type in this {{position}} annotation."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { parameters = true, returns = true, functionTypes = true } = optionsFirst(context, {});
+        const isInline = (node) => node.type === "TSTypeLiteral" || functionTypes && (node.type === "TSFunctionType" || node.type === "TSConstructorType");
+        function check(annotation, position) {
+          astVisit(annotation, [], (node, ancestors) => {
+            if (!isInline(node) || ancestors.some(isInline)) {
+              return;
+            }
+            context.report({
+              node,
+              messageId: "inlineType",
+              data: { kind: node.type === "TSTypeLiteral" ? "object" : "function", position }
+            });
+          });
+        }
+        astVisit(program, [], (node) => {
+          if (node.type !== "FunctionDeclaration" && node.type !== "FunctionExpression" && node.type !== "ArrowFunctionExpression" && node.type !== "TSDeclareFunction" && node.type !== "TSEmptyBodyFunctionExpression") {
+            return;
+          }
+          if (parameters) {
+            for (const parameter of node.params) {
+              check(parameterAnnotation(parameter), "parameter");
+            }
+          }
+          if (returns) {
+            check(node.returnType, "return");
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-local-schema-construction.ts
+import { defineRule as defineRule13 } 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 = defineRule12({
+var noLocalSchemaConstruction = defineRule13({
   meta: {
     type: "problem",
     schema: [{
@@ -1348,9 +1444,105 @@ var noLocalSchemaConstruction = defineRule12({
   }
 });
 
+// src/rules/no-member-comments.ts
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var DIRECTIVE = /^\s*(?:@ts-(?:ignore|expect-error|nocheck)|(?:es|ox)lint-(?:disable|enable)|prettier-ignore|biome-ignore|[cv]8 ignore|istanbul ignore|webpack[A-Z])/;
+var noMemberComments = defineRule14({
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allowWhy: { type: "boolean", default: true }
+      }
+    }],
+    messages: {
+      memberComment: "Remove this comment from the type member."
+    }
+  },
+  createOnce(context) {
+    const reported = new Set;
+    function checkMember(node) {
+      const parent = node.parent;
+      if (parent.type !== "TSInterfaceBody" && parent.type !== "TSTypeLiteral" && parent.type !== "ObjectExpression")
+        return;
+      const source = context.sourceCode;
+      const { allowWhy = true } = optionsFirst(context, {});
+      const previousToken = source.getTokenBefore(node);
+      const comments = [
+        ...source.getCommentsBefore(node).filter((comment) => !previousToken || previousToken.range[0] === parent.range[0] || previousToken.loc.end.line !== comment.loc.start.line),
+        ...source.getCommentsAfter(node).filter((comment) => comment.loc.start.line === node.loc.end.line)
+      ].filter((comment) => comment.range[0] > parent.range[0] && comment.range[1] < parent.range[1]);
+      let whyContinuation = false;
+      let previousLine = -1;
+      const removable = [];
+      for (const comment of comments) {
+        const value = (comment.type === "Block" ? comment.value.replace(/^\s*\* ?/gm, "") : comment.value).trimStart();
+        const isWhy = value.startsWith("Why: ") || comment.type === "Line" && whyContinuation && comment.loc.start.line === previousLine + 1;
+        whyContinuation = comment.type === "Line" && isWhy;
+        previousLine = comment.loc.end.line;
+        if (reported.has(comment.range[0]))
+          continue;
+        reported.add(comment.range[0]);
+        if (allowWhy && isWhy)
+          continue;
+        if (DIRECTIVE.test(value))
+          continue;
+        removable.push(comment);
+      }
+      for (let index = 0;index < removable.length; ) {
+        let last = index;
+        while (last + 1 < removable.length && removable[last + 1].loc.start.line === removable[last].loc.end.line + 1)
+          last++;
+        const first = removable[index];
+        const final = removable[last];
+        index = last + 1;
+        context.report({
+          loc: { start: first.loc.start, end: final.loc.end },
+          messageId: "memberComment",
+          fix(fixer) {
+            const text = source.text;
+            const lineStart = text.lastIndexOf(`
+`, first.range[0] - 1) + 1;
+            const before = text.slice(lineStart, first.range[0]);
+            const start = first.range[0] - (/[\t ]*$/.exec(before)?.[0].length ?? 0);
+            const after = text.slice(final.range[1]);
+            const trailingLines = after.match(/^[\t ]*\r?\n(?:[\t ]*\r?\n)*/);
+            if (trailingLines) {
+              const end = final.range[1] + trailingLines[0].length;
+              if (/^[\t ]*$/.test(before))
+                return fixer.removeRange([lineStart, end]);
+              const newline = trailingLines[0].includes(`\r
+`) ? `\r
+` : `
+`;
+              return fixer.replaceTextRange([start, end], newline);
+            }
+            return fixer.removeRange([start, final.range[1]]);
+          }
+        });
+      }
+    }
+    return {
+      Program() {
+        reported.clear();
+      },
+      TSPropertySignature: checkMember,
+      TSMethodSignature: checkMember,
+      TSIndexSignature: checkMember,
+      TSCallSignatureDeclaration: checkMember,
+      TSConstructSignatureDeclaration: checkMember,
+      Property: checkMember,
+      SpreadElement: checkMember
+    };
+  }
+});
+
 // src/rules/no-rederive-schema.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noRederiveSchema = defineRule13({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var noRederiveSchema = defineRule15({
   meta: {
     type: "problem",
     schema: [{
@@ -1395,8 +1587,8 @@ var noRederiveSchema = defineRule13({
 });
 
 // src/rules/no-restricted-files.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var noRestrictedFiles = defineRule14({
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+var noRestrictedFiles = defineRule16({
   meta: {
     type: "problem",
     schema: [{
@@ -1426,7 +1618,7 @@ var noRestrictedFiles = defineRule14({
 });
 
 // src/rules/no-restricted-token.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 function tokenIsTypeOnlyImport(node) {
   const parent = node.parent;
   if (parent?.type === "ImportSpecifier") {
@@ -1434,7 +1626,7 @@ function tokenIsTypeOnlyImport(node) {
   }
   return (parent?.type === "ImportDefaultSpecifier" || parent?.type === "ImportNamespaceSpecifier") && parent.parent.type === "ImportDeclaration" && parent.parent.importKind === "type";
 }
-var noRestrictedToken = defineRule15({
+var noRestrictedToken = defineRule17({
   meta: {
     type: "problem",
     schema: [{
@@ -1454,9 +1646,9 @@ var noRestrictedToken = defineRule15({
   createOnce(context) {
     return {
       before() {
-        const options2 = optionsFirst(context);
+        const options = 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));
+        const allowed = options.allowIn.some((suffix) => filename.endsWith(suffix)) || (options.allowPathPatterns ?? []).some((pattern) => new RegExp(pattern).test(filename));
         if (allowed) {
           return false;
         }
@@ -1476,8 +1668,8 @@ var noRestrictedToken = defineRule15({
 });
 
 // src/rules/no-runtime-in-types.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-var noRuntimeInTypes = defineRule16({
+import { defineRule as defineRule18 } from "@oxlint/plugins";
+var noRuntimeInTypes = defineRule18({
   meta: {
     type: "problem",
     schema: [{
@@ -1527,7 +1719,7 @@ var noRuntimeInTypes = defineRule16({
 });
 
 // src/rules/no-single-use-scalar-schema.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 function isScalarSchema(node, namespaces, structuralMethods) {
   if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
     return false;
@@ -1549,8 +1741,8 @@ function isDirectObjectField(identifier, ancestors, namespaces, structuralMethod
   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)) {
+function isAllowedStructuralElement(identifier, initializer, ancestors, options, namespaces, structuralMethods) {
+  if (!options.allowZodScalars || !schemasIsAllowedElement(initializer, true, namespaces, structuralMethods)) {
     return false;
   }
   const parent = ancestors.at(-1);
@@ -1559,9 +1751,9 @@ function isAllowedStructuralElement(identifier, initializer, ancestors, options2
     return false;
   }
   const method = call.callee.type === "MemberExpression" ? astStaticMemberName(call.callee) : undefined;
-  return Boolean(method && options2.methods.includes(method) && schemasElements(call).includes(identifier));
+  return Boolean(method && options.methods.includes(method) && schemasElements(call).includes(identifier));
 }
-var noSingleUseScalarSchema = defineRule17({
+var noSingleUseScalarSchema = defineRule19({
   meta: {
     type: "suggestion",
     schema: [{
@@ -1596,9 +1788,9 @@ var noSingleUseScalarSchema = defineRule17({
         }
       },
       "Program:exit"(program) {
-        const options2 = optionsFirst(context);
-        const namespaces = new Set(options2.namespaces);
-        const structuralMethods = new Set(options2.structuralMethods);
+        const options = optionsFirst(context);
+        const namespaces = new Set(options.namespaces);
+        const structuralMethods = new Set(options.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;
@@ -1607,14 +1799,14 @@ var noSingleUseScalarSchema = defineRule17({
             continue;
           }
           const variable = context.sourceCode.getDeclaredVariables(declarator).find((candidate) => candidate.name === name);
-          const references = variable?.references.filter((reference2) => reference2.isRead()) ?? [];
+          const references = variable?.references.filter((reference) => reference.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);
+          const inlineable = isDirectObjectField(identifier, ancestors, namespaces, structuralMethods) || isAllowedStructuralElement(identifier, initializer, ancestors, options, namespaces, structuralMethods);
           if (inlineable) {
             context.report({
               node: declarator.id,
@@ -1629,8 +1821,8 @@ var noSingleUseScalarSchema = defineRule17({
 });
 
 // src/rules/no-top-level-functions.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
-var noTopLevelFunctions = defineRule18({
+import { defineRule as defineRule20 } from "@oxlint/plugins";
+var noTopLevelFunctions = defineRule20({
   meta: {
     type: "problem",
     schema: [{
@@ -1687,8 +1879,8 @@ var noTopLevelFunctions = defineRule18({
 });
 
 // src/rules/no-trivial-functions.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
-var noTrivialFunctions = defineRule19({
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var noTrivialFunctions = defineRule21({
   meta: {
     type: "problem",
     schema: [{
@@ -1726,8 +1918,8 @@ var noTrivialFunctions = defineRule19({
 });
 
 // src/rules/no-type-declarations.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var noTypeDeclarations = defineRule20({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var noTypeDeclarations = defineRule22({
   meta: {
     type: "problem",
     schema: [{
@@ -1762,8 +1954,8 @@ var noTypeDeclarations = defineRule20({
 });
 
 // src/rules/no-unescaped-like.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
-var noUnescapedLike = defineRule21({
+import { defineRule as defineRule23 } from "@oxlint/plugins";
+var noUnescapedLike = defineRule23({
   meta: {
     type: "problem",
     schema: [{
@@ -1782,21 +1974,21 @@ var noUnescapedLike = defineRule21({
     let sanitized = new Set;
     return {
       Program(program) {
-        const { sanitizers: sanitizers2, allowSanitizedBindings = true } = optionsFirst(context);
-        sanitized = allowSanitizedBindings ? sanitizersConfiguredBindings(program, new Set(sanitizers2)) : new Set;
+        const { sanitizers, allowSanitizedBindings = true } = optionsFirst(context);
+        sanitized = allowSanitizedBindings ? sanitizersConfiguredBindings(program, new Set(sanitizers)) : new Set;
       },
       CallExpression(node) {
         if (node.callee.type !== "MemberExpression") {
           return;
         }
-        const { methods, sanitizers: sanitizers2 } = optionsFirst(context);
+        const { methods, sanitizers } = 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) {
+        if (!sanitizersCallsConfigured(value, new Set(sanitizers)) && !allowedIdentifier) {
           context.report({
             node: value ?? node,
             messageId: "unescaped",
@@ -1809,8 +2001,8 @@ var noUnescapedLike = defineRule21({
 });
 
 // src/rules/only-export-components.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
-var onlyExportComponents = defineRule22({
+import { defineRule as defineRule24 } from "@oxlint/plugins";
+var onlyExportComponents = defineRule24({
   meta: {
     type: "problem",
     schema: [{
@@ -1865,9 +2057,146 @@ var onlyExportComponents = defineRule22({
   }
 });
 
+// src/rules/only-export-constants.ts
+import { defineRule as defineRule25 } from "@oxlint/plugins";
+function bindingNames(pattern) {
+  switch (pattern.type) {
+    case "Identifier":
+      return [pattern.name];
+    case "AssignmentPattern":
+      return bindingNames(pattern.left);
+    case "RestElement":
+      return bindingNames(pattern.argument);
+    case "ArrayPattern":
+      return pattern.elements.flatMap((element) => element ? bindingNames(element) : []);
+    case "ObjectPattern":
+      return pattern.properties.flatMap((property) => bindingNames(property.type === "RestElement" ? property : property.value));
+  }
+}
+function moduleName(node) {
+  return node.type === "Identifier" ? node.name : node.value;
+}
+function unwrap(expression) {
+  if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "TSInstantiationExpression") {
+    return unwrap(expression.expression);
+  }
+  return expression;
+}
+function collectBindings(program) {
+  const bindings = new Map;
+  for (const statement of program.body) {
+    if (statement.type === "ImportDeclaration") {
+      for (const specifier of statement.specifiers) {
+        bindings.set(specifier.local.name, {
+          kind: statement.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type" ? "type" : "import"
+        });
+      }
+      continue;
+    }
+    const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+    if (declaration?.type === "TSImportEqualsDeclaration") {
+      bindings.set(declaration.id.name, { kind: declaration.importKind === "type" ? "type" : "import" });
+    } else if (declaration?.type === "VariableDeclaration") {
+      for (const item of declaration.declarations) {
+        for (const name of bindingNames(item.id)) {
+          bindings.set(name, {
+            kind: declaration.kind === "const" ? "const" : "other",
+            value: item.id.type === "Identifier" ? item.init : undefined
+          });
+        }
+      }
+    } else if (declaration && "id" in declaration && declaration.id?.type === "Identifier") {
+      bindings.set(declaration.id.name, {
+        kind: declaration.type === "TSTypeAliasDeclaration" || declaration.type === "TSInterfaceDeclaration" ? "type" : declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction" ? "function" : declaration.type === "ClassDeclaration" ? "class" : "other"
+      });
+    }
+  }
+  return bindings;
+}
+var onlyExportConstants = defineRule25({
+  meta: {
+    type: "problem",
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allowFunctionValues: { type: "boolean" },
+        allowTypeExports: { type: "boolean" },
+        allowReExports: { type: "boolean" }
+      }
+    }],
+    messages: {
+      nonConstant: "Export '{{name}}' must be a local const binding with an allowed value; types and re-exports require explicit options."
+    }
+  },
+  createOnce(context) {
+    return {
+      Program(program) {
+        const { allowFunctionValues = false, allowTypeExports = false, allowReExports = false } = optionsFirst(context, {});
+        const bindings = collectBindings(program);
+        function hasForbiddenValue(binding, seen = new Set) {
+          if (seen.has(binding) || binding.kind === "class") {
+            return true;
+          }
+          if (binding.kind === "function") {
+            return !allowFunctionValues;
+          }
+          if (!binding.value) {
+            return false;
+          }
+          seen.add(binding);
+          const value = unwrap(binding.value);
+          if (value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression") {
+            return !allowFunctionValues;
+          }
+          if (value.type === "ClassExpression") {
+            return true;
+          }
+          const target = value.type === "Identifier" ? bindings.get(value.name) : undefined;
+          return target ? hasForbiddenValue(target, seen) : false;
+        }
+        function check(node, name, localName, typeOnly = false, reExport = false) {
+          const binding = localName ? bindings.get(localName) : undefined;
+          const allowed = typeOnly || !reExport && binding?.kind === "type" ? allowTypeExports : reExport || binding?.kind === "import" ? allowReExports : binding?.kind === "const" && !hasForbiddenValue(binding);
+          if (!allowed) {
+            context.report({ node, messageId: "nonConstant", data: { name } });
+          }
+        }
+        for (const statement of program.body) {
+          if (statement.type === "ExportAllDeclaration") {
+            check(statement, "*", undefined, statement.exportKind === "type", true);
+          } else if (statement.type === "ExportDefaultDeclaration") {
+            const declaration = statement.declaration;
+            check(statement, "default", declaration.type === "Identifier" ? declaration.name : undefined, declaration.type === "TSInterfaceDeclaration");
+          } else if (statement.type === "TSExportAssignment") {
+            check(statement, "export =");
+          } else if (statement.type === "TSNamespaceExportDeclaration") {
+            check(statement, statement.id.name);
+          } else if (statement.type === "ExportNamedDeclaration") {
+            const declaration = statement.declaration;
+            if (declaration?.type === "VariableDeclaration") {
+              for (const item of declaration.declarations) {
+                for (const name of bindingNames(item.id)) {
+                  check(item, name, name);
+                }
+              }
+            } else if (declaration) {
+              const name = "id" in declaration && declaration.id?.type === "Identifier" ? declaration.id.name : "<anonymous>";
+              check(declaration, name, name);
+            }
+            for (const specifier of statement.specifiers) {
+              check(specifier, moduleName(specifier.exported), moduleName(specifier.local), statement.exportKind === "type" || specifier.exportKind === "type", Boolean(statement.source));
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/require-file-factory.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
-var requireFileFactory = defineRule23({
+import { defineRule as defineRule26 } from "@oxlint/plugins";
+var requireFileFactory = defineRule26({
   meta: {
     type: "problem",
     schema: [{
@@ -1913,8 +2242,8 @@ var requireFileFactory = defineRule23({
 });
 
 // src/rules/require-object-params.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-var requireObjectParams = defineRule24({
+import { defineRule as defineRule27 } from "@oxlint/plugins";
+var requireObjectParams = defineRule27({
   meta: {
     type: "problem",
     schema: [],
@@ -1940,8 +2269,8 @@ var requireObjectParams = defineRule24({
 });
 
 // src/rules/require-orpc-output.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
-var requireOrpcOutput = defineRule25({
+import { defineRule as defineRule28 } from "@oxlint/plugins";
+var requireOrpcOutput = defineRule28({
   meta: {
     type: "problem",
     schema: [{
@@ -1983,8 +2312,8 @@ var requireOrpcOutput = defineRule25({
 });
 
 // src/rules/require-paired-call.ts
-import { defineRule as defineRule26 } from "@oxlint/plugins";
-var requirePairedCall = defineRule26({
+import { defineRule as defineRule29 } from "@oxlint/plugins";
+var requirePairedCall = defineRule29({
   meta: {
     type: "problem",
     schema: [{
@@ -2039,8 +2368,8 @@ var requirePairedCall = defineRule26({
 });
 
 // src/rules/route-surface.ts
-import { defineRule as defineRule27 } from "@oxlint/plugins";
-var routeSurface = defineRule27({
+import { defineRule as defineRule30 } from "@oxlint/plugins";
+var routeSurface = defineRule30({
   meta: {
     type: "problem",
     schema: [{
@@ -2096,7 +2425,9 @@ var src_default = eslintCompatPlugin({
     "no-file-level-helpers": noFileLevelHelpers,
     "no-imported-type-alias": noImportedTypeAlias,
     "no-inline-schema-elements": noInlineSchemaElements,
+    "no-inline-types": noInlineTypes,
     "no-local-schema-construction": noLocalSchemaConstruction,
+    "no-member-comments": noMemberComments,
     "no-rederive-schema": noRederiveSchema,
     "no-restricted-files": noRestrictedFiles,
     "no-restricted-token": noRestrictedToken,
@@ -2107,6 +2438,7 @@ var src_default = eslintCompatPlugin({
     "no-type-declarations": noTypeDeclarations,
     "no-unescaped-like": noUnescapedLike,
     "only-export-components": onlyExportComponents,
+    "only-export-constants": onlyExportConstants,
     "require-file-factory": requireFileFactory,
     "require-object-params": requireObjectParams,
     "require-orpc-output": requireOrpcOutput,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",