@starci/eslint-canon-fe 1.4.5 → 3.0.0

package/README.md

@@ -1,86 +1,38 @@
-# @starci/eslint-canon-fe
-
-**58 ESLint rules, from 16 laws, that hold a React front end to one way of being written.**
-
-Not a style pack. These rules enforce *architecture*: which tier a component belongs to, whether
-structure may be typed as a raw class string, where a vendor primitive may be imported, which file
-is allowed to fetch. Prettier decides how code looks; this decides what it is allowed to be.
-
-```bash
-npm i -D @starci/eslint-canon-fe
-```
-
-## Use it
-
-One block in `eslint.config.mjs`. It attaches every rule at the severity the canon asks for, and
-makes inline disable comments ineffective rather than merely discouraged.
-
-```js
-import starciFe, {
-    recommended,
-    linterOptions,
-    starciFeConfig,
-} from "@starci/eslint-canon-fe"
-
-export default [
-    // …your own ignores, language options and other plugins…
-    starciFeConfig({
-        layout: "single-app",       // or "monorepo"
-        plugin: starciFe,
-        recommended,
-        linterOptions,
-    }),
-]
-```
-
-`layout` is the one thing a repository owns. `single-app` governs `src/**`; `monorepo` governs
-`packages/ui/src/**` and `apps/*/src/**`. **Which globs the law applies to is your fact. What the
-law says is not** — so there is no option to switch a rule off or lower it to a warning.
-
-Prefer to wire it by hand? Every piece is exported: `rules`, `recommended`, `linterOptions`,
-`ruleOwners`, `audits`, `auditOwners`, `lawOwners`.
-
-## What it actually catches
-
-A sample, not the list:
-
-| Rule | What it stops |
-|---|---|
-| `no-literal-structural-class` | Layout classes typed straight onto an element instead of named in the contract registry |
-| `no-unknown-contract-key` | A structure key that no registry entry declares |
-| `presentational-purity` | A drawing component that fetches, so it can never be rendered from a test |
-| `connected-block-has-presentational-twin` | A block wired to data with no pure half to render |
-| `no-vendor-icon-outside-icon-leaf` | A vendor glyph imported anywhere but the one leaf that wraps it |
-| `no-arbitrary-value` · `no-fractional-step` | Values off the spacing scale, invented per call site |
-| `no-resting-twin-component` | A hand-kept skeleton tree that drifts from the thing it stands in for |
-| `no-inline-lint-config` | A disable comment switching the architecture off for one line |
-| `require-export-jsdoc` | An exported symbol with no stated reason to exist |
-| `no-second-language-in-source` | Copy hardcoded where the translation layer should own it |
-
-Every rule names the law that declares it — `ruleOwners` maps rule name to law, so a failing build
-line leads straight to the document that explains why.
-
-## Why the rules are all errors
-
-Existing debt gets fixed before adoption. Lowering architecture to `warn` teaches every later author
-that the boundary is optional, and a boundary everyone learns is optional is not a boundary. There
-is no staged rollout mode, on purpose.
-
-## Companion
-
-- **[@starci/eslint-canon-be](https://www.npmjs.com/package/@starci/eslint-canon-be)** — the
-  back-end half: 37 rules from 15 laws covering CQRS, exceptions, transport, observability and
-  end-to-end flows.
-
-## Where the laws live
-
-Each rule is the enforceable half of a written law. The prose — why the rule exists, what it
-refuses, which cases sit just outside it — is published openly at
-[starci183/starci-claude-skills](https://github.com/starci183/starci-claude-skills).
-
-A rule that cannot be pointed at in real code is a proposal, not a law. Everything here is
-pointed at.
-
-## Requirements
-
-ESLint 9+ (flat config), Node 20.9+.
+# @starci/eslint-canon-fe
+
+The StarCi front-end lint canon for traditional React and TypeScript applications. It keeps
+component ownership, accessibility, loading behavior, vendor boundaries, translations, naming,
+and colocated class-name composition consistent without prescribing a custom rendering protocol.
+
+```bash
+npm i -D @starci/eslint-canon-fe
+```
+
+```js
+import starciFe, { recommended, linterOptions, starciFeConfig } from "@starci/eslint-canon-fe"
+
+export default [starciFeConfig({
+  layout: "single-app",
+  plugin: starciFe,
+  recommended,
+  linterOptions,
+})]
+```
+
+The `single-app` layout governs `src/**`; `monorepo` governs shared package and app source trees.
+The package publishes the plugin, recommended levels, repository audits, and layout helper from
+the root entry point.
+
+## Rules
+
+Rules cover comments, file layout, icons and vendor ownership, landmarks, loading states, naming,
+props, served locales, component splits, design tokens, translations, type safety, typography, and
+class-name ownership. Reusable class names belong in a colocated `classNames.ts` module and should
+be composed with HeroUI `cn` using one utility token per argument.
+
+Grammar is a business-neutral HeroUI-backed component package. Its components accept ordinary
+typed React props and children.
+
+## Requirements
+
+ESLint 9+ (flat config) and Node.js 20.9+.

package/class-names.mjs

@@ -0,0 +1,145 @@
+/**
+ * The classNames law: component markup consumes named styling declarations, while colocated
+ * classNames files own the utility-token composition.
+ */
+
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+const isComponentSource = (filename) => normalizePath(filename).includes("/src/components/")
+const isClassNamesFile = (filename) => /\/classNames\.tsx?$/.test(normalizePath(filename))
+const isClassAttribute = (node) => node.type === "JSXAttribute" && ["className", "class"].includes(node.name?.name)
+const isCn = (node) => node?.type === "Identifier" && node.name === "cn"
+
+const importedClassNames = (context) => {
+  const imports = new Set()
+  for (const statement of context.getSourceCode().ast.body) {
+    if (statement.type !== "ImportDeclaration" || statement.source.value !== "./classNames") continue
+    for (const specifier of statement.specifiers) imports.add(specifier.local.name)
+  }
+  return imports
+}
+
+const isExportedOwner = (node) => {
+  let current = node
+  while (current) {
+    if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(current.type)) {
+      current = current.parent
+      if (current?.type === "VariableDeclarator") current = current.parent
+      if (current?.type === "VariableDeclaration") current = current.parent
+      return ["ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(current?.type)
+    }
+    if (current.type === "VariableDeclarator") {
+      current = current.parent?.parent
+      return ["ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(current?.type)
+    }
+    current = current.parent
+  }
+  return false
+}
+
+const visitTokenLeaves = (node, report) => {
+  if (!node) return
+  if (node.type === "ArrayExpression") {
+    report(node, "array")
+    return
+  }
+  if (node.type === "Literal" && typeof node.value === "string") {
+    if (/\s/.test(node.value) || /\d+,\d+/.test(node.value)) report(node, "token")
+    return
+  }
+  if (node.type === "ConditionalExpression" || node.type === "LogicalExpression") {
+    visitTokenLeaves(node.consequent ?? node.left, report)
+    visitTokenLeaves(node.alternate ?? node.right, report)
+  }
+}
+
+const isEmptyClassName = (node) => node?.type === "Literal" && node.value === null || node?.type === "Identifier" && node.name === "undefined"
+
+const usesImportedClassName = (node, imported) => {
+  if (!node) return false
+  if (node.type === "Identifier") return imported.has(node.name) || node.name === "undefined"
+  if (isEmptyClassName(node)) return true
+  if (node.type === "CallExpression") return node.callee.type === "Identifier" && imported.has(node.callee.name)
+  if (node.type === "MemberExpression") return node.object.type === "Identifier" && imported.has(node.object.name)
+  if (node.type === "ConditionalExpression") return usesImportedClassName(node.consequent, imported) && usesImportedClassName(node.alternate, imported)
+  if (node.type === "LogicalExpression") {
+    if (node.operator === "&&") return usesImportedClassName(node.right, imported)
+    return usesImportedClassName(node.left, imported) && usesImportedClassName(node.right, imported)
+  }
+  return false
+}
+
+/** Report className values written directly in component JSX. */
+export const noInlineClassName = {
+  meta: {
+    type: "problem",
+    docs: { description: "Component JSX must import a named className declaration." },
+    schema: [],
+    messages: { inline: "Move this className value to an imported colocated classNames.ts export." },
+  },
+  create(context) {
+    if (!isComponentSource(context.filename || context.getFilename())) return {}
+    const imported = importedClassNames(context)
+    return {
+      JSXAttribute(node) {
+        if (!isClassAttribute(node) || !node.value) return
+        const expression = node.value.type === "JSXExpressionContainer" ? node.value.expression : node.value
+        if (!usesImportedClassName(expression, imported)) context.report({ node, messageId: "inline" })
+      },
+    }
+  },
+}
+
+/** Require every classNames declaration to use the colocated classNames.ts convention. */
+export const classNamesInColocatedFile = {
+  meta: {
+    type: "problem",
+    docs: { description: "Reusable className declarations belong in colocated classNames.ts files." },
+    schema: [],
+    messages: { misplaced: "Put reusable className declarations in a colocated classNames.ts file." },
+  },
+  create(context) {
+    const filename = context.filename || context.getFilename()
+    if (!isComponentSource(filename)) return {}
+    return {
+      CallExpression(node) {
+        if (!isCn(node.callee) || isClassNamesFile(filename)) return
+        context.report({ node, messageId: "misplaced" })
+      },
+    }
+  },
+}
+
+/** Require variadic cn utility tokens: no arrays, whitespace-packed values, or fractional commas. */
+export const cnArgumentsAreSingleTokens = {
+  meta: {
+    type: "problem",
+    docs: { description: "Each cn argument is one valid utility token." },
+    schema: [],
+    messages: {
+      array: "Pass utility tokens to cn as variadic arguments, not an array.",
+      token: "Each cn argument must be one utility token without whitespace or malformed fractional commas.",
+      unexported: "Export every className declaration or function that produces a cn value.",
+    },
+  },
+  create(context) {
+    const filename = context.filename || context.getFilename()
+    if (!isClassNamesFile(filename)) return {}
+    return {
+      CallExpression(node) {
+        if (!isCn(node.callee)) return
+        if (!isExportedOwner(node)) context.report({ node, messageId: "unexported" })
+        for (const argument of node.arguments) visitTokenLeaves(argument, (reportedNode, messageId) => context.report({ node: reportedNode, messageId }))
+      },
+    }
+  },
+}
+
+/** Every rule this law publishes. */
+export const rules = {
+  "no-inline-class-name": noInlineClassName,
+  "class-names-in-colocated-file": classNamesInColocatedFile,
+  "cn-arguments-are-single-tokens": cnArgumentsAreSingleTokens,
+}
+
+/** Recommended severity for the classNames law. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/file-layout.mjs

@@ -22,7 +22,7 @@ const TWO_FILE_TIERS = /\/src\/components\/(pages|layouts)\/([^/]+)\/(.+)$/
 const TWO_FILE_TIERS_WITH_CATEGORY = /\/src\/components\/(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)(?:\.spec)?\.tsx?$/
+const ALLOWED_IN_SURFACE_FOLDER = /^(?:component|index|classNames)(?:\.spec)?\.tsx?$/
 
 /** Folders that are not component code, whatever they are nested inside. */
 const NON_COMPONENT_FOLDERS = /\/src\/components\/.*\/(constants|utils|types|hooks)\//
@@ -36,7 +36,7 @@ const surfaceFolder = (filename) => {
 
 // -- FILE-2 --------------------------------------------------------------------------------------
 
-/** A page, layout or overlay folder holds its two halves and nothing else. */
+/** A page, layout or overlay folder holds its two halves and its colocated class-name module. */
 export const surfaceFolderTwoFilesOnly = {
   meta: {
     type: "problem",
@@ -44,7 +44,7 @@ export const surfaceFolderTwoFilesOnly = {
     schema: [],
     messages: {
       extra:
-        "`{{tier}}/{{name}}/` contains `{{rest}}` - a surface folder holds its two halves ONLY (`component.tsx` is the shape, `index.tsx` is the wiring). Whatever this is, it has a real home: a component of its own goes to `blocks/<category>/`, a closed arrangement to `composites/`, a fetch to `hooks/`, a pure helper to `modules/utils/`, a shape to `modules/types/`, copy or a config map to `resources/`. \"Only this screen uses it\" is how a folder becomes a second codebase.",
+        "`{{tier}}/{{name}}/` contains `{{rest}}` - a surface folder holds `component.tsx`, `index.tsx`, and an optional `classNames.ts`. Whatever else this is has a real home: a component of its own goes to `blocks/<category>/`, a closed arrangement to `composites/`, a fetch to `hooks/`, a pure helper to `modules/utils/`, a shape to `modules/types/`, copy or a config map to `resources/`.",
     },
   },
   create(context) {
@@ -164,7 +164,7 @@ export const noRuntimeNamespace = {
 const FEATURE_TIERS = /\/packages\/[^/]+\/src\/(blocks|overlays|pages|layouts)\//
 
 /** Tiers that know no feature, and therefore belong to the shared package. */
-const VOCABULARY_TIERS = /\/apps\/[^/]+\/src\/(?:components\/)?(contracts|leaves|composites|branches)\//
+const VOCABULARY_TIERS = /\/apps\/[^/]+\/src\/(?:components\/)?(leaves|composites|branches)\//
 
 /**
  * In a monorepo, the shared package stops below the block.
@@ -183,7 +183,7 @@ export const monorepoTierBelongsToItsSide = {
     type: "problem",
     docs: {
       description:
-        "In a monorepo the shared package holds contracts, leaves, composites and branches; blocks, overlays, layouts and pages belong to the app that owns the feature.",
+        "In a monorepo the shared package holds leaves, composites and branches; blocks, overlays, layouts and pages belong to the app that owns the feature.",
     },
     schema: [],
     messages: {
@@ -316,7 +316,6 @@ export const sourceTierMarkerMatchesFolder = {
       blocks: "block",
       branches: "branch",
       composites: "composite",
-      contracts: "contract",
       layouts: "layout",
       leaves: "leaf",
       overlays: "overlay",
@@ -353,7 +352,7 @@ export const noShellTier = {
     schema: [],
     messages: {
       shell:
-        "`shells/` is an untyped branch exemption. Move the owner to a named branch, replace children with typed contract content, and keep vendor mechanics closed there.",
+        "`shells/` is an untyped branch exemption. Move the owner to a named branch and keep vendor mechanics closed there.",
     },
   },
   create(context) {

package/grammar-boundary.mjs

@@ -0,0 +1,16 @@
+/**
+ * The boundary between product code and `@starci/grammar`.
+ *
+ * Grammar is a business-neutral HeroUI-backed component package. Product code may compose its
+ * components with ordinary React children and typed props; this contribution deliberately does
+ * not impose a second rendering protocol or a product-specific adapter lane.
+ */
+
+/** No product-specific AST restrictions are needed for the neutral Grammar boundary. */
+export const rules = {}
+
+/** No repository audit is coupled to the neutral Grammar boundary. */
+export const audits = {}
+
+/** The neutral boundary contributes no mandatory rule levels. */
+export const recommended = {}

package/index.mjs

@@ -13,8 +13,13 @@
  * would leave two names for one rule and no way to tell which a message came from.
  */
 import { recommended as commentsRecommended, rules as commentsRules } from "./comments.mjs"
-import { recommended as contractRecommended, rules as contractRules } from "./contract.mjs"
-import { recommended as fileLayoutRecommended, rules as fileLayoutRules } from "./file-layout.mjs"
+import { recommended as classNamesRecommended, rules as classNamesRules } from "./class-names.mjs"
+import { recommended as fileLayoutRecommended, rules as fileLayoutRules } from "./file-layout.mjs"
+import {
+  audits as grammarBoundaryAudits,
+  recommended as grammarBoundaryRecommended,
+  rules as grammarBoundaryRules,
+} from "./grammar-boundary.mjs"
 import { recommended as iconRecommended, rules as iconRules } from "./icon.mjs"
 import { recommended as landmarkRecommended, rules as landmarkRules } from "./landmark.mjs"
 import { recommended as loadingRecommended, rules as loadingRules } from "./loading.mjs"
@@ -41,8 +46,18 @@ import { recommended as vendorRecommended, rules as vendorRules } from "./vendor
 /** Each law's contribution, kept separate so a duplicate name is detectable rather than silent. */
 const CONTRIBUTIONS = [
   { law: "comments", rules: commentsRules, recommended: commentsRecommended },
-  { law: "contract", rules: contractRules, recommended: contractRecommended },
-  { law: "file-layout", rules: fileLayoutRules, recommended: fileLayoutRecommended },
+  {
+    law: "class-names",
+    rules: classNamesRules,
+    recommended: classNamesRecommended,
+  },
+  { law: "file-layout", rules: fileLayoutRules, recommended: fileLayoutRecommended },
+  {
+    law: "grammar-boundary",
+    rules: grammarBoundaryRules,
+    recommended: grammarBoundaryRecommended,
+    audits: grammarBoundaryAudits,
+  },
   { law: "icon", rules: iconRules, recommended: iconRecommended },
   { law: "landmark", rules: landmarkRules, recommended: landmarkRecommended },
   { law: "loading", rules: loadingRules, recommended: loadingRecommended },

package/landmark.mjs

@@ -1,242 +1,29 @@
-/**
- * Rules for the LANDMARK law - `patterns/fe/landmark/INDEX.md`.
- *
- * WHY THESE EXIST. A registry makes the failure silent. A key named `dashboard-main` records the
- * intent exactly and renders a `div`, because the branch that draws registry nodes draws divs. An
- * application shipped with every region correctly named and not one landmark in the document, and
- * no gate had anything to say: a name in a key is not an element in a document.
- *
- * WHAT THEY HOLD, as two halves of one idea. A route layout that composes its own chrome must hand
- * the routed children to the landmark branch; and that branch may appear only in a ROUTE file,
- * because a second `main` is an ambiguous landmark rather than a stronger one.
- *
- * WHAT THEY CANNOT HOLD, stated rather than implied. A file-at-a-time rule cannot see that a layout
- * and a page under it BOTH opened a landmark. The rules narrow the place to route files and refuse
- * every tier below, which is where the mistake actually happens - a reading column named `*-main`
- * drawn with the landmark branch. The remaining cross-file case is a review question, and pretending
- * otherwise would be the rule claiming a guarantee it does not have.
- *
- * WHY THE `Tree` TEST IS PART OF THE FIRST RULE. Without it the rule fires on every layout that
- * touches `children`, including the root document shell and pass-through layouts that delegate
- * their chrome - and satisfying it there would put the second `main` in the document that the
- * companion rule refuses. The bluntness was real, was measured, and is the reason the condition is
- * narrower than "renders children".
- */
-
-import { contractHostOf } from "./contract.mjs"
-
-/** Forward-slash form of a filename, so Windows paths compare like every other path. */
-const normalize = (filename) => String(filename || "").replace(/\\/g, "/")
-
-/** A route layout: `layout.tsx` anywhere under an `app/` router directory. */
-export const isRouteLayoutFile = (filename) => /\/app\/(?:.*\/)?layout\.tsx$/.test(normalize(filename))
-
-/**
- * A route file: the layout OR the page of a route.
- *
- * WHY BOTH. The landmark belongs to the outermost file that composes the routed screen, and that is
- * not always a layout. A route with no chrome-composing layout - a scaffold, a standalone screen -
- * has its page as the outermost composer, and forcing the mark upward would mean inventing a layout
- * whose only job is to wrap. That was not a hypothetical: an early version of this rule allowed only
- * layouts, and it refused three route pages that were each the sole composer of their screen and
- * each held exactly one `main`.
- */
-export const isRouteFile = (filename) => /\/app\/(?:.*\/)?(?:layout|page)\.tsx$/.test(normalize(filename))
-
-/**
- * A page tier file: either half of a surface under `components/pages/<Name>/`.
- *
- * WHY THE PAGE TIER OWNS THE MARK TOO, AND WHY THIS WAS NOT ALWAYS TRUE.
- *
- * The landmark used to be a named branch, so "the outermost file that composes the screen" and "a
- * file under `app/`" were the same sentence — the branch was imported into the route file and that
- * was that. Then the mark moved into the contract entry as `host: "main"`, and the two sentences
- * came apart: the entry is rendered by whoever renders the screen's outermost frame, and FILE-6
- * says that is emphatically NOT the route file. A route names which page renders at which URL and
- * draws nothing.
- *
- * Held to route files only, the two laws then refused each other. Every page moved out of `app/` to
- * satisfy FILE-6 was reported for misplacing its landmark, and the only way to satisfy both at
- * once was to leave the page owner in the routing tree — which is the defect FILE-6 exists to
- * prevent. A rule that can only be satisfied by breaking another rule is a finding about the rule.
- *
- * What the guarantee actually was, and still is: ONE main per document, owned by whoever owns the
- * whole screen. A route file and a page component are both that. A block, composite, leaf, branch,
- * overlay or shared layout is not, and each of those still reports — which is the case this rule was
- * written for, because a landmark added there is a SECOND main rather than a stronger one.
- */
-export const isPageTierFile = (filename) =>
-  /\/components\/pages\/[A-Z][A-Za-z0-9]*\/(?:index|component)\.tsx$/.test(normalize(filename))
-
-/** The branches that open a landmark element. One per element, by LANDMARK-1. */
-export const LANDMARK_BRANCHES = new Set(["Main"])
-
-/** The branch that composes an ordinary registry node, and therefore marks a layout as chrome-owning. */
-const TREE_BRANCH = "Tree"
-
-/**
- * The contract key a frame element is rendering, when it names one literally.
- *
- * @param node - A JSX opening element.
- * @returns The key, or null when the element takes no literal `contract`.
- */
-const contractKeyOf = (node) => {
-  const attribute = (node.attributes || []).find(
-    (candidate) => candidate.type === "JSXAttribute" && candidate.name && candidate.name.name === "contract",
-  )
-  const value = attribute && attribute.value
-  return value && value.type === "Literal" && typeof value.value === "string" ? value.value : null
-}
-
-/**
- * True when this element draws a landmark.
- *
- * TWO SHAPES, AND THE SECOND IS THE ONE THAT LASTS. A landmark used to be a named branch, so this
- * asked for the name. The element now belongs to the contract entry - `host: "main"` - which is
- * why a repository can delete its `Main` branch entirely and still have exactly one main landmark:
- * the frame reads the host from the key. Asking only for the branch name reported those repositories
- * as having no landmark at all, which is the opposite of what they had done.
- *
- * @param node - A JSX opening element.
- * @param filename - The file being linted, used to locate the contract table.
- */
-const isLandmarkElement = (node, filename) =>
-  isLandmarkBranchElement(node) || isHostMainFrame(node, filename)
-
-/**
- * True when this element is a landmark BRANCH, named directly.
- *
- * @param node - A JSX opening element.
- */
-const isLandmarkBranchElement = (node) =>
-  node.type === "JSXOpeningElement"
-  && node.name
-  && node.name.type === "JSXIdentifier"
-  && LANDMARK_BRANCHES.has(node.name.name)
-
-/**
- * True when this element is an ordinary frame whose CONTRACT ENTRY declares the landmark.
- *
- * @param node - A JSX opening element.
- * @param filename - The file being linted, used to locate the contract table.
- */
-const isHostMainFrame = (node, filename) => {
-  if (node.type !== "JSXOpeningElement" || !node.name || node.name.type !== "JSXIdentifier") return false
-  if (LANDMARK_BRANCHES.has(node.name.name)) return false
-  const key = contractKeyOf(node)
-  return key !== null && contractHostOf(filename, key) === "main"
-}
-
-/**
- * True when this file is a landmark branch's own implementation.
- *
- * That file draws the element by hand and must: it is the one place the element is allowed to
- * appear, exactly as `Tree` is the one place a `div` is.
- *
- * @param filename - The file being linted.
- */
-const isLandmarkBranchFile = (filename) =>
-  [...LANDMARK_BRANCHES].some((name) => new RegExp(`/branches/${name}/`).test(normalize(filename)))
-
-export const rules = {
-  "routed-page-is-a-main-landmark": {
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "A route layout that composes its own chrome must wrap the routed children in the Main branch, so the page is a landmark a reader can skip to.",
-      },
-      schema: [],
-      messages: {
-        missing:
-          "This layout composes the page chrome but never marks the routed page. Wrap `children` in the `Main` branch so assistive technology can skip the navigation to reach the page - a registry key named `*-main` is a name, not a landmark.",
-      },
-    },
-    create(context) {
-      const filename = context.filename || context.getFilename()
-      if (!isRouteLayoutFile(filename)) return {}
-      let rendersChildren = false
-      let composesChrome = false
-      let usesLandmark = false
-      let firstNode = null
-      return {
-        JSXExpressionContainer(node) {
-          if (node.expression && node.expression.type === "Identifier" && node.expression.name === "children") {
-            rendersChildren = true
-            firstNode = firstNode || node
-          }
-        },
-        Identifier(node) {
-          // `children` reaches the tree through a slot callback as often as through JSX, so the
-          // bare identifier counts too - otherwise a layout escapes by handing it to a builder.
-          if (node.name === "children" && node.parent && node.parent.type !== "Property") {
-            rendersChildren = true
-            firstNode = firstNode || node
-          }
-        },
-        JSXOpeningElement(node) {
-          if (isLandmarkElement(node, filename)) usesLandmark = true
-          if (node.name && node.name.type === "JSXIdentifier" && node.name.name === TREE_BRANCH) {
-            composesChrome = true
-            firstNode = firstNode || node
-          }
-        },
-        "Program:exit"(node) {
-          if (rendersChildren && composesChrome && !usesLandmark) {
-            context.report({ node: firstNode || node, messageId: "missing" })
-          }
-        },
-      }
-    },
-  },
-
-  "main-landmark-belongs-to-a-route-file": {
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "The Main branch draws the document's one main landmark, so it belongs to the route file that composes the screen and nowhere below it.",
-      },
-      schema: [],
-      messages: {
-        misplaced:
-          "This draws the document's ONE main landmark, so it belongs to whoever owns the whole screen - the route's `layout.tsx` or `page.tsx`, or the page surface under `components/pages/<Name>/`. Used here it puts a second `main` in the document, which is an ambiguous landmark rather than a stronger one - a registry key named `*-main` inside a block or composite is a reading column, and its entry must not declare `host: \"main\"`.",
-      },
-    },
-    /*
-     * TWO SHAPES, TWO DIFFERENT SETS OF FILES THAT MAY HOLD THEM, and collapsing them was the bug.
-     *
-     * The `Main` BRANCH is a component somebody imports in order to wrap a screen. It belongs to the
-     * route file that composes that screen and nowhere below - a page reaching for it is the trap
-     * this law was written for, because the thing it wraps is a reading COLUMN and the document then
-     * has two mains.
-     *
-     * A frame whose CONTRACT ENTRY declares `host: "main"` is not that. Nobody imported a landmark;
-     * the registry says which element this key's node opens, and the frame obeys. That entry is
-     * rendered by whoever renders the screen's outermost node - and FILE-6 says the route file is
-     * emphatically not it, because a route mounts a page and draws nothing. Holding both shapes to
-     * route files only made the two laws refuse each other, and the only way to satisfy both was to
-     * leave the page owner in the routing tree, which is the defect FILE-6 exists to prevent.
-     */
-    create(context) {
-      const filename = context.filename || context.getFilename()
-      if (isLandmarkBranchFile(filename)) return {}
-      const isRoute = isRouteFile(filename)
-      const isPageTier = isPageTierFile(filename)
-      return {
-        JSXOpeningElement(node) {
-          if (isLandmarkBranchElement(node)) {
-            if (!isRoute) context.report({ node, messageId: "misplaced" })
-            return
-          }
-          if (isHostMainFrame(node, filename) && !isRoute && !isPageTier) {
-            context.report({ node, messageId: "misplaced" })
-          }
-        },
-      }
-    },
-  },
-}
-
-/** Every FE canon rule is an error; see `sources/fe/index.mjs` for why there is no warn tier. */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))
+/**
+ * Accessibility landmarks for ordinary React route composition.
+ *
+ * Native HTML landmarks are intentionally independent of component implementation details. The
+ * application may pass children through layouts and pages normally.
+ */
+
+const normalize = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** Whether a file is a Next route layout. */
+export const isRouteLayoutFile = (filename) => /\/app\/(?:.*\/)?layout\.tsx$/.test(normalize(filename))
+
+/** Whether a file is a Next route entry. */
+export const isRouteFile = (filename) => /\/app\/(?:.*\/)?(?:layout|page)\.tsx$/.test(normalize(filename))
+
+/** Whether a file owns a page component. */
+export const isPageTierFile = (filename) => /\/src\/components\/pages\//.test(normalize(filename))
+
+/** Named branch owners that may provide landmark semantics. */
+export const LANDMARK_BRANCHES = new Set(["Main"])
+
+/** No custom landmark AST rule is needed; semantic ownership is enforced by the component code. */
+export const rules = {}
+
+/** No repository audit is coupled to landmark ownership. */
+export const audits = {}
+
+/** The landmark contribution has no mandatory rule levels. */
+export const recommended = {}