oxlint-plugin-arch 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 0.2.0
+
+First npm release.
+
+- Add `no-trivial-functions`, `no-local-schema-construction`, and `no-single-use-scalar-schema`.
+- Add `folder-prefix` `after` so nested folders stay in the filename.
+- Add `allDeclarations` on filename/export naming rules.
+- Close alias, type-only import, re-export, and `zod/*` edge cases.
+- Install from npm with specifier `oxlint-plugin-arch`. Vendoring stays optional.
+
+## 0.1.0
+
+Initial plugin with configurable architecture rules.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# oxlint-plugin-arch
+
+Configurable, filename-aware architecture rules for Oxlint.
+
+Install the package, then put repository paths and policy in your Oxlint config. Rules contain no application-specific names or folders.
+
+## Install
+
+```bash
+bun add -d oxlint-plugin-arch oxlint @oxlint/plugins
+```
+
+Use matching `oxlint` and `@oxlint/plugins` versions. Then register the package:
+
+```ts
+import { defineConfig } from 'oxlint'
+
+export default defineConfig({
+  jsPlugins: [
+    { name: 'arch', specifier: 'oxlint-plugin-arch' },
+  ],
+})
+```
+
+## Recommended companion: anti-slop
+
+We recommend [Dillon Mulroy's anti-slop](https://github.com/dmmulroy/anti-slop) alongside this plugin. Anti-slop catches low-evidence TypeScript and JavaScript implementation patterns; oxlint-plugin-arch enforces configurable file, export, boundary, and API structure.
+
+Register both in the same Oxlint config under their separate `anti-slop/*` and `arch/*` rule namespaces.
+
+## Optional: vendor a local copy
+
+If you want to inspect or fork the rules in-tree, copy `src/index.ts`, `src/rules/`, and `src/utils/`, or use the agent skill:
+
+```bash
+npx skills add nikuscs/oxlint-plugin-arch --skill install-oxlint-arch
+```
+
+Then point `jsPlugins[].specifier` at the copied entry file instead of the package name.
+
+## 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 25 rules across representative component, action, service, route, API, schema, and database scopes.
+
+Copy the shapes that match your repository; do not copy globs or naming policy blindly.
+
+## Rules
+
+- `export-file-prefix` — require export names, or every function and type, to start with a filename-derived 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-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-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.
+- `no-restricted-token` — restrict an identifier to configured owner paths.
+- `no-runtime-in-types` — keep selected type modules runtime-free.
+- `no-single-use-scalar-schema` — reject local scalar Zod aliases used once where they can be safely inlined.
+- `no-top-level-functions` — reject top-level functions and optional re-exports.
+- `no-trivial-functions` — reject empty or passthrough top-level functions.
+- `no-unescaped-like` — require configured sanitizers for configured query methods.
+- `only-export-components` — allow only React component and type exports.
+- `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.
+- `require-paired-call` — require one configured call when another appears.
+- `route-surface` — constrain route exports, hooks, and intrinsic JSX.
+
+Every rule file includes plain-English behavior and examples. Rule tests under `src/tests/` show complete option shapes.
+
+## Development
+
+```bash
+bun install
+bun run check
+```
+
+After production changes, run `bun run sync:skill-assets`; CI verifies the bundled installer copy matches `src/`.
+
+## Release
+
+Update `CHANGELOG.md`, then run the full lifecycle from a clean `main`:
+
+```bash
+bun run release              # prompt for patch/minor/major
+bun run release:patch        # check, bump, tag, push, npm publish
+bun run release:dry-run      # check + npm pack dry-run only
+```
+
+`scripts/release.sh` refuses dirty trees and requires `npm login`. `prepublishOnly` runs `bun run check` again before the tarball goes out.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "oxlint-plugin-arch",
+  "version": "0.2.1",
+  "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "src/index.ts",
+    "src/rules",
+    "src/utils"
+  ],
+  "scripts": {
+    "check": "bun run lint && bun run test && bun run typecheck && bun run check:examples && bun run check:skill-assets",
+    "lint": "oxlint src examples scripts skills/install-oxlint-arch/scripts",
+    "test": "vitest run src/tests",
+    "typecheck": "tsc --noEmit",
+    "sync:skill-assets": "bun scripts/sync-skill-assets.ts",
+    "check:examples": "oxlint examples/minimal.oxlint.config.ts -c examples/minimal.oxlint.config.ts --disable-nested-config && oxlint examples/full.oxlint.config.ts -c examples/full.oxlint.config.ts --disable-nested-config",
+    "check:skill-assets": "bun scripts/sync-skill-assets.ts --check",
+    "prepublishOnly": "bun run check",
+    "release": "bash scripts/release.sh",
+    "release:dry-run": "bash scripts/release.sh --dry-run",
+    "release:patch": "bash scripts/release.sh patch --yes",
+    "release:minor": "bash scripts/release.sh minor --yes",
+    "release:major": "bash scripts/release.sh major --yes"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "1.78.0"
+  },
+  "peerDependencies": {
+    "oxlint": ">=1.78.0"
+  },
+  "devDependencies": {
+    "@types/node": "26.0.1",
+    "bumpp": "10.4.1",
+    "oxlint": "1.78.0",
+    "typescript": "6.0.3",
+    "vitest": "4.1.9"
+  },
+  "packageManager": "bun@1.3.14",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nikuscs/oxlint-plugin-arch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nikuscs/oxlint-plugin-arch/issues"
+  },
+  "homepage": "https://github.com/nikuscs/oxlint-plugin-arch#readme",
+  "keywords": [
+    "oxlint",
+    "eslint",
+    "architecture",
+    "lint",
+    "plugin"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,57 @@
+import { eslintCompatPlugin } from '@oxlint/plugins'
+import { exportFilePrefix } from './rules/export-file-prefix.ts'
+import { exportNamePattern } from './rules/export-name-pattern.ts'
+import { filenameExportName } from './rules/filename-export-name.ts'
+import { filenameMatch } from './rules/filename-match.ts'
+import { folderPrefix } from './rules/folder-prefix.ts'
+import { noExtraExports } from './rules/no-extra-exports.ts'
+import { noExtraFactoryKeys } from './rules/no-extra-factory-keys.ts'
+import { noFileLevelHelpers } from './rules/no-file-level-helpers.ts'
+import { noImportedTypeAlias } from './rules/no-imported-type-alias.ts'
+import { noInlineSchemaElements } from './rules/no-inline-schema-elements.ts'
+import { noLocalSchemaConstruction } from './rules/no-local-schema-construction.ts'
+import { noRederiveSchema } from './rules/no-rederive-schema.ts'
+import { noRestrictedFiles } from './rules/no-restricted-files.ts'
+import { noRestrictedToken } from './rules/no-restricted-token.ts'
+import { noRuntimeInTypes } from './rules/no-runtime-in-types.ts'
+import { noSingleUseScalarSchema } from './rules/no-single-use-scalar-schema.ts'
+import { noTopLevelFunctions } from './rules/no-top-level-functions.ts'
+import { noTrivialFunctions } from './rules/no-trivial-functions.ts'
+import { noUnescapedLike } from './rules/no-unescaped-like.ts'
+import { onlyExportComponents } from './rules/only-export-components.ts'
+import { requireFileFactory } from './rules/require-file-factory.ts'
+import { requireObjectParams } from './rules/require-object-params.ts'
+import { requireOrpcOutput } from './rules/require-orpc-output.ts'
+import { requirePairedCall } from './rules/require-paired-call.ts'
+import { routeSurface } from './rules/route-surface.ts'
+
+export 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,
+  },
+})

package/src/rules/export-file-prefix.ts

@@ -0,0 +1,70 @@
+import { defineRule } from '@oxlint/plugins'
+import { declarationsCollectNamed, exportsCollect, namingFileBasename, optionsFirst } from '../utils/index.ts'
+
+interface ExportFilePrefixOptions {
+  stem?: 'before-first-dot' | 'full-basename'
+  normalize?: 'remove-separators' | 'none'
+  allDeclarations?: boolean
+  allowPattern?: string
+}
+
+/**
+ * Checks that exported names start with a prefix taken from the filename, and can also check every function and type in the file.
+ *
+ * Example: In `foo-chart.tsx`, `fooChartPreview` and `interface FooChartPreviewProps` pass; `preview` fails when `allDeclarations` is on.
+ */
+export const 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 options = optionsFirst<ExportFilePrefixOptions>(context, {
+          stem: 'before-first-dot',
+          normalize: 'remove-separators',
+        })
+        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, '')
+        const stem = options.stem === 'full-basename' ? basename : (basename.split('.')[0] ?? '')
+        const prefix = options.normalize === 'none' ? stem : stem.replaceAll(/[-_]/g, '').toLowerCase()
+        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<string>()
+
+        for (const item of names) {
+          const key = `${item.name}:${item.node.start}:${item.node.end}`
+          const comparableName = options.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 },
+          })
+        }
+      },
+    }
+  },
+})

package/src/rules/export-name-pattern.ts

@@ -0,0 +1,71 @@
+import { defineRule } from '@oxlint/plugins'
+import { declarationsCollectNamed, exportsCollect, optionsFirst } from '../utils/index.ts'
+
+interface ExportNamePatternOptions {
+  pattern: string
+  flags?: string
+  ignoreTypeExports?: boolean
+  allDeclarations?: boolean
+  allowPattern?: string
+}
+
+/**
+ * Checks exported names, or every function and type, against a regular expression supplied in the rule options.
+ *
+ * Example: With `^user[A-Z]`, `userGet` passes while `getUser` fails.
+ */
+export const exportNamePattern = defineRule({
+  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<ExportNamePatternOptions>(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<string>()
+
+        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 },
+          })
+        }
+      },
+    }
+  },
+})

package/src/rules/filename-export-name.ts

@@ -0,0 +1,86 @@
+import { defineRule } from '@oxlint/plugins'
+import {
+  declarationsCollectFunctions,
+  exportsCollectFunctions,
+  factoriesExpandTemplate,
+  namingFileBasename,
+  namingMatchTemplate,
+  optionsFirst,
+} from '../utils/index.ts'
+
+interface FilenameExportNameOptions {
+  file: string
+  export: string
+  mode?: 'all' | 'some'
+  placeholderPattern?: string
+  allDeclarations?: boolean
+}
+
+/**
+ * Builds an expected function name from filename placeholders, then checks exported or all functions against it.
+ *
+ * Example: `user-action.create.ts` can require `makeUserActionCreate`; `mode: some` allows additional exports.
+ */
+export const filenameExportName = defineRule({
+  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<FilenameExportNameOptions>(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 },
+            })
+          }
+        }
+      },
+    }
+  },
+})

package/src/rules/filename-match.ts

@@ -0,0 +1,47 @@
+import { defineRule } from '@oxlint/plugins'
+import { namingFileBasename, optionsFirst } from '../utils/index.ts'
+
+interface FilenameMatchOptions {
+  pattern: string
+  message: string
+  flags?: string
+}
+
+/**
+ * Checks the current filename against a configurable regular expression and reports the configured message.
+ *
+ * Example: A pattern ending in `.spec.ts` accepts `login.spec.ts` and rejects `login.test.ts`.
+ */
+export const filenameMatch = defineRule({
+  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<FilenameMatchOptions>(context)
+
+        if (!new RegExp(pattern, flags).test(namingFileBasename(context.filename))) {
+          context.report({
+            node: program,
+            messageId: 'mismatch',
+            data: { message },
+          })
+        }
+      },
+    }
+  },
+})

package/src/rules/folder-prefix.ts

@@ -0,0 +1,73 @@
+import { defineRule } from '@oxlint/plugins'
+import {
+  namingDirSegments,
+  namingFileBasename,
+  namingFolderPrefixes,
+  namingPosixPath,
+  namingSegmentsAfter,
+  optionsFirst,
+} from '../utils/index.ts'
+
+interface FolderPrefixOptions {
+  singularize?: 'none' | 'trailing-s'
+  separators?: string[]
+  after?: string
+}
+
+/**
+ * Checks that a filename equals or starts with its parent folder name, or with the folders after a configured root.
+ *
+ * Example: Inside `users/`, `user-card.tsx` passes. With `after: 'components'`, `components/admin/insights/admin-insights-foo.tsx` passes.
+ */
+export const folderPrefix = defineRule({
+  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<FolderPrefixOptions>(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] ?? '' },
+          })
+        }
+      },
+    }
+  },
+})

package/src/rules/no-extra-exports.ts

@@ -0,0 +1,60 @@
+import { defineRule } from '@oxlint/plugins'
+import { exportsCollect, namingCamelCase, namingFileBasename, namingPascalCase, optionsFirst } from '../utils/index.ts'
+
+interface NoExtraExportsOptions {
+  names: string[]
+  domainStem?: 'before-first-dot' | 'full-basename'
+  allowTypeExports?: boolean
+}
+
+/**
+ * Allows only the configured export-name templates, with placeholders derived from the filename.
+ *
+ * Example: `billing.service.ts` may allow `makeBillingService`; an exported `helper` then fails.
+ */
+export const noExtraExports = defineRule({
+  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 options = optionsFirst<NoExtraExportsOptions>(context)
+        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, '')
+        const domain = options.domainStem === 'full-basename' ? basename : (basename.split('.')[0] ?? '')
+        const allowed = options.names.map((template) => template
+          .replaceAll('{Domain}', namingPascalCase(domain))
+          .replaceAll('{domain}', namingCamelCase(domain)))
+
+        for (const binding of exportsCollect(program)) {
+          if (options.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(', ') },
+            })
+          }
+        }
+      },
+    }
+  },
+})