@starci/eslint-canon-fe 3.0.2 → 5.1.2

package/served-locale.mjs

@@ -1,161 +1,161 @@
-/**
+/**
  * Rules for the SERVED LOCALE law - `patterns/fe/served-locale/INDEX.md`.
- *
- * WHY THESE EXIST. An application obeyed the translation law completely - every label resolved in a
- * connected half, no literal below a block, both catalogues in step - and served a Vietnamese reader
- * an English course on a `/vi/` URL. The chrome came from the dictionary and the content came from an
- * API that was never told which language to serve, so the failure looked like a translation gap and
- * was looked for in the dictionary, where there was nothing wrong. The header was missing, and no
- * gate had anything to say about a header nobody wrote.
- *
- * WHAT THEY HOLD. That the transport chain declares a locale, and that exactly one place writes it.
- * Both are file-at-a-time facts: the chain is assembled in one file, and a header is written where it
- * is written.
- *
- * WHAT THEY CANNOT HOLD, stated rather than implied. Neither rule can tell whether the value the link
- * computes is CORRECT - whether it reads the address, the cookie or a constant - because that is
- * inside a function these rules only see the name of. A link that attaches `x-locale: "en"`
- * unconditionally satisfies both and is wrong. That case is a review question and LOCALE-2 is where
- * it is argued; pretending otherwise would be the rule claiming a guarantee it does not have.
- *
- * WHY THE FIRST RULE KEYS ON THE TERMINAL LINK RATHER THAN ON THE FILE PATH. A repository may name
- * its client folder anything, and a path pattern that guessed wrong would either miss the real chain
- * or fire on every helper beside it. The chain is identifiable by what it does: it builds the link
- * that talks to the network.
- *
- * WITH ONE EXEMPTION THAT WAS FOUND BY RUNNING IT, NOT BY THINKING ABOUT IT. "Constructs the
- * terminal link" is also true of the file that DEFINES that link, so the first version reported
- * `links/http.ts` and its spec on a repository that had done everything right. There was no correct
- * way to satisfy it there - a locale link inside the http link is a chain hiding in a link - and a
- * rule with no correct way to satisfy it is a finding about the rule. A file under `links/` is one
- * link; a chain is assembled elsewhere, which is where the locale belongs.
- */
-
-/** Forward-slash form of a filename, so Windows paths compare like every other path. */
-const normalize = (filename) => String(filename || "").replace(/\\/g, "/")
-
-/**
- * The link file that owns the locale header.
- *
- * This is the ONE file allowed to write it, and it is recognised by path rather than by content:
- * the point of the second rule is that the header appears in one place, so that place has to be
- * named somewhere, and a name is what the law and the rule can both refer to.
- */
-export const isLocaleLinkFile = (filename) => /\/links\/locale\.[cm]?tsx?$/.test(normalize(filename))
-
-/**
- * One link's own implementation, rather than a chain of them.
- *
- * WHY THIS EXEMPTION EXISTS, AND IT WAS MEASURED. The first version of the chain rule keyed only on
- * "constructs the terminal link", which is true of the file that DEFINES that link - `links/http.ts`
- * builds `new HttpLink(...)`, because that is its whole job. Run against real source it reported
- * that file and its spec, and there was no correct way to satisfy it there: attaching a locale link
- * inside the http link would be a chain hiding in a link.
- *
- * A file under `links/` is one link. A chain is assembled somewhere else, which is exactly where the
- * locale belongs.
- */
-export const isLinkImplementationFile = (filename) => /\/links\/[^/]+$/.test(normalize(filename))
-
-/** A spec or test file - it asserts about production shapes rather than being one. */
-export const isTestFile = (filename) => /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(normalize(filename))
-
-/** The header a request declares its language in. */
-export const LOCALE_HEADER = "x-locale"
-
-/** Callee names that construct the terminal link - the one that actually reaches the network. */
-const TERMINAL_LINK_CALLEES = new Set(["createHttpLink", "HttpLink", "createUploadLink", "BatchHttpLink"])
-
-/** Callee names that attach the reader's locale to an operation. */
-const LOCALE_LINK_CALLEES = new Set(["createAttachLocaleLink", "createLocaleLink"])
-
-/** The callee name of a call or `new` expression, when it has a plain one. */
-const calleeName = (node) => {
-  const callee = node && node.callee
-  if (!callee) return null
-  if (callee.type === "Identifier") return callee.name
-  if (callee.type === "MemberExpression" && callee.property && callee.property.type === "Identifier") {
-    return callee.property.name
-  }
-  return null
-}
-
-/** Every string-ish key a property can carry, so `"x-locale"` and `["x-locale"]` read the same. */
-const propertyKeyOf = (property) => {
-  if (!property || property.type !== "Property") return null
-  const key = property.key
-  if (!key) return null
-  if (key.type === "Identifier" && !property.computed) return key.name
-  if (key.type === "Literal" && typeof key.value === "string") return key.value
-  return null
-}
-
-export const rules = {
-  "api-client-attaches-the-locale": {
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "A transport chain that builds the terminal HTTP link must also attach the reader's locale, so every call declares the language it wants served.",
-      },
-      schema: [],
-      messages: {
-        missing:
-          "This assembles the API transport but never attaches the reader's locale, so every call it makes is served the server's default language. Add the locale link to the chain, beside the auth link and unconditionally - a guest reads in a language too. A surface that is bilingual in its chrome and monolingual in its content reads as a translation gap, which is why it gets looked for in the dictionary rather than here.",
-      },
-    },
-    create(context) {
-      const filename = context.filename || context.getFilename()
-      // A single link's implementation is not a chain - `links/http.ts` constructs the terminal link
-      // because defining it IS its job, and there is no correct way to attach a locale there. A
-      // spec asserts about a chain rather than being one.
-      if (isLinkImplementationFile(filename) || isTestFile(filename)) return {}
-      let terminalNode = null
-      let attachesLocale = false
-      const note = (node) => {
-        const name = calleeName(node)
-        if (name === null) return
-        if (TERMINAL_LINK_CALLEES.has(name)) terminalNode = terminalNode || node
-        if (LOCALE_LINK_CALLEES.has(name)) attachesLocale = true
-      }
-      return {
-        CallExpression: note,
-        NewExpression: note,
-        "Program:exit"() {
-          if (terminalNode && !attachesLocale) {
-            context.report({ node: terminalNode, messageId: "missing" })
-          }
-        },
-      }
-    },
-  },
-
-  "locale-header-belongs-to-the-link": {
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "The locale header is written by the locale link and nowhere else, so one place answers which language a request is in.",
-      },
-      schema: [],
-      messages: {
-        elsewhere:
-          "Only the locale link may write `x-locale`. Setting it here is a second answer to which language this request is in, and the two diverge the first time one of them is updated - usually leaving a single hook correct and the rest of the surface on the server's default. Let the transport attach it.",
-      },
-    },
-    create(context) {
-      const filename = context.filename || context.getFilename()
-      if (isLocaleLinkFile(filename)) return {}
-      return {
-        Property(node) {
-          if (propertyKeyOf(node) === LOCALE_HEADER) {
-            context.report({ node, messageId: "elsewhere" })
-          }
-        },
-      }
-    },
-  },
-}
-
-/** 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"]))
+ *
+ * WHY THESE EXIST. An application obeyed the translation law completely - every label resolved in a
+ * connected half, no literal below a block, both catalogues in step - and served a Vietnamese reader
+ * an English course on a `/vi/` URL. The chrome came from the dictionary and the content came from an
+ * API that was never told which language to serve, so the failure looked like a translation gap and
+ * was looked for in the dictionary, where there was nothing wrong. The header was missing, and no
+ * gate had anything to say about a header nobody wrote.
+ *
+ * WHAT THEY HOLD. That the transport chain declares a locale, and that exactly one place writes it.
+ * Both are file-at-a-time facts: the chain is assembled in one file, and a header is written where it
+ * is written.
+ *
+ * WHAT THEY CANNOT HOLD, stated rather than implied. Neither rule can tell whether the value the link
+ * computes is CORRECT - whether it reads the address, the cookie or a constant - because that is
+ * inside a function these rules only see the name of. A link that attaches `x-locale: "en"`
+ * unconditionally satisfies both and is wrong. That case is a review question and LOCALE-2 is where
+ * it is argued; pretending otherwise would be the rule claiming a guarantee it does not have.
+ *
+ * WHY THE FIRST RULE KEYS ON THE TERMINAL LINK RATHER THAN ON THE FILE PATH. A repository may name
+ * its client folder anything, and a path pattern that guessed wrong would either miss the real chain
+ * or fire on every helper beside it. The chain is identifiable by what it does: it builds the link
+ * that talks to the network.
+ *
+ * WITH ONE EXEMPTION THAT WAS FOUND BY RUNNING IT, NOT BY THINKING ABOUT IT. "Constructs the
+ * terminal link" is also true of the file that DEFINES that link, so the first version reported
+ * `links/http.ts` and its spec on a repository that had done everything right. There was no correct
+ * way to satisfy it there - a locale link inside the http link is a chain hiding in a link - and a
+ * rule with no correct way to satisfy it is a finding about the rule. A file under `links/` is one
+ * link; a chain is assembled elsewhere, which is where the locale belongs.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalize = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/**
+ * The link file that owns the locale header.
+ *
+ * This is the ONE file allowed to write it, and it is recognised by path rather than by content:
+ * the point of the second rule is that the header appears in one place, so that place has to be
+ * named somewhere, and a name is what the law and the rule can both refer to.
+ */
+export const isLocaleLinkFile = (filename) => /\/links\/locale\.[cm]?tsx?$/.test(normalize(filename))
+
+/**
+ * One link's own implementation, rather than a chain of them.
+ *
+ * WHY THIS EXEMPTION EXISTS, AND IT WAS MEASURED. The first version of the chain rule keyed only on
+ * "constructs the terminal link", which is true of the file that DEFINES that link - `links/http.ts`
+ * builds `new HttpLink(...)`, because that is its whole job. Run against real source it reported
+ * that file and its spec, and there was no correct way to satisfy it there: attaching a locale link
+ * inside the http link would be a chain hiding in a link.
+ *
+ * A file under `links/` is one link. A chain is assembled somewhere else, which is exactly where the
+ * locale belongs.
+ */
+export const isLinkImplementationFile = (filename) => /\/links\/[^/]+$/.test(normalize(filename))
+
+/** A spec or test file - it asserts about production shapes rather than being one. */
+export const isTestFile = (filename) => /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(normalize(filename))
+
+/** The header a request declares its language in. */
+export const LOCALE_HEADER = "x-locale"
+
+/** Callee names that construct the terminal link - the one that actually reaches the network. */
+const TERMINAL_LINK_CALLEES = new Set(["createHttpLink", "HttpLink", "createUploadLink", "BatchHttpLink"])
+
+/** Callee names that attach the reader's locale to an operation. */
+const LOCALE_LINK_CALLEES = new Set(["createAttachLocaleLink", "createLocaleLink"])
+
+/** The callee name of a call or `new` expression, when it has a plain one. */
+const calleeName = (node) => {
+  const callee = node && node.callee
+  if (!callee) return null
+  if (callee.type === "Identifier") return callee.name
+  if (callee.type === "MemberExpression" && callee.property && callee.property.type === "Identifier") {
+    return callee.property.name
+  }
+  return null
+}
+
+/** Every string-ish key a property can carry, so `"x-locale"` and `["x-locale"]` read the same. */
+const propertyKeyOf = (property) => {
+  if (!property || property.type !== "Property") return null
+  const key = property.key
+  if (!key) return null
+  if (key.type === "Identifier" && !property.computed) return key.name
+  if (key.type === "Literal" && typeof key.value === "string") return key.value
+  return null
+}
+
+export const rules = {
+  "api-client-attaches-the-locale": {
+    meta: {
+      type: "problem",
+      docs: {
+        description:
+          "A transport chain that builds the terminal HTTP link must also attach the reader's locale, so every call declares the language it wants served.",
+      },
+      schema: [],
+      messages: {
+        missing:
+          "This assembles the API transport but never attaches the reader's locale, so every call it makes is served the server's default language. Add the locale link to the chain, beside the auth link and unconditionally - a guest reads in a language too. A surface that is bilingual in its chrome and monolingual in its content reads as a translation gap, which is why it gets looked for in the dictionary rather than here.",
+      },
+    },
+    create(context) {
+      const filename = context.filename || context.getFilename()
+      // A single link's implementation is not a chain - `links/http.ts` constructs the terminal link
+      // because defining it IS its job, and there is no correct way to attach a locale there. A
+      // spec asserts about a chain rather than being one.
+      if (isLinkImplementationFile(filename) || isTestFile(filename)) return {}
+      let terminalNode = null
+      let attachesLocale = false
+      const note = (node) => {
+        const name = calleeName(node)
+        if (name === null) return
+        if (TERMINAL_LINK_CALLEES.has(name)) terminalNode = terminalNode || node
+        if (LOCALE_LINK_CALLEES.has(name)) attachesLocale = true
+      }
+      return {
+        CallExpression: note,
+        NewExpression: note,
+        "Program:exit"() {
+          if (terminalNode && !attachesLocale) {
+            context.report({ node: terminalNode, messageId: "missing" })
+          }
+        },
+      }
+    },
+  },
+
+  "locale-header-belongs-to-the-link": {
+    meta: {
+      type: "problem",
+      docs: {
+        description:
+          "The locale header is written by the locale link and nowhere else, so one place answers which language a request is in.",
+      },
+      schema: [],
+      messages: {
+        elsewhere:
+          "Only the locale link may write `x-locale`. Setting it here is a second answer to which language this request is in, and the two diverge the first time one of them is updated - usually leaving a single hook correct and the rest of the surface on the server's default. Let the transport attach it.",
+      },
+    },
+    create(context) {
+      const filename = context.filename || context.getFilename()
+      if (isLocaleLinkFile(filename)) return {}
+      return {
+        Property(node) {
+          if (propertyKeyOf(node) === LOCALE_HEADER) {
+            context.report({ node, messageId: "elsewhere" })
+          }
+        },
+      }
+    },
+  },
+}
+
+/** 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"]))

package/shape-slot.mjs

@@ -0,0 +1,339 @@
+/**
+ * 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.
+ */
+
+import { normalizePath } from "./lib/path.mjs"
+
+/** 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"]))