@starci/eslint-canon-fe 3.0.2 → 4.0.0

package/README.md

@@ -30,6 +30,13 @@ props, served locales, component splits, design tokens, translations, type safet
 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.
 
+The `shape-slot` law holds the split surfaces (blocks, pages, layouts, overlays under `components/`
+or `features/`): the pure `XBase` takes `{ state, props, on }` of atoms (`base-props-atom`), only its
+sibling `index.tsx` imports it and never re-exports it (`base-import-pair`), `XState` names drawn
+shapes and never a data status (`no-data-status-shape`), and a block renders each slot's
+loading/forbidden/error/empty through `SlotView` (`slot-status-through-slotview`). Reference tree:
+`.claude/examples/shape-slot`.
+
 Grammar is a business-neutral HeroUI-backed component package. Its components accept ordinary
 typed React props and children.
 

package/file-layout.mjs

@@ -16,10 +16,12 @@
 const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
 
 /** 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 +267,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 +292,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 +392,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,

package/index.mjs

@@ -36,6 +36,7 @@ import {
 import { recommended as namingRecommended, rules as namingRules } from "./naming.mjs"
 import { recommended as propsRecommended, rules as propsRules } from "./props-and-slots.mjs"
 import { recommended as servedLocaleRecommended, rules as servedLocaleRules } from "./served-locale.mjs"
+import { recommended as shapeSlotRecommended, rules as shapeSlotRules } from "./shape-slot.mjs"
 import { recommended as splitRecommended, rules as splitRules } from "./the-split.mjs"
 import { recommended as tokensRecommended, rules as tokensRules } from "./tokens.mjs"
 import { recommended as translationRecommended, rules as translationRules } from "./translation.mjs"
@@ -71,6 +72,7 @@ const CONTRIBUTIONS = [
   { law: "naming", rules: namingRules, recommended: namingRecommended },
   { law: "props-and-slots", rules: propsRules, recommended: propsRecommended },
   { law: "served-locale", rules: servedLocaleRules, recommended: servedLocaleRecommended },
+  { law: "shape-slot", rules: shapeSlotRules, recommended: shapeSlotRecommended },
   { law: "the-split", rules: splitRules, recommended: splitRecommended },
   { law: "tokens", rules: tokensRules, recommended: tokensRecommended },
   { law: "translation", rules: translationRules, recommended: translationRecommended },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-fe",
-  "version": "3.0.2",
+  "version": "4.0.0",
   "description": "The StarCi front-end lint canon: every rule its laws publish, gathered as one flat-config plugin.",
   "type": "module",
   "license": "UNLICENSED",
@@ -33,4 +33,4 @@
     "starci",
     "canon"
   ]
-}
+}

package/props-and-slots.mjs

@@ -47,7 +47,7 @@ const componentNameOf = (node) => {
 export const publicComponentSignature = {
   meta: {
     type: "problem",
-    docs: { description: "Exported React components use one parameter named props with a matching XProps type." },
+    docs: { description: "Exported React components use one parameter named props with a matching XProps type (XBase may also take XBaseProps)." },
     schema: [],
     messages: {
       parameter: "Exported component {{name}} must be an arrow const with exactly one parameter named props.",
@@ -63,7 +63,9 @@ export const publicComponentSignature = {
         return
       }
       const type = params[0].typeAnnotation?.typeAnnotation
-      const expected = [name.endsWith("Base") ? `${name.slice(0, -4)}Props` : `${name}Props`]
+      // XBase pairs with XBaseProps so the connected X keeps XProps for itself; XProps stays accepted for
+      // existing twins.
+      const expected = name.endsWith("Base") ? [`${name}Props`, `${name.slice(0, -4)}Props`] : [`${name}Props`]
       const actual = type?.type === "TSTypeReference" && type.typeName?.type === "Identifier" ? type.typeName.name : null
       if (!actual || !expected.includes(actual)) context.report({ node: params[0], messageId: "type", data: { name, expected: expected.join(" or ") } })
     }

package/shape-slot.mjs

@@ -0,0 +1,340 @@
+/**
+ * The rules that hold the shape-slot law (example: examples/shape-slot).
+ *
+ * TWO AXES, AND ONLY ONE IS DRAWN. A surface's `state` is its SHAPE: a layout the owner approves as
+ * one drawing. A slot's data status (loading, forbidden, error, empty) is not a shape; it is a
+ * recipe applied per api through `SlotView`, and it is never drawn. Mixing the two is what made
+ * every block ship four hand-drawn variants that disagreed with each other.
+ *
+ * THE PURE HALF TAKES ATOMS. `component.tsx` receives `{ state, props, on }`: `props` is data
+ * (strings, numbers, booleans, arrays, plain objects), `on` is actions whose arguments are data,
+ * and the children it renders are written inside it, never handed in. A layout alone also takes
+ * `children`, because the router puts the page there.
+ *
+ * ONLY ITS OWN INDEX MAY IMPORT IT. Other tiers use the connected export, so the pure half stays a
+ * private drawing surface that audit can render from a fixture.
+ *
+ * Every rule reads one file. Types imported from elsewhere are trusted as data; only names this
+ * file declares are followed, which is exact for the tree the convention produces and silent,
+ * never wrong, beyond it.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** The pure half of a split tier, and which tier it is. */
+const pureHalf = (filename) => {
+  const match = normalizePath(filename).match(
+    /\/src\/(?:components|features)\/(blocks|pages|layouts|overlays)\/(?:[^/]+\/)*[A-Z][A-Za-z0-9]*\/component\.tsx$/,
+  )
+  return match ? match[1] : null
+}
+
+/** Specs render the pure half from fixtures; that is the point of it. */
+const isSpec = (filename) => /\.(spec|test)\.[cm]?[jt]sx?$/.test(normalizePath(filename))
+
+/** Type names that carry a rendered tree rather than data. */
+const NON_ATOM_TYPE = /^(?:ReactNode|ReactElement|ReactPortal|JSX\.Element|Element|ComponentType|FC|FunctionComponent|ElementType|ComponentProps|RenderFunction)$/
+
+/** The printed name of a type reference, qualified names included. */
+const typeNameOf = (node) => {
+  const name = node?.typeName
+  if (!name) return ""
+  if (name.type === "Identifier") return name.name
+  if (name.type === "TSQualifiedName") return `${typeNameOf({ typeName: name.left })}.${name.right.name}`
+  return ""
+}
+
+/** Every type this file declares, by name, so references can be followed locally. */
+const collectLocalTypes = (program) => {
+  const types = new Map()
+  const visit = (statement) => {
+    const declaration = statement?.type === "ExportNamedDeclaration" ? statement.declaration : statement
+    if (declaration?.type === "TSTypeAliasDeclaration") types.set(declaration.id.name, declaration.typeAnnotation)
+    if (declaration?.type === "TSInterfaceDeclaration") types.set(declaration.id.name, declaration.body)
+  }
+  for (const statement of program.body) visit(statement)
+  return types
+}
+
+/** The members of an object-shaped type node, following local names and intersections. */
+const membersOf = (node, types, seen = new Set()) => {
+  if (!node) return []
+  if (node.type === "TSTypeLiteral") return node.members
+  if (node.type === "TSInterfaceBody") return node.body
+  if (node.type === "TSIntersectionType") return node.types.flatMap((part) => membersOf(part, types, seen))
+  if (node.type === "TSTypeReference") {
+    const name = typeNameOf(node)
+    if (seen.has(name) || !types.has(name)) return []
+    seen.add(name)
+    return membersOf(types.get(name), types, seen)
+  }
+  return []
+}
+
+/** The key a property signature declares. */
+const keyOf = (member) => (member.key?.type === "Identifier" ? member.key.name : member.key?.value)
+
+// -- SHAPE-SLOT-1 ----------------------------------------------------------------------------------
+
+/** The pure half takes `{ state, props, on }` of atoms; only a layout also takes `children`. */
+export const basePropsAtom = {
+  meta: {
+    type: "problem",
+    docs: { description: "A pure `XBase` takes `state`, atom `props` and `on` actions; no component or tree crosses in." },
+    schema: [],
+    messages: {
+      tree:
+        "`{{path}}` hands a rendered tree (`{{type}}`) into the pure half. Write the child inside `component.tsx` and pass it atoms (ids, strings, flags); a tree handed in cannot be drawn, audited or reused.",
+      action:
+        "`{{path}}` is a function inside `props`. Actions live in `on`, so `props` stays pure data that a fixture can hold.",
+      onData:
+        "`on.{{key}}` is not an action. `on` holds functions only; data belongs in `props`.",
+      member:
+        "`{{key}}` is not part of the pure contract. A pure half takes `state`, `props` and `on`{{children}}.",
+    },
+  },
+  create(context) {
+    const tier = pureHalf(context.filename || context.getFilename())
+    if (!tier) return {}
+    let types = new Map()
+
+    /** Walk a data type: report trees and functions anywhere inside it. */
+    const checkData = (node, path, seen) => {
+      if (!node) return
+      switch (node.type) {
+        case "TSFunctionType":
+          context.report({ node, messageId: "action", data: { path } })
+          return
+        case "TSTypeReference": {
+          const name = typeNameOf(node)
+          if (NON_ATOM_TYPE.test(name)) {
+            context.report({ node, messageId: "tree", data: { path, type: name } })
+            return
+          }
+          for (const argument of node.typeArguments?.params ?? node.typeParameters?.params ?? []) checkData(argument, path, seen)
+          if (types.has(name) && !seen.has(name)) {
+            seen.add(name)
+            checkData(types.get(name), path, seen)
+          }
+          return
+        }
+        case "TSUnionType":
+        case "TSIntersectionType":
+          for (const part of node.types) checkData(part, path, seen)
+          return
+        case "TSArrayType":
+          checkData(node.elementType, path, seen)
+          return
+        case "TSTypeOperator":
+          checkData(node.typeAnnotation, path, seen)
+          return
+        case "TSTypeLiteral":
+        case "TSInterfaceBody":
+          for (const member of node.members ?? node.body) {
+            if (member.type === "TSMethodSignature") {
+              context.report({ node: member, messageId: "action", data: { path: `${path}.${keyOf(member)}` } })
+            } else if (member.type === "TSPropertySignature") {
+              checkData(member.typeAnnotation?.typeAnnotation, `${path}.${keyOf(member)}`, seen)
+            }
+          }
+          return
+        default:
+      }
+    }
+
+    /** Walk `on`: every member is a function whose parameters are data. */
+    const checkActions = (node) => {
+      for (const member of membersOf(node, types)) {
+        const key = keyOf(member)
+        const type = member.type === "TSMethodSignature" ? member : member.typeAnnotation?.typeAnnotation
+        if (type?.type !== "TSFunctionType" && type?.type !== "TSMethodSignature") {
+          context.report({ node: member, messageId: "onData", data: { key } })
+          continue
+        }
+        for (const parameter of type.params ?? type.parameters ?? []) {
+          checkData(parameter.typeAnnotation?.typeAnnotation, `on.${key}(${parameter.name ?? "arg"})`, new Set())
+        }
+      }
+    }
+
+    return {
+      Program(node) {
+        types = collectLocalTypes(node)
+      },
+      VariableDeclarator(node) {
+        if (node.id?.type !== "Identifier" || !/^[A-Z][A-Za-z0-9]*Base$/.test(node.id.name)) return
+        const fn = node.init
+        if (fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression") return
+        const annotation = fn.params?.[0]?.typeAnnotation?.typeAnnotation
+        for (const member of membersOf(annotation, types)) {
+          const key = keyOf(member)
+          const type = member.typeAnnotation?.typeAnnotation
+          if (key === "state") continue
+          if (key === "props") checkData(type, "props", new Set())
+          else if (key === "on") checkActions(type)
+          else if (key === "children" && tier === "layouts") continue
+          else {
+            context.report({
+              node: member,
+              messageId: "member",
+              data: { key, children: tier === "layouts" ? ", plus the router's `children`" : "" },
+            })
+          }
+        }
+      },
+    }
+  },
+}
+
+// -- SHAPE-SLOT-2 ----------------------------------------------------------------------------------
+
+/** Only the sibling `index.tsx` (and its specs) may reach `component.tsx`; only `X` leaves the folder. */
+export const baseImportPair = {
+  meta: {
+    type: "problem",
+    docs: { description: "A pure `component.tsx` is imported only by its sibling `index.tsx`, which never re-exports `XBase`." },
+    schema: [],
+    messages: {
+      reach:
+        "`{{source}}` reaches into another surface's pure half. Import that surface's connected export from its folder; the pure half is a private drawing surface.",
+      reexport:
+        "`index.tsx` re-exports `{{name}}`. The folder exports only its connected `X`; the pure `XBase` stays behind it so no other tier can bypass the owner.",
+    },
+  },
+  create(context) {
+    const filename = normalizePath(context.filename || context.getFilename())
+    const base = filename.split("/").pop() || ""
+    const isOwnIndex = base === "index.tsx"
+    const spec = isSpec(filename)
+    const inTier = /\/src\/(?:components|features)\/(blocks|pages|layouts|overlays)\//.test(filename)
+    const reachesPure = (source) => /(?:^|\/)component(?:\.tsx)?$/.test(source)
+
+    const check = (node, source) => {
+      if (typeof source !== "string" || !reachesPure(source)) return
+      const isSibling = source === "./component" || source === "./component.tsx"
+      if (isSibling && (isOwnIndex || spec)) return
+      if (isSibling && !inTier) return
+      context.report({ node, messageId: "reach", data: { source } })
+    }
+
+    return {
+      ImportDeclaration(node) {
+        check(node, node.source?.value)
+      },
+      ExportAllDeclaration(node) {
+        check(node, node.source?.value)
+      },
+      ExportNamedDeclaration(node) {
+        const source = node.source?.value
+        if (!source) return
+        check(node, source)
+        if (!isOwnIndex || !inTier || node.exportKind === "type") return
+        for (const specifier of node.specifiers ?? []) {
+          const name = specifier.exported?.name ?? specifier.local?.name
+          if (specifier.exportKind !== "type" && /^[A-Z][A-Za-z0-9]*Base$/.test(name)) {
+            context.report({ node: specifier, messageId: "reexport", data: { name } })
+          }
+        }
+      },
+    }
+  },
+}
+
+// -- SHAPE-SLOT-3 ----------------------------------------------------------------------------------
+
+/** Words that name a data status or an open/closed lifecycle, never a drawn shape. */
+const DATA_STATUS = new Set([
+  "pending", "loading", "failed", "error", "errored", "empty", "forbidden", "unavailable",
+  "skeleton", "closed", "idle", "refreshing", "retrying",
+])
+
+/** A surface's `XState` names shapes only. */
+export const noDataStatusShape = {
+  meta: {
+    type: "problem",
+    docs: { description: "`XState` of a pure half names drawn shapes, never a data status or open/closed." },
+    schema: [],
+    messages: {
+      status:
+        "`{{name}}` lists \"{{value}}\" as a shape. Loading, forbidden, error and empty are a slot's data status: pass them as `Slot<T>` in `props` and render them through `SlotView`. Open/closed is an atom (`isOpen`). A shape is a layout the owner approves as one drawing.",
+    },
+  },
+  create(context) {
+    if (!pureHalf(context.filename || context.getFilename())) return {}
+    const check = (name, node) => {
+      const members = node?.type === "TSUnionType" ? node.types : [node]
+      for (const member of members) {
+        const value = member?.type === "TSLiteralType" ? member.literal?.value : undefined
+        if (typeof value === "string" && DATA_STATUS.has(value)) {
+          context.report({ node: member, messageId: "status", data: { name, value } })
+        }
+      }
+    }
+    return {
+      TSTypeAliasDeclaration(node) {
+        if (/^[A-Z][A-Za-z0-9]*State$/.test(node.id.name)) check(node.id.name, node.typeAnnotation)
+      },
+    }
+  },
+}
+
+// -- SHAPE-SLOT-4 ----------------------------------------------------------------------------------
+
+/** Flags that are a slot's data status. */
+const STATUS_FLAG = /^(?:isLoading|isError|isForbidden|isPending|isValidating|isEmpty)$/
+
+/** The name a test expression reads, if it is a status flag. */
+const statusFlagOf = (node) => {
+  if (!node) return null
+  if (node.type === "UnaryExpression") return statusFlagOf(node.argument)
+  if (node.type === "ChainExpression") return statusFlagOf(node.expression)
+  if (node.type === "Identifier" && STATUS_FLAG.test(node.name)) return node.name
+  if (node.type === "MemberExpression" && node.property?.type === "Identifier" && STATUS_FLAG.test(node.property.name)) {
+    return node.property.name
+  }
+  if (node.type === "LogicalExpression" || node.type === "BinaryExpression") return statusFlagOf(node.left) ?? statusFlagOf(node.right)
+  return null
+}
+
+/** A block's pure half never branches on a data status itself. */
+export const slotStatusThroughSlotView = {
+  meta: {
+    type: "problem",
+    docs: { description: "A block's pure half renders data status through `SlotView`, never its own branch." },
+    schema: [],
+    messages: {
+      branch:
+        "This branches on `{{flag}}` by hand. Every slot renders its status through `SlotView`, the one recipe: a second branch drifts from it and becomes one more variant somebody draws.",
+    },
+  },
+  create(context) {
+    if (pureHalf(context.filename || context.getFilename()) !== "blocks") return {}
+    const check = (node, test) => {
+      const flag = statusFlagOf(test)
+      if (flag) context.report({ node, messageId: "branch", data: { flag } })
+    }
+    return {
+      ConditionalExpression(node) {
+        check(node, node.test)
+      },
+      IfStatement(node) {
+        check(node, node.test)
+      },
+      LogicalExpression(node) {
+        if (node.operator === "&&" && node.parent?.type === "JSXExpressionContainer") check(node, node.left)
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "base-props-atom": basePropsAtom,
+  "base-import-pair": baseImportPair,
+  "no-data-status-shape": noDataStatusShape,
+  "slot-status-through-slotview": slotStatusThroughSlotView,
+}
+
+/** Every FE canon rule is an error; existing debt is fixed before adoption. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))