@starci/eslint-canon-fe 3.0.2 → 5.1.2

package/e2e-shape.mjs

@@ -0,0 +1,348 @@
+/**
+ * The rules that hold `e2e-shape.md` (HFS R66, `FE_E2E_SHAPE`).
+ *
+ * THESE RULES GOVERN THE E2E TREE, NOT `src/`. `starciFeConfig` attaches them to `e2e/**` and
+ * `playwright.config.*`; every rule here also scopes itself by path, so a config that reaches it by
+ * mistake governs nothing it should not.
+ *
+ * WHY THE SHAPE IS FIXED. An e2e suite is the only proof that the whole app works, and it is run by
+ * hand, so it rots quietly: absolute paths that exist on one machine, a Docker dependency that makes
+ * it unrunnable in CI, a helper that writes into the OTHER repository's tree, a `test.skip` that
+ * turns a missing environment into a green run, and helpers whose untyped parameters hide the fields
+ * a test depends on. One layout - `e2e/<area>/<name>.e2e-spec.ts`, three viewports, typed helpers -
+ * is what lets the land gate check it statically even though it cannot run it.
+ *
+ * WHAT IS NOT HERE. That `typecheck:e2e` runs before `test:e2e` is a `package.json` fact (the
+ * architecture machine reads it); that the specs pass is the run itself.
+ */
+
+import { isE2eFile } from "./lib/scope.mjs"
+import { baseName } from "./lib/scope.mjs"
+import { normalizePath } from "./lib/path.mjs"
+
+/** The three viewports every e2e project set covers, as `width x height`. */
+export const VIEWPORTS = Object.freeze(["1440x900", "768x1024", "390x844"])
+
+/** A file that reads like a spec, by any of the common spellings. */
+const SPEC_LIKE = /(?:\.|-)(?:e2e-)?(?:spec|test)\.[cm]?tsx?$/
+
+/** The one legal spec path: `e2e/<area>/<name>.e2e-spec.ts`. */
+const SPEC_PATH = /(?:^|\/)e2e\/[^/]+\/[^/]+\.e2e-spec\.ts$/
+
+/** Helper folders: not specs, and never spec-named. */
+const HELPER_PATH = /(?:^|\/)e2e\/(?:support|fixtures)\//
+
+/** An absolute filesystem path: a drive, a UNC share, or a well-known root. */
+const ABSOLUTE_PATH = /^(?:[A-Za-z]:[\\/]|\\\\|\/(?:Users|home|tmp|mnt|var|opt|etc|root|d|c)\/)/
+
+/** A `..` segment in a path string. */
+const PARENT_SEGMENT = /(?:^|[\\/])\.\.(?:[\\/]|$)/
+
+/** Static string of a literal or an expression-free template, else null. */
+const staticString = (node) => {
+  if (!node) return null
+  if (node.type === "Literal" && typeof node.value === "string") return node.value
+  if (node.type === "TemplateLiteral") return node.quasis.map((quasi) => quasi.value.cooked ?? "").join("")
+  return null
+}
+
+/** Every string in a subtree, so `path.join(__dirname, "..", "..")` is read as its parts. */
+const stringsIn = (node, source) => {
+  const found = []
+  const walk = (current) => {
+    if (!current || typeof current.type !== "string") return
+    const text = staticString(current)
+    if (text !== null) found.push(text)
+    for (const key of source.visitorKeys[current.type] ?? []) {
+      const child = current[key]
+      if (Array.isArray(child)) child.forEach(walk)
+      else walk(child)
+    }
+  }
+  walk(node)
+  return found
+}
+
+// -- E2E-1 -----------------------------------------------------------------------------------------
+
+/** Specs live at `e2e/<area>/<name>.e2e-spec.ts`. */
+export const e2eSpecLocation = {
+  meta: {
+    type: "problem",
+    docs: { description: "An e2e spec is `e2e/<area>/<name>.e2e-spec.ts`; helpers live under `support/` or `fixtures/`." },
+    schema: [],
+    messages: {
+      location:
+        "`{{name}}` is not at `e2e/<area>/<name>.e2e-spec.ts`. One shape - an area folder, the `.e2e-spec.ts` suffix - is what lets the gate find every spec without running them; helpers go in `e2e/support/` or `e2e/fixtures/` and are never named like a spec.",
+    },
+  },
+  create(context) {
+    const file = normalizePath(context.filename || context.getFilename())
+    if (!/(?:^|\/)e2e\//.test(file)) return {}
+    const name = baseName(file)
+    const helper = HELPER_PATH.test(file)
+    const specLike = SPEC_LIKE.test(name)
+    const legal = SPEC_PATH.test(file) && !helper
+    if ((specLike && !legal) || (helper && /\.e2e-spec\./.test(name))) {
+      return { Program: (node) => context.report({ node, messageId: "location", data: { name } }) }
+    }
+    return {}
+  },
+}
+
+// -- E2E-2 -----------------------------------------------------------------------------------------
+
+/** No absolute path in e2e source. */
+export const e2eNoAbsolutePath = {
+  meta: {
+    type: "problem",
+    docs: { description: "No absolute filesystem path in e2e source." },
+    schema: [],
+    messages: {
+      absolute:
+        "An absolute path (`{{path}}`). It exists on one machine and nowhere else, so the suite passes locally and cannot run in CI or on another machine. Build the path from the config or the test's own directory.",
+    },
+  },
+  create(context) {
+    if (!isE2eFile(context.filename || context.getFilename())) return {}
+    const check = (node, text) => {
+      if (typeof text === "string" && ABSOLUTE_PATH.test(text)) context.report({ node, messageId: "absolute", data: { path: text } })
+    }
+    return {
+      Literal: (node) => check(node, node.value),
+      TemplateElement: (node) => check(node, node.value && node.value.cooked),
+    }
+  },
+}
+
+// -- E2E-3 -----------------------------------------------------------------------------------------
+
+/** Container tooling that an e2e suite must not depend on. */
+const DOCKER_MODULE = /^(?:dockerode|testcontainers|@testcontainers\/.+|docker-compose)$/
+
+/** A command or string that starts Docker. */
+const DOCKER_TEXT = /\bdocker(?:-compose)?\b|\bdocker\s+compose\b/i
+
+/** No Docker in e2e. */
+export const e2eNoDocker = {
+  meta: {
+    type: "problem",
+    docs: { description: "An e2e suite does not start or require Docker." },
+    schema: [],
+    messages: {
+      docker:
+        "Docker in an e2e suite. A suite that needs a container runtime cannot run where the app can, and it hides the real prerequisite (a running app and backend) behind a tool. Point the suite at a URL from the config and let the environment provide the stack.",
+    },
+  },
+  create(context) {
+    if (!isE2eFile(context.filename || context.getFilename())) return {}
+    return {
+      ImportDeclaration(node) {
+        if (DOCKER_MODULE.test(String(node.source.value))) context.report({ node, messageId: "docker" })
+      },
+      Literal(node) {
+        if (typeof node.value === "string" && DOCKER_TEXT.test(node.value)) context.report({ node, messageId: "docker" })
+      },
+      TemplateElement(node) {
+        if (DOCKER_TEXT.test((node.value && node.value.cooked) || "")) context.report({ node, messageId: "docker" })
+      },
+    }
+  },
+}
+
+// -- E2E-4 -----------------------------------------------------------------------------------------
+
+/** Filesystem calls that write, move or remove. */
+const FS_WRITE = new Set([
+  "writeFile",
+  "writeFileSync",
+  "appendFile",
+  "appendFileSync",
+  "mkdir",
+  "mkdirSync",
+  "rm",
+  "rmSync",
+  "rmdir",
+  "rmdirSync",
+  "copyFile",
+  "copyFileSync",
+  "cp",
+  "cpSync",
+  "rename",
+  "renameSync",
+  "unlink",
+  "unlinkSync",
+  "createWriteStream",
+])
+
+/** The name a call is made through: `writeFile` or `fs.writeFile` or `fs.promises.writeFile`. */
+const calleeName = (callee) => {
+  if (callee.type === "Identifier") return callee.name
+  if (callee.type === "MemberExpression" && !callee.computed) return callee.property.name
+  return null
+}
+
+/** No e2e write outside the repository's own tree. */
+export const e2eNoCrossRepoWrite = {
+  meta: {
+    type: "problem",
+    docs: { description: "An e2e file write never targets an absolute path or climbs out of the repository." },
+    schema: [],
+    messages: {
+      write:
+        "This file operation writes to a path that is absolute or climbs out with `..`. An e2e run that writes into another repository (the backend's tree, a shared folder) changes state it does not own, and its result depends on a checkout layout. Write under this repository's own output folder.",
+    },
+  },
+  create(context) {
+    if (!isE2eFile(context.filename || context.getFilename())) return {}
+    const source = context.sourceCode || context.getSourceCode()
+    return {
+      CallExpression(node) {
+        const name = calleeName(node.callee)
+        if (!name || !FS_WRITE.has(name)) return
+        const strings = node.arguments.flatMap((argument) => stringsIn(argument, source))
+        if (strings.some((text) => ABSOLUTE_PATH.test(text) || PARENT_SEGMENT.test(text) || text === "..")) {
+          context.report({ node, messageId: "write" })
+        }
+      },
+    }
+  },
+}
+
+// -- E2E-5 -----------------------------------------------------------------------------------------
+
+/** The root identifier of a member chain: `test` in `test.describe.skip`. */
+const chainRoot = (node) => {
+  let current = node
+  while (current && current.type === "MemberExpression") current = current.object
+  return current && current.type === "Identifier" ? current.name : null
+}
+
+/** No skipped test: a missing environment is a failure. */
+export const e2eNoSkip = {
+  meta: {
+    type: "problem",
+    docs: { description: "No `test.skip`, `test.fixme` or `describe.skip`: a missing environment fails the run." },
+    schema: [],
+    messages: {
+      skip:
+        "A skipped test. Skipping because the environment is missing turns \"the suite cannot run\" into a green run, which is the one result an e2e suite must never give. Fix the environment, or delete the test.",
+    },
+  },
+  create(context) {
+    if (!isE2eFile(context.filename || context.getFilename())) return {}
+    return {
+      CallExpression(node) {
+        const callee = node.callee
+        if (callee.type !== "MemberExpression" || callee.computed) return
+        if (!["skip", "fixme"].includes(callee.property.name)) return
+        if (["test", "it", "describe"].includes(chainRoot(callee.object))) context.report({ node, messageId: "skip" })
+      },
+    }
+  },
+}
+
+// -- E2E-6 -----------------------------------------------------------------------------------------
+
+/** True when a function is a module-level helper: declared, or bound to a top-level `const`. */
+const isModuleLevel = (node) => {
+  let current = node.parent
+  if (node.type !== "FunctionDeclaration") {
+    if (!current || current.type !== "VariableDeclarator") return false
+    current = current.parent && current.parent.parent
+  }
+  return Boolean(current) && ["Program", "ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(current.type)
+}
+
+/** Helpers carry types; nothing is `any`. */
+export const e2eTypedHelpers = {
+  meta: {
+    type: "problem",
+    docs: { description: "e2e helper parameters are typed and nothing is `any`." },
+    schema: [],
+    messages: {
+      untyped:
+        "A helper parameter with no type. A test depends on the fields a helper takes and returns; untyped, a renamed field fails at run time in a test nobody touched. Annotate the parameter.",
+      any: "`any` in e2e source. It turns the compiler off for the value a test asserts on. Type it, or narrow from `unknown`.",
+    },
+  },
+  create(context) {
+    if (!isE2eFile(context.filename || context.getFilename())) return {}
+    const checkParams = (node) => {
+      if (!isModuleLevel(node)) return
+      for (const parameter of node.params) {
+        const target = parameter.type === "AssignmentPattern" ? parameter.left : parameter
+        // A default value gives the parameter a type the compiler infers.
+        if (parameter.type === "AssignmentPattern" && parameter.right.type === "Literal") continue
+        if (target.type === "RestElement") {
+          if (!target.typeAnnotation) context.report({ node: target, messageId: "untyped" })
+          continue
+        }
+        if (!target.typeAnnotation) context.report({ node: target, messageId: "untyped" })
+      }
+    }
+    return {
+      FunctionDeclaration: checkParams,
+      ArrowFunctionExpression: checkParams,
+      FunctionExpression: checkParams,
+      TSAnyKeyword(node) {
+        context.report({ node, messageId: "any" })
+      },
+    }
+  },
+}
+
+// -- E2E-7 -----------------------------------------------------------------------------------------
+
+/** Every Playwright config declares exactly the three viewports. */
+export const playwrightViewports = {
+  meta: {
+    type: "problem",
+    docs: { description: `playwright.config declares the viewports ${VIEWPORTS.join(", ")} and no others.` },
+    schema: [],
+    messages: {
+      missing:
+        "The Playwright config does not declare the viewport {{size}}. Every app is proved at 1440x900, 768x1024 and 390x844 so a layout that only works on a desktop screen fails here.",
+      extra:
+        "The Playwright config declares the viewport {{size}}, which is not one of 1440x900, 768x1024, 390x844. A fourth size is a fourth thing to keep passing that no design covers.",
+    },
+  },
+  create(context) {
+    if (!/^playwright\.config\.[cm]?[jt]s$/.test(baseName(context.filename || context.getFilename()))) return {}
+    const seen = new Map()
+    return {
+      Property(node) {
+        if (node.computed || node.key.type !== "Identifier" || node.key.name !== "viewport") return
+        if (node.value.type !== "ObjectExpression") return
+        const field = (name) => {
+          const property = node.value.properties.find((p) => p.type === "Property" && p.key.type === "Identifier" && p.key.name === name)
+          return property && property.value.type === "Literal" ? property.value.value : null
+        }
+        const width = field("width")
+        const height = field("height")
+        if (typeof width === "number" && typeof height === "number") seen.set(`${width}x${height}`, node)
+      },
+      "Program:exit"(program) {
+        for (const size of VIEWPORTS) if (!seen.has(size)) context.report({ node: program, messageId: "missing", data: { size } })
+        for (const [size, node] of seen) if (!VIEWPORTS.includes(size)) context.report({ node, messageId: "extra", data: { size } })
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "e2e-spec-location": e2eSpecLocation,
+  "e2e-no-absolute-path": e2eNoAbsolutePath,
+  "e2e-no-docker": e2eNoDocker,
+  "e2e-no-cross-repo-write": e2eNoCrossRepoWrite,
+  "e2e-no-skip": e2eNoSkip,
+  "e2e-typed-helpers": e2eTypedHelpers,
+  "playwright-viewports": playwrightViewports,
+}
+
+/** Which tree these rules govern: the factory attaches them to `e2e/**`, not to `src/**`. */
+export const scope = "e2e"
+
+/** Every rule is an error. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/env-owner.mjs

@@ -0,0 +1,134 @@
+/**
+ * The rules that hold `env-owner.md` (HFS R49, `FE_ENV_OWNER`).
+ *
+ * TWO FACTS, ONE OWNER. The environment is read in exactly one place, `modules/config`, and what it
+ * reads has no default that stands in for a real deployment value. They are one law because they
+ * fail together: an app with nine copies of `process.env.API_URL ?? "http://localhost:3068"` had
+ * nine readers and nine silent defaults, so a production build with the variable missing talked to
+ * a developer's laptop and looked healthy.
+ *
+ * The rules cannot see whether `modules/config` throws when a variable is missing in production -
+ * that is a behaviour, and the module's own spec is where it is proven. What they hold is the
+ * shape that makes it provable: one reader, and no literal fallback next to it.
+ */
+
+import { isConfigModule, isSpecFile } from "./lib/scope.mjs"
+
+/** `process.env`, or `import.meta.env`. */
+const isEnvObject = (node) => {
+  if (!node || node.type !== "MemberExpression" || node.computed) return false
+  const name = node.property && node.property.name
+  if (name !== "env") return false
+  const object = node.object
+  if (object.type === "Identifier" && object.name === "process") return true
+  return (
+    object.type === "MetaProperty" && object.meta.name === "import" && object.property.name === "meta"
+  )
+}
+
+/** The variable name of `process.env.NAME` / `process.env["NAME"]`, or null. */
+const envVariableName = (node) => {
+  if (!node || node.type !== "MemberExpression" || !isEnvObject(node.object)) return null
+  if (!node.computed && node.property.type === "Identifier") return node.property.name
+  if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
+    return node.property.value
+  }
+  return null
+}
+
+/** Static text of a literal or an expression-free template, else null. */
+const staticText = (node) => {
+  if (!node) return null
+  if (node.type === "Literal" && typeof node.value === "string") return node.value
+  if (node.type === "TemplateLiteral") {
+    return node.quasis.map((quasi) => quasi.value.cooked ?? "").join("")
+  }
+  return null
+}
+
+/** An absolute or protocol-relative URL: what a fallback must never carry. */
+const URL_TEXT = /^(?:https?:)?\/\/\S+/i
+
+/** Variable names whose value is a secret or an address: a default for one is a hole in a deployment. */
+const SENSITIVE_NAME = /(?:SECRET|TOKEN|PASSWORD|PASSWD|API_?KEY|PRIVATE_?KEY|URL|URI|HOST|ENDPOINT|ORIGIN)$/i
+
+// -- FE-ENV-1 --------------------------------------------------------------------------------------
+
+/** Only `modules/config` reads the environment. */
+export const noEnvOutsideConfig = {
+  meta: {
+    type: "problem",
+    docs: { description: "`process.env` and `import.meta.env` are read only in `modules/config`." },
+    schema: [],
+    messages: {
+      env:
+        "This file reads the environment. Only `modules/config` may: it is the one place that can fail loudly when a production variable is missing. Read the value from the config module's typed export instead.",
+    },
+  },
+  create(context) {
+    const filename = context.filename || context.getFilename()
+    if (isConfigModule(filename) || isSpecFile(filename)) return {}
+    return {
+      MemberExpression(node) {
+        if (isEnvObject(node)) context.report({ node, messageId: "env" })
+      },
+      VariableDeclarator(node) {
+        // `const { env } = process` reads the environment without the member expression.
+        if (node.id.type !== "ObjectPattern" || !node.init) return
+        if (node.init.type !== "Identifier" || node.init.name !== "process") return
+        const reads = node.id.properties.some(
+          (property) => property.type === "Property" && property.key.type === "Identifier" && property.key.name === "env",
+        )
+        if (reads) context.report({ node, messageId: "env" })
+      },
+    }
+  },
+}
+
+// -- FE-ENV-2 --------------------------------------------------------------------------------------
+
+/** A fallback never stands in for a deployment address or secret. */
+export const noHardcodedEndpointFallback = {
+  meta: {
+    type: "problem",
+    docs: { description: "No URL literal as a fallback, and no literal default for an address or secret variable." },
+    schema: [],
+    messages: {
+      url:
+        "A URL literal used as a fallback (`?? \"http://...\"`, `|| \"http://...\"` or a parameter default). A missing variable then silently points production at a developer's machine. Read the address from `modules/config`, which throws when it is absent.",
+      variable:
+        "`{{name}}` is an address or secret variable with a literal default. A default here makes a misconfigured deployment look healthy. Remove the default and let `modules/config` fail loudly when it is missing.",
+    },
+  },
+  create(context) {
+    if (isSpecFile(context.filename || context.getFilename())) return {}
+    return {
+      LogicalExpression(node) {
+        if (node.operator !== "??" && node.operator !== "||") return
+        const text = staticText(node.right)
+        if (text === null) return
+        if (URL_TEXT.test(text)) {
+          context.report({ node: node.right, messageId: "url" })
+          return
+        }
+        const name = envVariableName(node.left)
+        if (name && text !== "" && SENSITIVE_NAME.test(name)) {
+          context.report({ node: node.right, messageId: "variable", data: { name } })
+        }
+      },
+      AssignmentPattern(node) {
+        const text = staticText(node.right)
+        if (text !== null && URL_TEXT.test(text)) context.report({ node: node.right, messageId: "url" })
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "no-env-outside-config": noEnvOutsideConfig,
+  "no-hardcoded-endpoint-fallback": noHardcodedEndpointFallback,
+}
+
+/** Both are exact syntactic shapes, and both are errors. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/file-layout.mjs

@@ -12,14 +12,15 @@
  * to rather than merely refusing.
  */
 
-/** Forward-slash form of a filename, so Windows paths compare like every other path. */
-const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+import { normalizePath } from "./lib/path.mjs"
 
 /** Tiers whose folder holds exactly the two halves of one surface. */
-const TWO_FILE_TIERS = /\/src\/components\/(pages|layouts)\/([^/]+)\/(.+)$/
+// `features/` is the current root for route-facing surfaces (knowledge FE-FOLDER-1); `components/` is the
+// earlier Academy layout, still accepted so existing trees stay valid.
+const TWO_FILE_TIERS = /\/src\/(?:components|features)\/(pages|layouts)\/([^/]+)\/(.+)$/
 
 /** Overlays carry a feature category between the tier and the surface. */
-const TWO_FILE_TIERS_WITH_CATEGORY = /\/src\/components\/(overlays)\/[^/]+\/([^/]+)\/(.+)$/
+const TWO_FILE_TIERS_WITH_CATEGORY = /\/src\/(?:components|features)\/(overlays)\/[^/]+\/([^/]+)\/(.+)$/
 
 /** The two halves, and the twin test of each, are the whole of what a surface folder may hold. */
 const ALLOWED_IN_SURFACE_FOLDER = /^(?:component|index|classNames)(?:\.spec)?\.tsx?$/
@@ -265,11 +266,11 @@ const ROUTE_TREE_TEST = /\.spec\.(?:tsx?|jsx?)$/
 export const routeTreeHoldsRoutesOnly = {
   meta: {
     type: "problem",
-    docs: { description: "`src/app/**` holds framework route files only; a page owner lives in `components/pages/<Name>/`." },
+    docs: { description: "`src/app/**` holds framework route files only; a page owner lives in `features/pages/<Name>/` (or the earlier `components/pages/<Name>/`)." },
     schema: [],
     messages: {
       stray:
-        "`app/{{rest}}` is not a route file. A file under `app/` names which page renders at which URL - `page`, `layout`, `loading`, `error` and their siblings are the framework's slots, and `{{basename}}` is not one of them. This is a component, so it belongs where its siblings are: `components/pages/<Name>/` for a screen, `components/blocks/<category>/<Name>/` for a domain sentence. Left here it is the one place nobody looks, and the route has quietly become a second page.",
+        "`app/{{rest}}` is not a route file. A file under `app/` names which page renders at which URL - `page`, `layout`, `loading`, `error` and their siblings are the framework's slots, and `{{basename}}` is not one of them. This is a component, so it belongs where its siblings are: `features/pages/<Name>/` for a screen, `components/blocks/<category>/<Name>/` for a domain sentence. Left here it is the one place nobody looks, and the route has quietly become a second page.",
     },
   },
   create(context) {
@@ -290,7 +291,7 @@ export const routeTreeHoldsRoutesOnly = {
 }
 
 /** The rules this law contributes to the plugin. */
-const TIER_PATH = /\/(?:src\/components|packages\/[^/]+\/src|apps\/[^/]+\/src\/(?:components\/)?)\/(leaves|composites|branches|blocks|layouts|overlays|pages)\//
+const TIER_PATH = /\/(?:src\/components|src\/features|packages\/[^/]+\/src|apps\/[^/]+\/src\/(?:components\/|features\/)?)\/(leaves|composites|branches|blocks|layouts|overlays|pages)\//
 
 function propertyName(node) {
   if (node.key?.type === "Identifier") return node.key.name
@@ -390,11 +391,103 @@ export const unitTestColocated = {
   },
 }
 
+/**
+ * The component a route slot mounts takes the slot's own name.
+ *
+ * `page.tsx` default-exports `Page`, `layout.tsx` default-exports `Layout`, and so on through
+ * the component slots. The filename already tells the framework what the file is; the export
+ * name is what the reader and the search results get, and a slot that calls its component
+ * `LandingPage` or `AuthenticationRoute` invents a second name for a file that already has a
+ * fixed one. The page OWNER - the component that draws the screen - keeps its own name and
+ * lives in `components/pages/`; the slot is a shell that mounts it, and a shell named `Page`
+ * says exactly that.
+ *
+ * `default` is deliberately absent: a parallel-route default mirrors whichever page it stands
+ * in for, so its name is a decision rather than a constant. `route`, `providers`, `globals`
+ * and the asset slots export no component and are not here.
+ */
+const ROUTE_SLOT_NAME = {
+  page: "Page",
+  layout: "Layout",
+  template: "Template",
+  loading: "Loading",
+  error: "Error",
+  "global-error": "GlobalError",
+  "not-found": "NotFound",
+}
+
+const ROUTE_SLOT_FILE = new RegExp(
+  `^(?:${Object.keys(ROUTE_SLOT_NAME).join("|")})(?:\\.[a-z-]+)?\\.tsx$`,
+)
+
+export const routeSlotFixedName = {
+  meta: {
+    type: "problem",
+    docs: { description: "A route slot file default-exports a component named after the slot." },
+    schema: [],
+    messages: {
+      wrong:
+        "`{{basename}}` default-exports `{{actual}}`. A route slot takes the slot's own name - rename it `{{expected}}` and keep the drawing in the page owner under `features/pages/` (the slot is a shell that mounts it).",
+      anonymous:
+        "`{{basename}}` default-exports an anonymous component. A route slot takes the slot's own name - `const {{expected}} = () => <Owner />` then `export default {{expected}}`.",
+      missing:
+        "`{{basename}}` has no default export. A route slot's job is to mount its component - default-export `{{expected}}`.",
+    },
+  },
+  create(context) {
+    const file = normalizePath(context.filename || context.getFilename())
+    const hit = file.match(ROUTE_TREE)
+    if (!hit) return {}
+    const basename = hit[1].slice(hit[1].lastIndexOf("/") + 1)
+    if (ROUTE_TREE_TEST.test(basename)) return {}
+    const slot = basename.match(ROUTE_SLOT_FILE)
+    if (!slot) return {}
+    const expected = ROUTE_SLOT_NAME[slot[0].split(".")[0]]
+    let seen = false
+    const report = (node, actual) =>
+      context.report({
+        node,
+        messageId: actual === null ? "anonymous" : "wrong",
+        data: { basename, actual: actual ?? "(anonymous)", expected },
+      })
+    return {
+      ExportDefaultDeclaration(node) {
+        seen = true
+        const declaration = node.declaration
+        if (declaration.type === "Identifier") {
+          if (declaration.name !== expected) report(node, declaration.name)
+          return
+        }
+        if (
+          (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") &&
+          declaration.id
+        ) {
+          if (declaration.id.name !== expected) report(node, declaration.id.name)
+          return
+        }
+        report(node, null)
+      },
+      ExportNamedDeclaration(node) {
+        for (const specifier of node.specifiers || []) {
+          if (specifier.exported?.name !== "default") continue
+          seen = true
+          const local = specifier.local?.name ?? null
+          if (local !== expected) report(node, local)
+        }
+      },
+      "Program:exit"(node) {
+        if (!seen) context.report({ node, messageId: "missing", data: { basename, expected } })
+      },
+    }
+  },
+}
+
 export const rules = {
   "no-shell-tier": noShellTier,
   "source-tier-marker-matches-folder": sourceTierMarkerMatchesFolder,
   "surface-folder-two-files-only": surfaceFolderTwoFilesOnly,
   "route-tree-holds-routes-only": routeTreeHoldsRoutesOnly,
+  "route-slot-fixed-name": routeSlotFixedName,
   "no-helper-folder-in-components": noHelperFolderInComponents,
   "export-matches-folder": exportMatchesFolder,
   "no-runtime-namespace": noRuntimeNamespace,