@starci/eslint-canon-fe 1.3.2 → 1.4.1

package/props.ts

@@ -61,13 +61,13 @@ export type LeafProps<D extends ComponentData, A extends ComponentActions = Comp
 /**
  * A COMPOSITE's props. The same three slots a leaf has, and the absence of a fourth is the point.
  *
- * A composite is a CLOSED shape: it assembles leaves into an arrangement a caller can use but
- * cannot rearrange. That boundary with `branch` is held by this type rather than by a convention -
- * there is no `render` here, so an author who wanted a slot cannot express one and has to decide
- * which tier they are actually writing. A boundary the compiler holds does not drift.
- * CLOSED DOES NOT MEAN FREEHAND. A composite still assembles through a typed `Tree` contract;
- * raw structural markup would create an unnamed layout outside the registry. If a caller may
- * supply the content or recipe, the component is a branch rather than a composite.
+ * A composite is a CLOSED shape: it assembles leaves into an arrangement a caller can use but
+ * cannot rearrange. That boundary with `branch` is held by this type rather than by a convention -
+ * there is no `render` here, so an author who wanted a slot cannot express one and has to decide
+ * which tier they are actually writing. A boundary the compiler holds does not drift.
+ * CLOSED DOES NOT MEAN FREEHAND. A composite still assembles through a typed `Tree` contract;
+ * raw structural markup would create an unnamed layout outside the registry. If a caller may
+ * supply the content or recipe, the component is a branch rather than a composite.
  *
  * It is structurally identical to {@link LeafProps} and deliberately NOT an alias of it: the two
  * tiers answer different questions, and a shared name would let a reader conclude they are the same
@@ -85,18 +85,18 @@ export type CompositeProps<D extends ComponentData, A extends ComponentActions =
  *
  * THIS IS THE SLOT THAT USED TO BE `children`, AND THE CHANGE IS NOT COSMETIC. `children` is markup
  * that has already been built: it can be a `.map`, a ternary, a fragment, or a subtree nobody named,
- * so nothing above it can say what is inside a node and no rule can check. `render` is a contract
- * value in one of two lanes. This alias is the bound lane: Tree and ordinary branches receive
- * named slots or an explicit projection. A data-driven surface uses {@link ContractRenderBranchProps}
- * to receive a stable component type and pass changing runtime `props` into it.
+ * so nothing above it can say what is inside a node and no rule can check. `render` is a contract
+ * value in one of two lanes. This alias is the bound lane: Tree and ordinary branches receive
+ * named slots or an explicit projection. A data-driven surface uses {@link ContractRenderBranchProps}
+ * to receive a stable component type and pass changing runtime `props` into it.
  *
  * `contract` and `render` are one decision written twice, and `ContractComponent<K>` ties them together:
  * the key fixes which slots exist and what may fill each, so a card cannot say one thing and hold
  * another. A wrong leaf, wrong leaf props, a node where a leaf was asked for, a missing slot and a
  * slot nobody declared are five compile errors rather than five things a reviewer has to spot.
  *
- * A bare callback or JSX value may not arrive: neither carries the exact key metadata that makes
- * `contract` and `render` one checked decision.
+ * A bare callback or JSX value may not arrive: neither carries the exact key metadata that makes
+ * `contract` and `render` one checked decision.
  *
  * THERE IS NO LIST VARIANT, and there does not need to be. A slot that holds many says so in the
  * table with `repeats: true`; that slot becomes an array. `restingCount` separately fixes how many
@@ -110,26 +110,26 @@ export type BranchProps<
     readonly props: D
     readonly on?: A
     readonly contract: K
-    readonly render: ContractComponent<NoInfer<K>>
-    readonly isLoading?: boolean
-}
-
-/**
- * A data-driven contract host's props. Runtime data stays in `props`; `render` is a stable real
- * component type branded for the exact key. `SurfaceListCard` uses this lane because a repeated
- * domain collection must not be closed into a new callback descriptor at every host call site.
- */
-export type ContractRenderBranchProps<
-    D extends ComponentData,
-    K extends ContractKey,
-    A extends ComponentActions = ComponentActions,
-> = {
-    readonly props: D
-    readonly on?: A
-    readonly contract: K
-    readonly render: ContractComponent<NoInfer<K>, LeafProps<D, A>>
-    readonly isLoading?: boolean
-}
+    readonly render: ContractComponent<NoInfer<K>>
+    readonly isLoading?: boolean
+}
+
+/**
+ * A data-driven contract host's props. Runtime data stays in `props`; `render` is a stable real
+ * component type branded for the exact key. `SurfaceListCard` uses this lane because a repeated
+ * domain collection must not be closed into a new callback descriptor at every host call site.
+ */
+export type ContractRenderBranchProps<
+    D extends ComponentData,
+    K extends ContractKey,
+    A extends ComponentActions = ComponentActions,
+> = {
+    readonly props: D
+    readonly on?: A
+    readonly contract: K
+    readonly render: ContractComponent<NoInfer<K>, LeafProps<D, A>>
+    readonly isLoading?: boolean
+}
 
 /**
  * A BLOCK's presentational half. Two slots.

package/served-locale.mjs

@@ -1,5 +1,5 @@
 /**
- * Rules for the SERVED LOCALE law - `patterns/fe/served-locale/INDEX.md`.
+ * Rules for the SERVED LOCALE law - `fe/canon/patterns/served-locale.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

package/the-split.mjs

@@ -66,7 +66,7 @@ export const presentationalPurity = {
 export const connectedBlockHasPresentationalTwin = {
   meta: {
     type: "problem",
-    docs: { description: "A connected block index renders only its exact `XBase` twin from component.tsx." },
+    docs: { description: "A connected block index renders only its exact `_X` twin from component.tsx." },
     schema: [],
     messages: {
       missing:
@@ -81,7 +81,7 @@ export const connectedBlockHasPresentationalTwin = {
     const block = connectedBlock(context.filename || context.getFilename())
     if (!block) return {}
 
-    const twin = `${block}Base`
+    const twin = `_${block}`
     const worldBindings = new Set()
     const rendered = []
     let importsTwin = false

package/typography.mjs

@@ -1,83 +1,83 @@
-/**
- * The rule that holds `typography.md`.
- *
- * MOST OF THIS LAW IS A UNION, and what is left is one shape a type cannot see: a heading TAG
- * written by hand. The level union stops a fifth step being asked for; nothing in the type system
- * notices an `<h2>` in a file that never mentions the heading component at all.
- *
- * The rule's own twin lives in `tokens.mjs`: that one catches a heading assembled out of a large
- * size and a heavy weight on some other element. Between them they cover both ways a heading gets
- * hand-rolled - with the right tag and the wrong look, or the right look and no tag.
- */
-
-/** Forward-slash form of a filename, so Windows paths compare like every other path. */
-const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
-
-/** Product source lives under `src/`; tooling and config are out of scope. */
-const isSourceFile = (filename) => normalizePath(filename).includes("/src/")
-
-/** A twin test may build heading markup by hand to assert against it. */
-const isTestFile = (filename) => /\.(?:test|spec)\.(?:ts|tsx)$/.test(normalizePath(filename))
-
-/** The one component that owns the tag and the size together, and therefore may write the tag. */
-const isHeadingComponent = (filename) => normalizePath(filename).includes("/src/components/leaves/Heading/")
-
-/** The tags a document outline is built from. */
-const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"])
-
-/** The deepest level the component draws; below this a page has nested too far. */
-const DEEPEST_LEVEL = 4
-
-/** Intrinsic (lowercase) tag name, or null for a component. */
-const tagName = (opening) => {
-  const name = opening && opening.name
-  if (!name || name.type !== "JSXIdentifier") return null
-  return name.name === name.name.toLowerCase() ? name.name : null
-}
-
-// -- TYPESET-1 · TYPESET-2 -------------------------------------------------------------------------------
-
-/** A heading comes from the component that owns its tag and its size as one decision. */
-export const noHeadingTagOutsideHeadingComponent = {
-  meta: {
-    type: "problem",
-    docs: { description: "Heading tags are written by the heading component, from a level." },
-    schema: [],
-    messages: {
-      tag:
-        "`<{{tag}}>` written here throws away the two facts the heading component exists to keep together: the tag a screen reader builds the document outline from, and the size a reader sees. Set separately they drift, and a screen's third-largest text becomes its first heading. Render the heading component with a level of {{level}}; one prop decides both, so they cannot disagree.",
-      tooDeep:
-        "`<{{tag}}>` is deeper than the scale goes: levels stop at {{deepest}}, because a fifth means the page has nested further than a reader can hold. That is a structure problem wearing a styling problem's clothes - flatten the section, then render the title with a level the scale has.",
-    },
-  },
-  create(context) {
-    const file = normalizePath(context.filename || context.getFilename())
-    if (!isSourceFile(file) || isTestFile(file) || isHeadingComponent(file)) return {}
-    return {
-      JSXOpeningElement(node) {
-        const tag = tagName(node)
-        if (!tag || !HEADING_TAGS.has(tag)) return
-        const level = Number(tag.slice(1))
-        if (level > DEEPEST_LEVEL) {
-          context.report({ node, messageId: "tooDeep", data: { tag, deepest: DEEPEST_LEVEL } })
-          return
-        }
-        context.report({ node, messageId: "tag", data: { tag, level } })
-      },
-    }
-  },
-}
-
-/** The rules this law contributes to the plugin. */
-export const rules = {
-  "no-heading-tag-outside-heading-component": noHeadingTagOutsideHeadingComponent,
-}
-
-/**
- * The level this law asks for, as the plugin's own opinion.
- *
- * Exact: a tag name in a file that is not the component that owns it. A repository adopting this
- * with history should expect the deeper levels to report a structure problem rather than a styling
- * one, and those take longer to fix than the message suggests.
- */
-export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))
+/**
+ * The rule that holds `typography.md`.
+ *
+ * MOST OF THIS LAW IS A UNION, and what is left is one shape a type cannot see: a heading TAG
+ * written by hand. The level union stops a fifth step being asked for; nothing in the type system
+ * notices an `<h2>` in a file that never mentions the heading component at all.
+ *
+ * The rule's own twin lives in `tokens.mjs`: that one catches a heading assembled out of a large
+ * size and a heavy weight on some other element. Between them they cover both ways a heading gets
+ * hand-rolled - with the right tag and the wrong look, or the right look and no tag.
+ */
+
+/** Forward-slash form of a filename, so Windows paths compare like every other path. */
+const normalizePath = (filename) => String(filename || "").replace(/\\/g, "/")
+
+/** Product source lives under `src/`; tooling and config are out of scope. */
+const isSourceFile = (filename) => normalizePath(filename).includes("/src/")
+
+/** A twin test may build heading markup by hand to assert against it. */
+const isTestFile = (filename) => /\.(?:test|spec)\.(?:ts|tsx)$/.test(normalizePath(filename))
+
+/** The one component that owns the tag and the size together, and therefore may write the tag. */
+const isHeadingComponent = (filename) => normalizePath(filename).includes("/src/components/leaves/Heading/")
+
+/** The tags a document outline is built from. */
+const HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"])
+
+/** The deepest level the component draws; below this a page has nested too far. */
+const DEEPEST_LEVEL = 4
+
+/** Intrinsic (lowercase) tag name, or null for a component. */
+const tagName = (opening) => {
+  const name = opening && opening.name
+  if (!name || name.type !== "JSXIdentifier") return null
+  return name.name === name.name.toLowerCase() ? name.name : null
+}
+
+// -- TYPESET-1 · TYPESET-2 -------------------------------------------------------------------------------
+
+/** A heading comes from the component that owns its tag and its size as one decision. */
+export const noHeadingTagOutsideHeadingComponent = {
+  meta: {
+    type: "problem",
+    docs: { description: "Heading tags are written by the heading component, from a level." },
+    schema: [],
+    messages: {
+      tag:
+        "`<{{tag}}>` written here throws away the two facts the heading component exists to keep together: the tag a screen reader builds the document outline from, and the size a reader sees. Set separately they drift, and a screen's third-largest text becomes its first heading. Render the heading component with a level of {{level}}; one prop decides both, so they cannot disagree.",
+      tooDeep:
+        "`<{{tag}}>` is deeper than the scale goes: levels stop at {{deepest}}, because a fifth means the page has nested further than a reader can hold. That is a structure problem wearing a styling problem's clothes - flatten the section, then render the title with a level the scale has.",
+    },
+  },
+  create(context) {
+    const file = normalizePath(context.filename || context.getFilename())
+    if (!isSourceFile(file) || isTestFile(file) || isHeadingComponent(file)) return {}
+    return {
+      JSXOpeningElement(node) {
+        const tag = tagName(node)
+        if (!tag || !HEADING_TAGS.has(tag)) return
+        const level = Number(tag.slice(1))
+        if (level > DEEPEST_LEVEL) {
+          context.report({ node, messageId: "tooDeep", data: { tag, deepest: DEEPEST_LEVEL } })
+          return
+        }
+        context.report({ node, messageId: "tag", data: { tag, level } })
+      },
+    }
+  },
+}
+
+/** The rules this law contributes to the plugin. */
+export const rules = {
+  "no-heading-tag-outside-heading-component": noHeadingTagOutsideHeadingComponent,
+}
+
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * Exact: a tag name in a file that is not the component that owns it. A repository adopting this
+ * with history should expect the deeper levels to report a structure problem rather than a styling
+ * one, and those take longer to fix than the message suggests.
+ */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/vendor-boundary.mjs

@@ -27,15 +27,24 @@ const memberName = (node) => {
 /** The component library this boundary owns. Its glyph counterpart belongs to `icon.mjs`. */
 const VENDOR_PACKAGE_PREFIX = "@heroui/"
 
-/** Named mechanics branches own the closed vendor interaction machines. */
-const MECHANICS_BRANCH = /\/src\/components\/branches\/(?:ModalBranch|DrawerBranch|DropdownBranch)\//
-const LEGACY_SHELL_DIR = "/src/components/shells/"
+/**
+ * The shell folder is closed, and it is closed to FOUR now.
+ *
+ * Three own a vendor interaction machine and ignore their interior. `RouteShell` owns a framework
+ * one: a Next segment layout is handed its page as `children`, no tier below a shell may take one,
+ * and a server component cannot convert it because a function does not serialise across that
+ * boundary. It imports no vendor at all, which is why this rule can admit it without widening what
+ * a vendor import means.
+ */
+const SHELL_DIR = "/src/components/shells/"
+const FRAMEWORK_SHELL = /\/src\/components\/shells\/RouteShell\//
+const SHELL_FILE = /\/src\/components\/shells\/(?:ModalShell|DrawerShell|DropdownShell|RouteShell)\//
 
 /** Named surface branches may own the vendor wrapper they project a content contract into. */
 const SURFACE_BRANCH = /\/src\/components\/branches\/(?:SurfaceCard|SurfaceAccordionCard|SurfaceListCard|SurfaceFormCard)\//
 
 const isAllowedVendorOwner = (file) =>
-  file.includes("/src/components/leaves/") || MECHANICS_BRANCH.test(file) || SURFACE_BRANCH.test(file)
+  file.includes("/src/components/leaves/") || SHELL_FILE.test(file) || SURFACE_BRANCH.test(file)
 
 /** True for a file inside the component tree, where the boundary applies. */
 const isComponentFile = (filename) => normalizePath(filename).includes("/src/components/")
@@ -56,15 +65,15 @@ const jsxMemberName = (node) => {
 export const vendorBoundary = {
   meta: {
     type: "problem",
-    docs: { description: "Vendor imports belong to leaves and named mechanics or surface branches." },
+    docs: { description: "Vendor imports belong to leaves, the two covering shells, and named surface branches." },
     schema: [],
     messages: {
       outside:
-        "This component does not own a vendor primitive. Vendor imports belong to leaves, ModalBranch/DrawerBranch/DropdownBranch, and the named SurfaceCard family branches that project contracts into vendor bodies.",
-      emptyBranch:
-        "ModalBranch/DrawerBranch/DropdownBranch must wrap their vendor interaction primitive; otherwise this is an ordinary branch in a privileged mechanics path.",
-      legacyShell:
-        "`components/shells` is a deleted structural tier. Move vendor mechanics into the named Branch owner; framework route content closes outside the component tier into a named contract projection.",
+        "This component does not own a vendor primitive. Vendor imports belong to leaves, ModalShell/DrawerShell, and the named SurfaceCard family branches that project contracts into vendor bodies.",
+      emptyShell:
+        "ModalShell/DrawerShell must wrap their vendor covering primitive; otherwise this is an ordinary branch in the wrong tier.",
+      unknownShell:
+        "Only ModalShell, DrawerShell, DropdownShell and RouteShell are shells. This component must use contract + render as a branch; needing an arbitrary vendor children slot does not create another one - and the list disagreeing with canon is a gate bug, which is how this message came to name two when the tree said three.",
     },
   },
   create(context) {
@@ -72,8 +81,8 @@ export const vendorBoundary = {
     // Outside the component tree, a provider standing the library up for the whole application is a
     // different thing from a component pulling in a widget.
     if (!isComponentFile(file)) return {}
-    const isLegacyShell = file.includes(LEGACY_SHELL_DIR)
-    const isMechanicsBranch = MECHANICS_BRANCH.test(file)
+    const isShellDirectory = file.includes(SHELL_DIR)
+    const isShell = SHELL_FILE.test(file)
     const isTestFile = /\.(?:test|spec)\.[jt]sx?$/.test(file)
     const isAllowed = isAllowedVendorOwner(file)
     let importsVendor = false
@@ -86,8 +95,14 @@ export const vendorBoundary = {
       },
       "Program:exit"(node) {
         if (isTestFile) return
-        if (isLegacyShell) context.report({ node, messageId: "legacyShell" })
-        else if (isMechanicsBranch && !importsVendor) context.report({ node, messageId: "emptyBranch" })
+        if (isShellDirectory && !isShell) context.report({ node, messageId: "unknownShell" })
+        /*
+         * A shell with no vendor import is empty - except the one whose mechanic is the FRAMEWORK's.
+         * `RouteShell` converts the children a Next layout is handed into the component every tier
+         * below expects, and it imports nothing to do it. Demanding a vendor primitive there would
+         * force an import that means nothing, which is how a rule teaches somebody to add noise.
+         */
+        else if (isShell && !importsVendor && !FRAMEWORK_SHELL.test(file)) context.report({ node, messageId: "emptyShell" })
       },
     }
   },
@@ -95,22 +110,22 @@ export const vendorBoundary = {
 
 // -- VENDOR-6 --------------------------------------------------------------------------------------
 
-/** The modal mechanics branch owns one zero-inset vendor body as the scroll region. */
-export const modalBranchOwnsScrollBody = {
+/** A content-agnostic modal shell owns one zero-inset vendor body as the scroll region. */
+export const modalShellOwnsScrollBody = {
   meta: {
     type: "problem",
-    docs: { description: "ModalBranch keeps one zero-inset Modal.Body as its scroll region." },
+    docs: { description: "ModalShell keeps one zero-inset Modal.Body as its scroll region." },
     schema: [],
     messages: {
       missing:
-        "ModalBranch must keep one `Modal.Body` around its named content projection: that vendor body is the dialog's scroll region, not a second content surface.",
+        "ModalShell must keep one `Modal.Body` around its uninterpreted children: that vendor body is the dialog's scroll region, not a second content surface.",
       inset:
-        "ModalBranch's body must be `className=\"p-0\"`. The mounted contract owns layout; vendor body padding plus contract padding creates a doubled inset.",
+        "ModalShell's body must be `className=\"p-0\"`. The mounted contract owns layout; vendor body padding plus contract padding creates a doubled inset.",
     },
   },
   create(context) {
     const file = normalizePath(context.filename || context.getFilename())
-    if (!/\/src\/components\/branches\/ModalBranch\/index\.tsx$/.test(file)) return {}
+    if (!/\/src\/components\/shells\/ModalShell\/index\.tsx$/.test(file)) return {}
     let hasBody = false
     return {
       JSXOpeningElement(node) {
@@ -280,24 +295,24 @@ export const textLinkUsesHeroLink = {
 
 // -- VENDOR-11 -------------------------------------------------------------------------------------
 
-/** The account block owns the product choices; DropdownBranch alone owns HeroUI mechanics. */
+/** The account block owns the product choices; DropdownShell alone owns HeroUI mechanics. */
 export const accountControlOwnsDropdown = {
   meta: {
     type: "problem",
-    docs: { description: "AccountMenu is a block over DropdownBranch; only the branch imports HeroUI Dropdown." },
+    docs: { description: "AccountMenu is a block over DropdownShell; only the shell imports HeroUI Dropdown." },
     schema: [],
     messages: {
-      dropdown: "DropdownBranch must import HeroUI `Dropdown`; vendor mechanics belong to the branch.",
-      branch: "AccountMenu's pure block half must compose DropdownBranch instead of importing HeroUI directly.",
-      vendor: "AccountMenu is a product block. Import DropdownBranch; do not own HeroUI Dropdown here.",
+      dropdown: "DropdownShell must import HeroUI `Dropdown`; vendor mechanics belong to the shell.",
+      shell: "AccountMenu's pure block half must compose DropdownShell instead of importing HeroUI directly.",
+      vendor: "AccountMenu is a product block. Import DropdownShell; do not own HeroUI Dropdown here.",
       menu: "ShellNav must render the AccountMenu block from `components/blocks/auth/AccountMenu`.",
       direct: "The account IconButton may not carry an action in ShellNav. Guests open AccountMenu; its Sign in or Sign up choice opens the modal.",
-      pieces: "AccountMenu passes typed section data to DropdownBranch; it must not import Branch Section or Item pieces and rebuild vendor anatomy itself.",
+      pieces: "AccountMenu passes typed section data to DropdownShell; it must not import shell Section or Item pieces and rebuild vendor anatomy itself.",
     },
   },
   create(context) {
     const file = normalizePath(context.filename || context.getFilename())
-    const isDropdown = /\/src\/components\/branches\/DropdownBranch\/index\.tsx$/.test(file)
+    const isDropdown = /\/src\/components\/shells\/DropdownShell\/index\.tsx$/.test(file)
     const isMenu = /\/src\/components\/blocks\/auth\/AccountMenu\/component\.tsx$/.test(file)
     const isNav = /\/src\/components\/layouts\/ShellNav\/component\.tsx$/.test(file)
     if (!isDropdown && !isMenu && !isNav) return {}
@@ -306,7 +321,7 @@ export const accountControlOwnsDropdown = {
       ExportNamedDeclaration(node) {
         if (!isDropdown) return
         const source = context.sourceCode || context.getSourceCode()
-          if (/\bDropdownBranch(?:Item|Section)\b/.test(source.getText(node))) {
+        if (/\bDropdownShell(?:Item|Section)\b/.test(source.getText(node))) {
           context.report({ node, messageId: "pieces" })
         }
       },
@@ -315,10 +330,10 @@ export const accountControlOwnsDropdown = {
           hasOwner ||= (node.specifiers || []).some((specifier) => specifier.imported?.name === "Dropdown")
         }
         if (isMenu && node.source?.value === "@heroui/react") context.report({ node, messageId: "vendor" })
-        if (isMenu && /\/components\/branches\/DropdownBranch$/.test(normalizePath(node.source?.value))) {
+        if (isMenu && /\/components\/shells\/DropdownShell$/.test(normalizePath(node.source?.value))) {
           hasOwner = true
           if ((node.specifiers || []).some((specifier) =>
-            /^(?:DropdownBranchSection|DropdownBranchItem)/.test(specifier.imported?.name || ""))) {
+            /^(?:DropdownShellSection|DropdownShellItem)/.test(specifier.imported?.name || ""))) {
             context.report({ node, messageId: "pieces" })
           }
         }
@@ -335,7 +350,7 @@ export const accountControlOwnsDropdown = {
       },
       "Program:exit"(node) {
         if (hasOwner) return
-        context.report({ node, messageId: isDropdown ? "dropdown" : isMenu ? "branch" : "menu" })
+        context.report({ node, messageId: isDropdown ? "dropdown" : isMenu ? "shell" : "menu" })
       },
     }
   },
@@ -440,12 +455,12 @@ export const noInternalStarciHref = {
 export const authOverlayOwnsSingleContentHost = {
   meta: {
     type: "problem",
-    docs: { description: "Authentication has one zero-inset content host inside ModalBranch or DrawerBranch." },
+    docs: { description: "Authentication has one zero-inset content host inside ModalShell." },
     schema: [],
     messages: {
-      duplicate: "SignInOverlay must project through one host only: do not open a second `Tree`/`ContractContent` inside a branch that already receives `contract`/`render` directly, and do not open `Tree` by hand instead of importing `ContractContent`.",
-      missing: "SignInOverlay must host its content either by importing `ContractContent` for its already-hosted projection, or by passing `contract` and `render` props directly to `ModalBranch`/`DrawerBranch`.",
-      inset: "`centred-page-column` must not add py/pt/pb. ModalBranch is zero-inset and the auth content touches that scroll region without a second vertical padding band.",
+      duplicate: "SignInOverlay must project with `ContractContent`, not open another `Tree` around a panel that already owns the same host.",
+      missing: "SignInOverlay must import `ContractContent` for its already-hosted projection.",
+      inset: "`centred-page-column` must not add py/pt/pb. ModalShell is zero-inset and the auth content touches that scroll region without a second vertical padding band.",
     },
   },
   create(context) {
@@ -454,63 +469,24 @@ export const authOverlayOwnsSingleContentHost = {
     const isContracts = /\/src\/components\/contracts\/index\.ts$/.test(file)
     if (!isOverlay && !isContracts) return {}
     let hasContent = false
-
-    /*
-     * Two call shapes satisfy the same invariant - one contract-driven content host, zero extra
-     * vertical inset - and both are recognised here.
-     *
-     * (a) THE OLD SHAPE: the overlay imports `ContractContent` and mounts it itself as the branch's
-     * children. `ContractContent` IS the checked host, so importing it is enough to credit the
-     * overlay with owning one.
-     *
-     * (b) THE NEW SHAPE: `ModalBranch`/`DrawerBranch` were migrated to take `{contract, render}`
-     * directly and build `<Tree contract render />` internally (SLOTS-4). An overlay that hands both
-     * props straight to the branch has delegated the same host to the branch itself; there is
-     * nothing left for the overlay to import.
-     *
-     * Matched by JSX ATTRIBUTE NAME, not by where `ModalBranch`/`DrawerBranch` resolve from - same
-     * reasoning VENDOR-12 already applies to `ContractContent`/`Tree` below: canon vocabulary means
-     * the same thing wherever it is imported from.
-     */
-    const MECHANICS_BRANCH_NAMES = new Set(["ModalBranch", "DrawerBranch"])
-    const hasJsxAttribute = (attributes, attrName) =>
-      (attributes || []).some((attribute) =>
-        attribute.type === "JSXAttribute"
-        && attribute.name?.type === "JSXIdentifier"
-        && attribute.name.name === attrName)
-    const jsxChildName = (child) => {
-      if (child?.type !== "JSXElement") return null
-      const name = child.openingElement?.name
-      return name?.type === "JSXIdentifier" ? name.name : null
-    }
-
     return {
       ImportDeclaration(node) {
         if (!isOverlay) return
         /*
-         * Matched by the NAME imported, not by where it came from - see the comment above.
+         * Matched by the NAME imported, not by where it came from.
+         *
+         * The path test this replaced only recognised `components/branches/Tree`,
+         * which is the single-app layout. A workspace that publishes the same
+         * branches from a package satisfied the law and failed the rule, with
+         * the only available remedy being an import of a module that does not
+         * exist there. `ContractContent` and `Tree` are canon vocabulary: a file
+         * importing either means the same thing wherever it resolves from.
          */
         for (const specifier of node.specifiers || []) {
           if (specifier.imported?.name === "ContractContent") hasContent = true
-          // Opening `Tree` by hand is the one thing neither shape ever does: both shapes close the
-          // host either inside ContractContent or inside the mechanics branch itself.
           if (specifier.imported?.name === "Tree") context.report({ node: specifier, messageId: "duplicate" })
         }
       },
-      JSXElement(node) {
-        if (!isOverlay) return
-        const name = node.openingElement?.name
-        if (name?.type !== "JSXIdentifier" || !MECHANICS_BRANCH_NAMES.has(name.name)) return
-        const attributes = node.openingElement.attributes
-        if (!hasJsxAttribute(attributes, "contract") || !hasJsxAttribute(attributes, "render")) return
-        // The branch itself now owns the host: shape (b).
-        hasContent = true
-        // A second content host nested as children, when the branch already receives contract/render
-        // directly, duplicates the host the branch already opened.
-        const nestedHost = (node.children || []).some((child) =>
-          jsxChildName(child) === "Tree" || jsxChildName(child) === "ContractContent")
-        if (nestedHost) context.report({ node, messageId: "duplicate" })
-      },
       Property(node) {
         if (!isContracts) return
         const key = node.key?.type === "Literal" ? node.key.value : node.key?.name
@@ -528,7 +504,7 @@ export const authOverlayOwnsSingleContentHost = {
 /** The rules this law contributes to the plugin. */
 export const rules = {
   "vendor-boundary": vendorBoundary,
-  "modal-branch-owns-scroll-body": modalBranchOwnsScrollBody,
+  "modal-shell-owns-scroll-body": modalShellOwnsScrollBody,
   "field-input-uses-secondary-variant": fieldInputUsesSecondaryVariant,
   "field-label-is-text-only": fieldLabelIsTextOnly,
   "no-surface-branch-in-overlay": noSurfaceBranchInOverlay,
@@ -543,7 +519,8 @@ export const rules = {
  * The level this law asks for, as the plugin's own opinion.
  *
  * A repository adopting this with history should expect the outward half to report and the inward
- * half to be silent until named mechanics branches exist. Creating those owners is the migration;
- * no anonymous wrapper tier is introduced.
+ * half to be silent, because `shells/` will not exist yet. Creating it is the migration: every
+ * vendor container currently wrapped as something else moves there, and each move is what makes the
+ * inward check meaningful afterwards.
  */
 export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))