@starci/eslint-grammar-core 0.15.3 → 0.15.6

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.15.6 - 2026-10-28
+
+- Changed: `starci-grammar/route-page-is-one-page` (R325) also refuses a page owner file that draws JSX but no `Page` and draws through no pure half of its own (an element imported from `./component`), with the message `missing` on its first element. The segment boundary owners of FE-BOUNDARY-1 (`*ErrorPage`, `*LoadingPage`, `*NotFoundPage`) are not judged for it; a file that draws a bare `PageHeader` or `PageContainer` is reported once, as `part`. Spec: `src/page.spec.ts`; docs: `docs/page.md`.
+- Changed: the R324 message names link tabs (items with `href`) as the other form of `header.tabs`.
+- Changed: versioned together with Grammar 0.15.6; the bundled canon pins name the Grammar family 0.15.6 and hfs 4.9.8.
+
+## 0.15.5 - 2026-10-28
+
+- Changed: versioned together with Grammar 0.15.5 (the family equality spec); `@starci/eslint-canon-fe` 9.4.5 is the peer dependency; the bundled canon pins name the Grammar family 0.15.5. No lint rule changed.
+- Changed: the bundled rule catalog states R225 with the app pre-push hook's dependency push gate (`starci deps check`). No lint rule changed.
+
+## 0.15.4 - 2026-10-28
+
+- Added: `starci-grammar/page-tabs-in-header` (R324, `FE_PAGE_TABS_OUTSIDE_HEADER`): a `Tabs` that is the first element child of a `Page`, or the next element sibling of a `PageHeader`, is a page tab bar outside the band; pass it as `header.tabs`.
+- Added: `starci-grammar/route-page-is-one-page` (R325, `FE_ROUTE_PAGE_OUTSIDE_PAGE`): a page owner (`fe.feature`, kind `pages`) draws one `Page` with no element sibling and no `PageHeader` or `PageContainer` of its own. Spec: `src/page.spec.ts`; docs: `docs/page.md`.
+- Changed: versioned together with Grammar 0.15.4; `@starci/eslint-canon-fe` 9.4.4 is the peer dependency; the bundled rule catalog carries R324 and R325, and the bundled canon pins follow release G (Grammar family 0.15.4, hfs 4.9.5, canon-fe 9.4.4, canon-be 3.6.4, ai-router 0.3.0).
+
 ## 0.15.3 - 2026-10-28
 
 - Added: `starci-grammar/no-hand-rolled-page-header` (R323, `FE_PAGE_HEADER_HAND_ROLLED`): a `Breadcrumbs` followed by a `SectionHeader` among one parent's element children is a page head composed by hand; compose Grammar 0.15.3's `PageHeader`. Spec: `src/page-header.spec.ts`; docs: `docs/page-header.md`.

package/README.md

@@ -19,7 +19,7 @@ Family helpers and the generated runtime closure belong to this package.
 
 The rule IDs remain stable when their namespace moves. Laws cover the fixed app shell and navbar,
 Grammar-owned structural elements, glyphs and icon sizes, destructive menu entries, status inks,
-chip labels that start uppercase, the page head composed by `PageHeader`, heading and token scales, vendor ownership and slot-status composition. Each rule's metadata cites
+chip labels that start uppercase, the page head composed by `PageHeader`, the route page as one `Page` with its tabs in the header, heading and token scales, vendor ownership and slot-status composition. Each rule's metadata cites
 its behavioral knowledge source and the governing ownership test. The R318 surface composition
 rules (nested control variants, panel-list alignment, layout-only CSS) stay in the universal canon.
 

package/dist/index.js

@@ -6,6 +6,7 @@ import { rules as drawingRules } from "./drawing.js";
 import { rules as grammarBoundaryRules } from "./grammar-boundary.js";
 import { rules as iconRules } from "./icon.js";
 import { rules as menuEntriesRules } from "./menu-entries.js";
+import { rules as pageRules } from "./page.js";
 import { rules as pageHeaderRules } from "./page-header.js";
 import { rules as statusColorsRules } from "./status-colors.js";
 import { rules as tokensRules } from "./tokens.js";
@@ -19,6 +20,7 @@ const CONTRIBUTIONS = [
     { law: "grammar-boundary", rules: grammarBoundaryRules },
     { law: "icon", rules: iconRules },
     { law: "menu-entries", rules: menuEntriesRules },
+    { law: "page", rules: pageRules },
     { law: "page-header", rules: pageHeaderRules },
     { law: "status-colors", rules: statusColorsRules },
     { law: "tokens", rules: tokensRules },

package/dist/lib/why.js

@@ -34,6 +34,16 @@ export const why = {
         en: "A page head in `<file>` is a Breadcrumbs trail and a SectionHeader composed by hand.",
         fix: "Compose Grammar PageHeader with breadcrumbs, title and the slots the head needs (description, meta, status, mark, actions, tabs).",
     },
+    "page-tabs-in-header": {
+        code: "FE_PAGE_TABS_OUTSIDE_HEADER",
+        en: "A page tab bar in `<file>` is a Tabs at the top of the Page body or right after a PageHeader, outside the header band.",
+        fix: "Pass the tabs as Page header.tabs (or PageHeader tabs): { label, items, selectedKey, onSelect }, or link tabs whose items carry an href each.",
+    },
+    "route-page-is-one-page": {
+        code: "FE_ROUTE_PAGE_OUTSIDE_PAGE",
+        en: "The page owner `<file>` draws something beside its Page, a bare PageHeader or PageContainer, or no Page at all.",
+        fix: "Draw one Page: the band as its header, everything else in its body, the measure as its measure.",
+    },
     "no-shell-bottom-tabs": {
         code: "FE_APP_SHELL_BOTTOM_TABS",
         en: "Bottom tab navigation replaces the required mobile sidebar drawer.",

package/dist/page.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "eslint";
+import type { TSESTree } from "@typescript-eslint/types";
+/** The `Tabs` element drawn as page tabs outside the header band, among one parent's children, or null. */
+export declare const tabsOutsideHeader: (parent: TSESTree.JSXElement | TSESTree.JSXFragment) => TSESTree.JSXElement | null;
+/** Page tabs are the header's `tabs`, never a `Tabs` at the top of the body or beside a `PageHeader`. */
+export declare const pageTabsInHeader: Rule.RuleModule;
+/** A page owner draws one `Page` and nothing beside it; `PageHeader` and `PageContainer` are Page's own parts. */
+export declare const routePageIsOnePage: Rule.RuleModule;
+/** The rules these laws contribute to the plugin. */
+export declare const rules: Record<string, Rule.RuleModule>;
+/** Every rule of these laws is an error. */
+export declare const recommended: Record<string, "error">;

package/dist/page.js

@@ -0,0 +1,147 @@
+import { inSlot, isProductSource, kindOfFile } from "@starci/eslint-canon-fe/lib/scope.mjs";
+import { defineFamilyRules, defineRule } from "./lib/rule-contract.js";
+/**
+ * The rules that hold the page frame laws: Grammar's `Page` is the one owner of a route page's header band, its inset
+ * and its rhythm.
+ *
+ * - R324 (`FE_PAGE_TABS_OUTSIDE_HEADER`): page tabs are the header's tabs. A `Tabs` that is the first element child of a
+ *   `Page` (the top of the body, right under the band), or the next element sibling of a `PageHeader`, is a page tab bar
+ *   drawn outside the band: it misses the separator it stands on and takes the body's inset and gap.
+ * - R325 (`FE_ROUTE_PAGE_OUTSIDE_PAGE`): a page owner (`fe.feature`, kind `pages`) draws one `Page` and nothing beside it.
+ *   A `Page` with an element sibling, or a bare `PageHeader` or `PageContainer` in the page owner, re-decides the inset
+ *   and the rhythm `Page` owns. A page owner file that draws JSX but no `Page`, and hands drawing to no pure half of its
+ *   own (an element imported from `./component`), has no page frame at all.
+ *
+ * WHAT IT READS. Element names (`Page`, or `Grammar.Page` as `Page`), the element children of one JSX parent, and the
+ * names a file imports from a relative module; whitespace text and JSX comments are not children. A `Tabs` lower in the
+ * body, a `Page` wrapped alone in a provider, and files outside a page owner (for R325) are not judged. The segment
+ * boundary owners of FE-BOUNDARY-1 (`*ErrorPage`, `*LoadingPage`, `*NotFoundPage`) are not judged for a missing `Page`:
+ * an app-level boundary stands in for whichever page failed or waits and draws its notice.
+ */
+/** The element name of a JSX child (`Tabs`, or `Grammar.Tabs` as `Tabs`), or null for text and expressions. */
+const elementName = (child) => {
+    if (child?.type !== "JSXElement")
+        return null;
+    const name = child.openingElement.name;
+    if (name.type === "JSXIdentifier")
+        return name.name;
+    if (name.type === "JSXMemberExpression")
+        return name.property.name;
+    return null;
+};
+/** The children that render: whitespace-only text and `{/* comments *\/}` are left out. */
+const renderedChildren = (children) => children.filter((child) => {
+    if (child.type === "JSXText")
+        return child.value.trim() !== "";
+    if (child.type === "JSXExpressionContainer")
+        return child.expression.type !== "JSXEmptyExpression";
+    return true;
+});
+/** The `Tabs` element drawn as page tabs outside the header band, among one parent's children, or null. */
+export const tabsOutsideHeader = (parent) => {
+    const children = renderedChildren(parent.children);
+    const first = children[0];
+    if (elementName(parent) === "Page" && elementName(first) === "Tabs")
+        return first;
+    for (let index = 0; index + 1 < children.length; index += 1) {
+        const next = children[index + 1];
+        if (elementName(children[index]) === "PageHeader" && elementName(next) === "Tabs")
+            return next;
+    }
+    return null;
+};
+/** Page tabs are the header's `tabs`, never a `Tabs` at the top of the body or beside a `PageHeader`. */
+export const pageTabsInHeader = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "R324: page tabs are Page header.tabs (or PageHeader tabs), never a Tabs at the top of the body." },
+        schema: [],
+        messages: {
+            outside: "This `Tabs` is the page's tab bar drawn under the header band instead of on it: it misses the separator the page tabs stand on and takes the body's inset. Pass it as `header.tabs` of `Page` (or `tabs` of `PageHeader`): `{ label, items, selectedKey, onSelect }`, or link tabs whose items carry an `href` each.",
+        },
+    },
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        const judge = (parent) => {
+            const tabs = tabsOutsideHeader(parent);
+            if (tabs !== null)
+                context.report({ node: tabs, messageId: "outside" });
+        };
+        return {
+            JSXElement(element) { judge(element); },
+            JSXFragment(fragment) { judge(fragment); },
+        };
+    },
+});
+const PAGE_PARTS = new Set(["PageHeader", "PageContainer"]);
+/** True for a page owner's file: `fe.feature`, kind `pages`. */
+const isPageOwner = (context) => inSlot(context, "fe.feature") && kindOfFile(context) === "pages";
+/** The segment boundary owners of FE-BOUNDARY-1: an error, loading or not-found page, which may draw a notice. */
+const BOUNDARY_OWNER = /\/features\/pages\/[^/]*(?:ErrorPage|LoadingPage|NotFoundPage)\//;
+/** True when the file is a boundary owner's, judged by its owner folder. */
+const isBoundaryOwner = (context) => BOUNDARY_OWNER.test(context.filename.replaceAll("\\", "/"));
+/** The pure half of a page owner: the module its connected half draws through. */
+const PURE_HALF = /^\.\/component(?:\.[cm]?[jt]sx?)?$/;
+/** A page owner draws one `Page` and nothing beside it; `PageHeader` and `PageContainer` are Page's own parts. */
+export const routePageIsOnePage = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "R325: a page owner draws one Page with nothing beside it, never a bare PageHeader or PageContainer, and never no Page at all." },
+        schema: [],
+        messages: {
+            sibling: "This `Page` has a sibling: a route page is one `Page`, and whatever sits beside it escapes the header band, the measure and the rhythm `Page` owns. Move the sibling into the `Page` body, or into `header` when it heads the page.",
+            part: "`{{name}}` is drawn by `Page`: a page owner composes `Page` (`header` for the band, `measure` for the body), so the inset and the rhythm have one owner. Replace it with `Page`.",
+            missing: "This page owner draws no `Page`: a route page is one Grammar `Page`, which owns the header band, the measure and the rhythm, so without it the page has no heading band and its body sits on no inset. Wrap what it draws in a `Page` whose `header.title` is the page heading (never a `Heading` of its own), or draw it through the owner's pure half in `./component`.",
+        },
+    },
+    create(context) {
+        if (!isProductSource(context) || !isPageOwner(context))
+            return {};
+        const judgeMissing = !isBoundaryOwner(context);
+        const pureHalf = new Set();
+        let first = null;
+        let drawsPage = false;
+        return {
+            ImportDeclaration(declaration) {
+                if (!PURE_HALF.test(String(declaration.source.value)))
+                    return;
+                for (const specifier of declaration.specifiers)
+                    pureHalf.add(specifier.local.name);
+            },
+            JSXElement(element) {
+                first ??= element;
+                const name = elementName(element);
+                const opening = element.openingElement.name;
+                if (opening.type === "JSXIdentifier" && pureHalf.has(opening.name))
+                    drawsPage = true;
+                if (name !== null && PAGE_PARTS.has(name)) {
+                    // The part's own finding already says to draw a `Page` instead; the missing Page is not reported twice.
+                    drawsPage = true;
+                    context.report({ node: element, messageId: "part", data: { name } });
+                    return;
+                }
+                if (name !== "Page")
+                    return;
+                drawsPage = true;
+                const parent = element.parent;
+                if (parent.type !== "JSXElement" && parent.type !== "JSXFragment")
+                    return;
+                if (renderedChildren(parent.children).length > 1)
+                    context.report({ node: element, messageId: "sibling" });
+            },
+            "Program:exit"() {
+                if (judgeMissing && first !== null && !drawsPage)
+                    context.report({ node: first, messageId: "missing" });
+            },
+        };
+    },
+});
+const tabsRules = { "page-tabs-in-header": pageTabsInHeader };
+const rootRules = { "route-page-is-one-page": routePageIsOnePage };
+defineFamilyRules(tabsRules, "knowledge/hfs/rules.yaml#R324");
+defineFamilyRules(rootRules, "knowledge/hfs/rules.yaml#R325");
+/** The rules these laws contribute to the plugin. */
+export const rules = { ...tabsRules, ...rootRules };
+/** Every rule of these laws is an error. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-grammar/${name}`, "error"]));

package/docs/page.md

@@ -0,0 +1,64 @@
+# A route page is one Page
+
+Law module: `page.ts`. Catalogue: R324 FE_PAGE_TABS_OUTSIDE_HEADER, R325 FE_ROUTE_PAGE_OUTSIDE_PAGE.
+
+Grammar's `Page` is a route page: the header band full width, then the body inside the page measure and gutter one region step below it. It is the single owner of the page inset and the page rhythm, so the page tabs belong to its header and nothing of the page sits beside it.
+
+Every rule below is an error in `coreGrammarConfig`; none can be switched off or suppressed inline.
+
+## `starci-grammar/page-tabs-in-header`
+
+A `Tabs` element that is the first element child of a `Page`, or the next element sibling of a `PageHeader`, is a finding, reported on the `Tabs`. Whitespace text and JSX comments are not children. A `Tabs` lower in the body, or inside a body section, is region tabs and is not judged.
+
+**Invalid** (`src/features/pages/ConnectionPage/component.tsx`)
+
+```tsx
+<Page header={{ title: "Main account" }}>
+  <Tabs label="Connection" items={items} selectedKey={tab} onSelect={setTab} />
+  <WebhookCard />
+</Page>
+```
+
+**Valid**
+
+```tsx
+<Page header={{ title: "Main account", tabs: { label: "Connection", items, selectedKey: tab, onSelect: setTab } }}>
+  <WebhookCard />
+</Page>
+```
+
+**Finding code:** `FE_PAGE_TABS_OUTSIDE_HEADER`
+
+## `starci-grammar/route-page-is-one-page`
+
+In a page owner (`fe.feature`, kind `pages`), a `Page` with an element sibling in its parent is a finding, and so is any `PageHeader` or `PageContainer`: both are Page's own parts. A page owner file that draws JSX but no `Page`, and draws no element imported from its own pure half (`./component`), is a finding too, reported on its first element: the page has no frame at all. A `Page` alone in a fragment or a provider, and one `Page` per branch of a conditional, are legal. Files outside a page owner are not judged, and the segment boundary owners of FE-BOUNDARY-1 (`*ErrorPage`, `*LoadingPage`, `*NotFoundPage`) are not judged for a missing `Page`: an app-level boundary stands in for whichever page failed or waits and draws its notice.
+
+**Invalid** (`src/features/pages/ConnectionPage/component.tsx`)
+
+```tsx
+<>
+  <PageHeader title="Main account" />
+  <PageContainer><WebhookCard /></PageContainer>
+</>
+```
+
+**Invalid** (`src/features/pages/HomePage/component.tsx`)
+
+```tsx
+<>
+  <Heading level={1}>Home</Heading>
+  <SignInForm />
+</>
+```
+
+**Valid**
+
+```tsx
+<Page header={{ title: "Main account" }}>
+  <WebhookCard />
+</Page>
+```
+
+**Finding code:** `FE_ROUTE_PAGE_OUTSIDE_PAGE`
+
+Rule ownership: [FE-RULE-OWNERSHIP](../../../contexts/code/fe/README.md#the-placement-test-fe-rule-ownership).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-grammar-core",
-  "version": "0.15.3",
+  "version": "0.15.6",
   "description": "ESLint rules for the core Grammar's component, token and composition contracts.",
   "keywords": [
     "eslint",
@@ -41,7 +41,7 @@
     "node": ">=22"
   },
   "peerDependencies": {
-    "@starci/eslint-canon-fe": "9.4.3",
+    "@starci/eslint-canon-fe": "9.4.5",
     "eslint": ">=9",
     "typescript": ">=5.9"
   },

package/runtime/knowledge/hfs/canon-pins.yaml

@@ -31,35 +31,35 @@ pins:
     source: packages/event-stream/package.json
     why: 'the one server-sent-events client of every front end (fe-stack event-stream, owner:event-stream-package): the transport client layer (modules/api/sse/clients) creates one instance for the app with the bearer token source and the stream operations follow on it; it carries Last-Event-ID resume, the capped doubling backoff, the heartbeat timeout, the single 401 renewal and the useSWRSubscription adapter, so no app keeps a hand-written reader.'
   '@starci/grammar':
-    version: 0.15.3
+    version: 0.15.6
     group: starci
     install: registry
     side: fe
     source: packages/grammar/package.json
     why: 'the grammar front ends read: the brand layer sets `--font-sans` and `--font-mono` and the grammar reads them; it carries the Input tel kind, the copyable and read-only Input, the IconButton disclosure props and count badge, ChatBubble, FillViewport, Textarea mentions and Enter-to-send, the leading PrimaryRailLayout rail, the plate-less Image, ListRow, the soft Alert, Progress steps, the floating primary IconButton, FlowGraph, the STATE-8 loading views and the bordered selectable TagGroup chips. The runtime source version wins for a @starci package.'
   '@starci/eslint-canon-be':
-    version: 3.6.3
+    version: 3.6.4
     group: starci
     install: registry
     side: be
     source: packages/eslint-canon-be/package.json
     why: 'the back-end ESLint canon: `loadHfs(import.meta.url)` of be/eslint.config.mjs finds the app-root hfs.json (kind app) and gives every linted file the view of the be side, and the project graph is built per side; its bundled runtime copies (slots, canon-pins, failure codes, the architecture machine) put .starcistacks and .sops.yaml at the app root; `starciBeConfig({ hfs: loadHfs(import.meta.url) })` is the typed factory and the BE-CONVENTION laws are its rules.'
   '@starci/eslint-canon-fe':
-    version: 9.4.3
+    version: 9.4.5
     group: starci
     install: registry
     side: fe
     source: packages/eslint-canon-fe/package.json
     why: 'the front-end ESLint canon: `loadHfs(import.meta.url)` of fe/eslint.config.mjs finds the app-root hfs.json (kind app) and gives every linted file the view of the fe side, and the project graph is built per side; its bundled runtime copies (slots, canon-pins, failure codes, the architecture machine) put .starcistacks and .sops.yaml at the app root; the front end has no tests (FE_NO_TESTS R97 in hfs) and no-vietnamese-in-source (R91) applies.'
   '@starci/eslint-grammar-core':
-    version: 0.15.3
+    version: 0.15.6
     group: starci
     install: registry
     side: fe
     source: packages/eslint-grammar-core/package.json
     why: 'the StarCi Grammar component API lint, versioned with @starci/grammar; front ends compose this family package with the universal FE canon.'
   '@starci/eslint-grammar-offset-pop':
-    version: 0.15.3
+    version: 0.15.6
     group: starci
     install: registry
     side: fe
@@ -106,7 +106,7 @@ pins:
     source: packages/ai-router/package.json
     why: 'the AI pool router of a back end: a NestJS module that routes OpenAI-compatible chat, stream and embeddings calls across keys, models and providers, with @starci/ai-router/testing for its specs; @starci/jest-preset compiles it as an ESM-only dependency.'
   '@starci/hfs':
-    version: 4.9.4
+    version: 4.9.8
     group: starci
     install: registry
     side: both
@@ -487,7 +487,7 @@ pins:
     version: 11.16.0
     group: ui
     side: fe
-    why: 'diagrams (fe-stack diagrams); version read from the starci-academy package-lock on 2026-10-13.'
+    why: 'runtime dependency of @starci/grammar for MermaidDiagram (fe-stack diagrams), imported lazily on the first diagram and themed from the grammar root; apps render diagrams through MermaidDiagram and never import mermaid.'
   'react-dropzone':
     version: 15.0.0
     group: ui

package/runtime/knowledge/hfs/rules.yaml

@@ -3894,7 +3894,7 @@ rules:
       - {kind: runtime, id: protected-zone, at: scripts/hfs/runtime-rules/rights-policy.mjs}
   - id: R225
     code: "RT_HOOK_SHAPE"
-    law: "The app hook templates keep the gate model: pre-commit is L0 only (no typecheck or test run); pre-push invokes the bundled scripts/guards/release-push-gate.mjs policy for fast-forward main, a clean outgoing secret scan and annotated v* tags. It runs no build, test, typecheck or lint."
+    law: "The app hook templates keep the gate model: pre-commit is L0 only (no typecheck or test run); pre-push invokes the bundled scripts/guards/release-push-gate.mjs policy for fast-forward main, a clean outgoing secret scan and annotated v* tags, then the harness's `starci deps check` (every committed @starci pin installable from npm, no local package copy ahead of npm). It runs no build, test, typecheck or lint."
     scope: runtime
     kinds: [check]
     gates: [land, runtime]
@@ -5710,3 +5710,49 @@ rules:
         source: owner
         quote: "Publish Grammar 0.15.3 with PageHeader now, then move all 18 pages to it before deploying. (translated from Vietnamese)"
         ruling: "A page is headed by Grammar's PageHeader (owner ruling page-header-band): a surface band whose content shares the page content's edges and which ends in its own full-width separator, page tabs standing on it; the lint refuses a page head composed by hand from Breadcrumbs and SectionHeader."
+  - id: R324
+    code: "FE_PAGE_TABS_OUTSIDE_HEADER"
+    law: "Page tabs are the header's tabs; a Tabs that is the first element of a Page body or the next element after a PageHeader is a page tab bar drawn outside the band."
+    kinds: [lint]
+    gates: [pre-commit, settle, land, ci]
+    failureCodes: ["FE_PAGE_TABS_OUTSIDE_HEADER"]
+    enforcers:
+      - {kind: eslint-grammar-core, id: page-tabs-in-header}
+    editions: [lite, full]
+    docs: [knowledge/patterns/fe/index.yaml#FE-RULE-OWNERSHIP]
+    templateNa: "A template states no page; the pages are the app's."
+    proves:
+      - packages/eslint-grammar-core/src/page.spec.ts
+    exemplifiedBy:
+      - {path: packages/eslint-grammar-core/src/page.spec.ts, editions: [lite, full], codes: [FE_PAGE_TABS_OUTSIDE_HEADER]}
+    witness:
+      - {path: packages/eslint-grammar-core/src/page.spec.ts, editions: [lite, full], codes: [FE_PAGE_TABS_OUTSIDE_HEADER]}
+    cases:
+      - id: case-1
+        date: "2026-10-28"
+        source: owner
+        quote: "ok trò"
+        ruling: "A route page is one Grammar Page (owner ruling page-frame); page tabs are its header's tabs, and the lint refuses a Tabs at the top of the Page body or right after a PageHeader."
+  - id: R325
+    code: "FE_ROUTE_PAGE_OUTSIDE_PAGE"
+    law: "A page owner draws one Grammar Page with nothing beside it; a sibling of the Page, or a bare PageHeader or PageContainer in the page owner, re-decides the inset and rhythm Page owns."
+    kinds: [lint]
+    gates: [pre-commit, settle, land, ci]
+    failureCodes: ["FE_ROUTE_PAGE_OUTSIDE_PAGE"]
+    enforcers:
+      - {kind: eslint-grammar-core, id: route-page-is-one-page}
+    editions: [lite, full]
+    docs: [knowledge/patterns/fe/index.yaml#FE-RULE-OWNERSHIP]
+    templateNa: "A template states no page; the pages are the app's."
+    proves:
+      - packages/eslint-grammar-core/src/page.spec.ts
+    exemplifiedBy:
+      - {path: packages/eslint-grammar-core/src/page.spec.ts, editions: [lite, full], codes: [FE_ROUTE_PAGE_OUTSIDE_PAGE]}
+    witness:
+      - {path: packages/eslint-grammar-core/src/page.spec.ts, editions: [lite, full], codes: [FE_ROUTE_PAGE_OUTSIDE_PAGE]}
+    cases:
+      - id: case-1
+        date: "2026-10-28"
+        source: owner
+        quote: "ok trò"
+        ruling: "A route page is one Grammar Page (owner ruling page-frame): the single owner of the page inset and rhythm; the lint refuses a sibling beside the Page and a bare PageHeader or PageContainer in a page owner."