@starci/eslint-canon-fe 9.9.7 → 9.9.9

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 9.9.9
+
+- Changed: Preserve mounted RootPage children through selected native body layouts only when their metadata constraints, immutable props and required context are proven. Retain exact body and import identity, and refresh the generated canon pins.
+
+## 9.9.8
+
+- Changed: Enforce the documented one-level connected RootPage children composition with mounted selected-export and actual sibling-Base proof shared with R325. Keep ordinary block/atom restrictions and inspect shape records for rendered trees.
+- Fixed: Virtual RuleTester files refuse the RootPage children capability before disk parsing; unsaved content keeps the on-disk source identity guard.
+
 ## 9.9.7
 
 - Changed: Bundled canon pins name the builder-provenance BE canon release and its coherent dependency cohort. This package changes no runtime behavior or rule severity.

package/README.md

@@ -56,6 +56,12 @@ declare intent and leave variants to Grammar. It contains destructive confirms i
 dialog, counts mutually exclusive render paths separately and reserves commit for the view's
 decision rather than repeated collection items.
 
+The R92 `tier-children` and `base-props-atom` checks share the existing R325 one-level RootPage proof: a mounted
+page or segment layout composes one connected root, that root renders its own Base, and the Base owns the selected
+canonical page renderer. Only those exact input members may take `children`; ordinary blocks, relays, fake or unused
+renderers and shape records containing rendered trees remain refused. The selected canonical Grammar catalog owns
+semantic renderer bindings; universal code carries no concrete renderer spelling.
+
 Regression specs belong to this package. Application front ends and Grammar libraries have no specs.
 
 ## The runtime copy

package/dist/drawing.d.ts

@@ -9,7 +9,7 @@
  * THE PURE HALF TAKES ATOMS. `component.tsx` receives `{ shape?, props, on? }`: `props` is data
  * (strings, numbers, booleans, arrays, plain objects), `on` is actions whose arguments are data,
  * and feature composition may also take named `render` callbacks inside `props` to render supplied
- * blocks. A layout alone also takes `children`, because the router puts the page there.
+ * blocks. A layout takes the router's `children`; the proven one-level connected root of a route Page and its Base take that owner's children into the Page body.
  *
  * 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.
@@ -20,7 +20,7 @@
  */
 import { type Rules, type Recommended } from "./lib/rule.js";
 /** The pure half takes atom data and actions; feature composition may receive named render callbacks. */
-export declare const basePropsAtom: import("./lib/rule.js").Rule<"action" | "tree" | "onData" | "member" | "renamed", []>;
+export declare const basePropsAtom: import("./lib/rule.js").Rule<"action" | "member" | "tree" | "onData" | "renamed", []>;
 /** Only the sibling `index.tsx` (and its specs) may reach `component.tsx`; only `X` leaves the folder. */
 export declare const baseImportPair: import("./lib/rule.js").Rule<"reach" | "reexport", []>;
 /** A surface's `XShape` names drawn shapes only: no data status, no open/closed, no status flag. */

package/dist/drawing.js

@@ -9,7 +9,7 @@
  * THE PURE HALF TAKES ATOMS. `component.tsx` receives `{ shape?, props, on? }`: `props` is data
  * (strings, numbers, booleans, arrays, plain objects), `on` is actions whose arguments are data,
  * and feature composition may also take named `render` callbacks inside `props` to render supplied
- * blocks. A layout alone also takes `children`, because the router puts the page there.
+ * blocks. A layout takes the router's `children`; the proven one-level connected root of a route Page and its Base take that owner's children into the Page body.
  *
  * 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.
@@ -20,6 +20,7 @@
  */
 import { defineRule } from "./lib/rule.js";
 import { classifyImport, roleOfFile } from "./lib/scope.js";
+import { rootPageChildren } from "./lib/root-page.js";
 import { inSplitTier, pureHalf } from "./lib/drawing-scope.js";
 /** 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)$/;
@@ -85,7 +86,7 @@ const keyOf = (member) => {
 export const basePropsAtom = defineRule({
     meta: {
         type: "problem",
-        docs: { description: "A pure `XBase` takes `shape`, atom `props` and `on` actions; feature composition may receive named render callbacks in `props`." },
+        docs: { description: "A pure `XBase` takes `shape`, atom `props` and `on` actions; a layout and a structurally proven RootPage may take children." },
         fixable: "code",
         schema: [],
         messages: {
@@ -213,8 +214,10 @@ export const basePropsAtom = defineRule({
                 for (const member of membersOf(annotation, types)) {
                     const key = keyOf(member);
                     const type = memberType(member);
-                    if (key === "shape")
+                    if (key === "shape") {
+                        checkData(type, "shape", new Set());
                         continue;
+                    }
                     if (key === "state") {
                         const stateKey = "key" in member ? member.key : undefined;
                         context.report({
@@ -228,7 +231,7 @@ export const basePropsAtom = defineRule({
                         checkData(type, "props", new Set());
                     else if (key === "on")
                         checkActions(type);
-                    else if (key === "children" && tier === "layouts")
+                    else if (key === "children" && (tier === "layouts" || tier === "blocks" && rootPageChildren(context, member)))
                         continue;
                     else {
                         context.report({

package/dist/hooks-folder.d.ts

@@ -27,7 +27,7 @@
  */
 import { type Rules, type Recommended } from "./lib/rule.js";
 /** `hooks/` holds React hooks, each under the name its family or domain gives it, and one shared helper file per domain. */
-export declare const hooksFolderHoldsHooksOnly: import("./lib/rule.js").Rule<"server" | "missing" | "defaultExport" | "export" | "many" | "fake" | "domain" | "notHook" | "family" | "subscription" | "sharedHook", []>;
+export declare const hooksFolderHoldsHooksOnly: import("./lib/rule.js").Rule<"server" | "missing" | "export" | "defaultExport" | "many" | "fake" | "domain" | "notHook" | "family" | "subscription" | "sharedHook", []>;
 /** The rules this law contributes to the plugin. */
 export declare const rules: Rules;
 /** Every rule is an error. */

package/dist/lib/cross-file-inputs.d.ts

@@ -32,5 +32,4 @@ export interface CrossFileInput {
 }
 /** The line count above which `file-size-growth` reads history: the soft budget of the shipped manifest (500) is never lower than this. */
 export declare const HISTORY_MIN_LINES = 400;
-/** Every disk read of this canon's rules beyond the import graph. */
 export declare const crossFileInputs: readonly CrossFileInput[];

package/dist/lib/cross-file-inputs.js

@@ -19,7 +19,14 @@
 /** The line count above which `file-size-growth` reads history: the soft budget of the shipped manifest (500) is never lower than this. */
 export const HISTORY_MIN_LINES = 400;
 /** Every disk read of this canon's rules beyond the import graph. */
+const ROOT_PAGE_INPUTS = ["**/src/app/**/*.{ts,tsx}", "**/src/features/**/*.{ts,tsx}", "**/src/components/{blocks,frames,composites,branches,leaves}/**/*.{ts,tsx}", "packages/*/package.json", "packages/*/src/**/*.{ts,tsx}"];
+const ROOT_PAGE_DEPENDANTS = ["**/src/components/blocks/**/*.{ts,tsx}"];
 export const crossFileInputs = [
+    ...["tier-children", "base-props-atom"].flatMap((rule) => [
+        { rule, kind: "content", relativeTo: "side", globs: ROOT_PAGE_INPUTS, appliesTo: ROOT_PAGE_DEPENDANTS, reader: "lib/owner-source.ts" },
+        { rule, kind: "content", relativeTo: "side", globs: ROOT_PAGE_INPUTS, appliesTo: ROOT_PAGE_DEPENDANTS, reader: "lib/root-page.ts" },
+        { rule, kind: "exists", relativeTo: "side", globs: ["**/src/app", "**/src/app/**"], appliesTo: ROOT_PAGE_DEPENDANTS, reader: "lib/root-page.ts" },
+    ]),
     // the manifest name of the package that owns the linted file (the nearest package.json upward)
     { rule: "no-grammar-shim", kind: "content", relativeTo: "side", globs: ["**/package.json", "../package.json"], appliesTo: ["**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"], reader: "grammar-shim.ts" },
     // an operation import is told from a workspace package by that package's manifest and entry

package/dist/lib/eslint-boundary.d.ts

@@ -8,8 +8,8 @@
  * run time, so the two views are joined here, in one place, and nowhere else.
  */
 import type { TSESLint } from "@typescript-eslint/utils";
-import type { ESLint, Rule as EslintRule } from "eslint";
-import type { Rule, Rules } from "./rule.js";
+import type { SourceCode as EslintSourceCode, ESLint, Rule as EslintRule } from "eslint";
+import type { SourceCode, Rule, Rules } from "./rule.js";
 /** A canon rule (or a rule already written at ESLint's type, as the Grammar families write theirs) as ESLint's rule type: the same object. */
 export declare const eslintRule: (rule: Rule<string, readonly unknown[]> | EslintRule.RuleModule) => EslintRule.RuleModule;
 /** A rule at typescript-eslint's rule type with mutable options, the type the shared back-end fixtures declare their testers with: the same object. */
@@ -21,3 +21,5 @@ export declare const eslintPlugin: (plugin: {
     };
     readonly rules: Rules;
 }) => ESLint.Plugin;
+/** The independently parsed source object at the same ESLint/typescript-eslint boundary. */
+export declare const sourceCodeView: (sourceCode: EslintSourceCode) => SourceCode;

package/dist/lib/eslint-boundary.js

@@ -4,3 +4,5 @@ export const eslintRule = (rule) => rule;
 export const sharedRule = (rule) => rule;
 /** The canon's rules as an ESLint plugin: the same objects, under ESLint's plugin type. */
 export const eslintPlugin = (plugin) => plugin;
+/** The independently parsed source object at the same ESLint/typescript-eslint boundary. */
+export const sourceCodeView = (sourceCode) => sourceCode;

package/dist/lib/owner-source.d.ts

@@ -0,0 +1,26 @@
+import type { TSESTree } from "@typescript-eslint/types";
+import type { Node, AnyContext } from "./rule.js";
+/** The actual lint context with its independently parsed owner program. */
+export interface ParsedContext extends AnyContext {
+    readonly program: TSESTree.Program;
+}
+export type ReaderContext = AnyContext;
+/** An exported value together with the parsed file that holds it. */
+export interface Owner {
+    readonly context: ParsedContext;
+    readonly value: Node;
+}
+export declare const sourceFile: (context: ReaderContext, source: string) => string | null;
+/** The selected exported value, following public barrels without scanning unrelated imported implementations. */
+export declare const headerExport: (context: ParsedContext, name: string, seen?: Set<string>) => Owner | null;
+/** The actual value import a JSX tag selects, including import aliases and namespaces. */
+export declare const jsxImport: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => {
+    readonly source: string;
+    readonly exported: string;
+} | null;
+/** An imported JSX owner, or null when its implementation cannot be proved from owned source. */
+export declare const importedHeader: (context: ReaderContext, opening: TSESTree.JSXOpeningElement) => Owner | null;
+/** A file of the app parsed on its own (a route `layout`), sharing the run's parse cache. */
+export declare const parsedSource: (context: ReaderContext, filename: string) => ParsedContext;
+/** The per-repository proof cache shares the same lifetime as parsed header source. */
+export declare const headerProofs: (context: ReaderContext) => Map<string, boolean>;

package/dist/lib/owner-source.js

@@ -0,0 +1,187 @@
+/** Resolve only an imported header's owned source and selected public export. */
+import fs from "node:fs";
+import path from "node:path";
+import { RUNTIME_ROOT } from "./package-root.js";
+import ts from "typescript";
+import parser from "@typescript-eslint/parser";
+import { SourceCode } from "eslint";
+import { importOf, variableOf } from "./bindings.js";
+import { resolveImport } from "./scope.js";
+import { hfsOf } from "./hfs.js";
+import { walk } from "./ast.js";
+import { sourceCodeView } from "./eslint-boundary.js";
+import { loadArchitectureConfig } from "#runtime/scripts/hfs/architecture/config.mjs";
+import { workspaceSourceEntry } from "#runtime/scripts/hfs/architecture/typescript.mjs";
+import { openHfs } from "#runtime/scripts/hfs/slots.mjs";
+const RUNTIME = RUNTIME_ROOT;
+const roots = new WeakMap();
+const origins = new WeakMap();
+const stateOf = (context) => {
+    const root = hfsOf(context).repoRoot;
+    const snapshot = origins.get(context.sourceCode) ?? context.sourceCode;
+    let state = roots.get(snapshot);
+    if (state === undefined) {
+        state = { root, files: new Map(), proofs: new Map(), workspaces: null };
+        roots.set(snapshot, state);
+    }
+    return state;
+};
+/** A workspace package from the text of its `package.json`. */
+const workspaceOf = (root, text) => {
+    const manifest = JSON.parse(text);
+    const record = typeof manifest === "object" && manifest !== null ? manifest : {};
+    return {
+        root,
+        workspace: true,
+        name: "name" in record && typeof record.name === "string" ? record.name : null,
+        manifest,
+        exports: "exports" in record ? record.exports : undefined
+    };
+};
+const workspaceFile = (context, source) => {
+    const state = stateOf(context);
+    if (!state.workspaces) {
+        const hfs = openHfs({ root: RUNTIME, repoRoot: state.root });
+        const config = loadArchitectureConfig(state.root, { hfs });
+        state.workspaces = config.workspaces.map((relative) => {
+            const root = path.join(state.root, relative);
+            return workspaceOf(root, fs.readFileSync(path.join(root, "package.json"), "utf8"));
+        });
+    }
+    const workspace = state.workspaces.find((entry) => entry.name && (source === entry.name || source.startsWith(`${entry.name}/`)));
+    return workspace ? workspaceSourceEntry(ts, workspace, source) : null;
+};
+export const sourceFile = (context, source) => {
+    const target = resolveImport(context, source) ?? workspaceFile(context, source);
+    if (!target)
+        return null;
+    const hfs = hfsOf(context);
+    return ([target, `${target}.tsx`, `${target}.ts`, `${target}/index.tsx`, `${target}/index.ts`].find((file) => /\.[cm]?[jt]sx?$/i.test(file) && !/\.d\.[cm]?ts$/i.test(file) && ts.sys.fileExists(file) && hfs.classify(file).status === "owned") ?? null);
+};
+/** Record the parent of a child node: the parser leaves it to ESLint's traversal, which this independent parse bypasses. */
+const adopt = (child, parent) => {
+    if (typeof child === "object" && child !== null && "type" in child && child.type)
+        Reflect.set(child, "parent", parent);
+};
+const sourceContext = (context, filename) => {
+    const state = stateOf(context);
+    const known = state.files.get(filename);
+    if (known)
+        return known;
+    const text = fs.readFileSync(filename, "utf8");
+    const parsed = parser.parseForESLint(text, {
+        filePath: filename,
+        sourceType: "module",
+        ecmaFeatures: { jsx: true },
+        range: true,
+        loc: true,
+        tokens: true,
+        comment: true
+    });
+    const sourceCode = new SourceCode({
+        text,
+        ast: parsed.ast,
+        scopeManager: parsed.scopeManager,
+        visitorKeys: parsed.visitorKeys,
+        parserServices: parsed.services
+    });
+    const view = sourceCodeView(sourceCode);
+    walk(view, parsed.ast, (node) => {
+        for (const key of view.visitorKeys[node.type] ?? []) {
+            const value = Reflect.get(node, key);
+            const values = Array.isArray(value) ? value : [value];
+            for (const child of values)
+                adopt(child, node);
+        }
+    });
+    const owned = {
+        ...context,
+        filename,
+        getFilename: () => filename,
+        settings: context.settings,
+        sourceCode: view,
+        program: parsed.ast
+    };
+    origins.set(view, origins.get(context.sourceCode) ?? context.sourceCode);
+    state.files.set(filename, owned);
+    return owned;
+};
+const moduleContext = (context, source) => {
+    const filename = sourceFile(context, source);
+    return filename ? sourceContext(context, filename) : null;
+};
+const namedDeclaration = (declaration, name) => {
+    if (declaration?.type === "FunctionDeclaration")
+        return declaration.id?.name === name ? declaration : null;
+    if (declaration?.type !== "VariableDeclaration")
+        return null;
+    return declaration.declarations.find((entry) => entry.id.type === "Identifier" && entry.id.name === name)?.init ?? null;
+};
+/** The name an export specifier spells: an identifier's name or a string literal's value. */
+const specifierName = (name) => (name.type === "Identifier" ? name.name : name.value);
+const namedExport = (context, statement, name, visited) => {
+    const value = namedDeclaration(statement.declaration, name);
+    if (value)
+        return { matched: true, owner: { context, value } };
+    const specifier = statement.specifiers.find((entry) => specifierName(entry.exported) === name);
+    if (!specifier)
+        return { matched: false };
+    if (!statement.source)
+        return { matched: true, owner: { context, value: specifier.local } };
+    const target = moduleContext(context, String(statement.source.value));
+    return { matched: true, owner: target ? headerExport(target, specifierName(specifier.local), visited) : null };
+};
+/** The selected exported value, following public barrels without scanning unrelated imported implementations. */
+export const headerExport = (context, name, seen = new Set()) => {
+    const key = `${context.filename}:${name}`;
+    if (seen.has(key))
+        return null;
+    const visited = new Set(seen).add(key);
+    for (const statement of context.program.body) {
+        if (statement.type === "ExportDefaultDeclaration" && name === "default")
+            return { context, value: statement.declaration };
+        if (statement.type === "ExportNamedDeclaration") {
+            const found = namedExport(context, statement, name, visited);
+            if (found.matched)
+                return found.owner;
+        }
+        if (statement.type === "ExportAllDeclaration") {
+            const target = moduleContext(context, String(statement.source.value));
+            const found = target && headerExport(target, name, visited);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+};
+/** The actual value import a JSX tag selects, including import aliases and namespaces. */
+export const jsxImport = (context, opening) => {
+    const name = opening.name;
+    const identifier = name.type === "JSXIdentifier" ? name : name.type === "JSXMemberExpression" ? name.object : null;
+    if (identifier?.type !== "JSXIdentifier")
+        return null;
+    const imported = importOf(context, identifier);
+    if (!imported)
+        return null;
+    const definition = variableOf(context, identifier)?.defs.find((entry) => entry.type === "ImportBinding");
+    if (definition?.type !== "ImportBinding" ||
+        definition.parent.importKind === "type" ||
+        (definition.node.type === "ImportSpecifier" && definition.node.importKind === "type"))
+        return null;
+    if (name.type === "JSXMemberExpression" && definition?.node.type !== "ImportNamespaceSpecifier")
+        return null;
+    const exported = name.type === "JSXMemberExpression" ? name.property.name : (imported.imported ?? "default");
+    return { source: imported.source, exported };
+};
+/** An imported JSX owner, or null when its implementation cannot be proved from owned source. */
+export const importedHeader = (context, opening) => {
+    const imported = jsxImport(context, opening);
+    if (!imported)
+        return null;
+    const target = moduleContext(context, imported.source);
+    return target ? headerExport(target, imported.exported) : null;
+};
+/** A file of the app parsed on its own (a route `layout`), sharing the run's parse cache. */
+export const parsedSource = (context, filename) => sourceContext(context, filename);
+/** The per-repository proof cache shares the same lifetime as parsed header source. */
+export const headerProofs = (context) => stateOf(context).proofs;

package/dist/lib/page-body.d.ts

@@ -0,0 +1,17 @@
+/** Finite content provenance inside a root Page: static grammar anatomy, local pure drawing, canonical region status. */
+import type { TSESTree } from "@typescript-eslint/utils";
+import { type Owner } from "./owner-source.js";
+import type { Node } from "./rule.js";
+export interface BodyReaders {
+    readonly resolve: (owner: Owner | null) => Owner | null;
+    readonly returned: (owner: Owner) => readonly Node[] | null;
+}
+interface Content {
+    readonly owner: Owner;
+    readonly field: string;
+}
+/** A field of the actual selected function parameter, never a matching identifier spelling. */
+export declare const parameterMember: (content: Content, node: Node | null) => boolean;
+/** Only Page's body carries owner content; a header/unknown attribute/dead callback cannot stand in for it. */
+export declare const preservesPageBody: (owner: Owner, page: TSESTree.JSXElement, readers: BodyReaders) => boolean;
+export {};

package/dist/lib/page-body.js

@@ -0,0 +1,244 @@
+import { grammarContractFor } from "#runtime/scripts/lib/grammar-lint.mjs";
+import { canonicalStatusOwnerBinding } from "#runtime/scripts/hfs/architecture/canon-jsx-clones.mjs";
+import { attribute, attributeValue, stringOf, walk } from "./ast.js";
+import { isFn, unwrap, variableOf } from "./bindings.js";
+import { hfsOf } from "./hfs.js";
+import { importedHeader, jsxImport } from "./owner-source.js";
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A field of the actual selected function parameter, never a matching identifier spelling. */
+export const parameterMember = (content, node) => {
+    const { owner, field } = content;
+    if (!isFn(owner.value) ||
+        !node ||
+        node.type !== "MemberExpression" ||
+        node.computed ||
+        node.property.type !== "Identifier" ||
+        node.property.name !== field ||
+        node.object.type !== "Identifier")
+        return false;
+    const parameter = owner.value.params[0];
+    return (parameter?.type === "Identifier" &&
+        variableOf(owner.context, node.object)?.defs.some((definition) => definition.type === "Parameter" && definition.name === parameter) === true);
+};
+const references = (content, node) => {
+    let count = 0;
+    walk(content.owner.context.sourceCode, node, (child) => {
+        if (parameterMember(content, child))
+            count += 1;
+    });
+    return count;
+};
+const bodyContainer = (owner, opening, contexts) => {
+    const family = hfsOf(owner.context).grammar;
+    if (!family)
+        return null;
+    const roles = grammarContractFor(family).semanticRoles;
+    const page = record(roles) ? roles.page : null;
+    if (!record(page) || !Array.isArray(page.bodyContainers) || !Array.isArray(page.entries))
+        return null;
+    const imported = jsxImport(owner.context, opening);
+    if (!imported || !page.bodyContainers.includes(imported.exported) || !page.entries.some((entry) => typeof entry === "string" && entry.replace("<family>", family) === imported.source))
+        return null;
+    if (page.bodyContainerConstraints !== undefined && !record(page.bodyContainerConstraints))
+        return null;
+    const constraint = record(page.bodyContainerConstraints) ? page.bodyContainerConstraints[imported.exported] : undefined;
+    if (constraint === undefined)
+        return contexts;
+    if (!record(constraint) || Object.keys(constraint).some((key) => !["requiresContext", "providesContext", "absentProps", "literalProps"].includes(key)))
+        return null;
+    if (constraint.requiresContext !== undefined && (typeof constraint.requiresContext !== "string" || !contexts.has(constraint.requiresContext)))
+        return null;
+    if (constraint.absentProps !== undefined) {
+        const absent = constraint.absentProps;
+        if (!Array.isArray(absent) || !absent.every((name) => typeof name === "string"))
+            return null;
+        if (opening.attributes.some((item) => item.type === "JSXAttribute" && item.name.type === "JSXIdentifier" && absent.includes(item.name.name)))
+            return null;
+    }
+    if (constraint.literalProps !== undefined) {
+        if (!record(constraint.literalProps))
+            return null;
+        for (const [name, choices] of Object.entries(constraint.literalProps)) {
+            if (!Array.isArray(choices) || !choices.every((choice) => typeof choice === "string"))
+                return null;
+            for (const item of opening.attributes) {
+                if (item.type !== "JSXAttribute" || item.name.type !== "JSXIdentifier" || item.name.name !== name)
+                    continue;
+                const value = attributeValue(item);
+                const literal = value && stringOf(unwrap(value));
+                if (literal === null || !choices.includes(literal))
+                    return null;
+            }
+        }
+    }
+    if (constraint.providesContext === undefined)
+        return contexts;
+    return typeof constraint.providesContext === "string" ? new Set(contexts).add(constraint.providesContext) : null;
+};
+/** The exactly returned fragment/expression, with no unused or duplicated call hidden beside it. */
+const returnedCall = (node) => {
+    const value = unwrap(node);
+    if (value.type === "CallExpression")
+        return value;
+    if (value.type !== "JSXFragment")
+        return null;
+    const children = value.children.filter((child) => child.type !== "JSXText" || child.value.trim() !== "");
+    const expression = children.length === 1 && children[0]?.type === "JSXExpressionContainer" ? children[0].expression : null;
+    return expression?.type === "CallExpression" ? expression : null;
+};
+/** Prove the selected SlotView implementation really calls render on loading/ready, and never on refusal. */
+const canonicalRegion = (owner, readers) => {
+    const found = hfsOf(owner.context).classify(owner.context.filename);
+    if (found.status !== "owned" || found.slot !== "fe.components" || found.kind !== "composites" || found.role !== "entry")
+        return false;
+    if (!isFn(owner.value) || owner.value.body.type !== "BlockStatement")
+        return false;
+    const body = owner.value.body.body;
+    const active = body.filter((statement) => statement.type !== "VariableDeclaration");
+    if (active.length !== 5 || active.slice(0, 4).some((statement) => statement.type !== "IfStatement" || statement.alternate !== null))
+        return false;
+    const states = ["isLoading", "isForbidden", "isError", "isEmpty"];
+    let slot = null;
+    for (const [index, statement] of active.slice(0, 4).entries()) {
+        if (statement.type !== "IfStatement" ||
+            statement.test.type !== "BinaryExpression" ||
+            statement.test.operator !== "in" ||
+            statement.test.left.type !== "Literal" ||
+            statement.test.left.value !== states[index] ||
+            statement.test.right.type !== "Identifier")
+            return false;
+        if (slot && variableOf(owner.context, slot) !== variableOf(owner.context, statement.test.right))
+            return false;
+        slot = statement.test.right;
+    }
+    if (!slot)
+        return false;
+    const slotBinding = variableOf(owner.context, slot);
+    const definition = slotBinding?.defs[0];
+    const parameter = owner.value.params[0];
+    if (definition?.type !== "Variable" ||
+        definition.parent.kind !== "const" ||
+        definition.node.id.type !== "ObjectPattern" ||
+        definition.node.init?.type !== "Identifier" ||
+        parameter?.type !== "Identifier" ||
+        variableOf(owner.context, definition.node.init)?.defs.some((item) => item.type === "Parameter" && item.name === parameter) !== true)
+        return false;
+    const slotProperty = definition.node.id.properties.find((property) => property.type === "Property" && property.key.type === "Identifier" && property.key.name === "slot");
+    if (slotProperty?.type !== "Property" || slotProperty.value.type !== "Identifier" || variableOf(owner.context, slotProperty.value) !== slotBinding)
+        return false;
+    const loading = active[0];
+    const ready = active[4];
+    if (loading?.type !== "IfStatement" ||
+        loading.consequent.type !== "ReturnStatement" ||
+        !loading.consequent.argument ||
+        ready?.type !== "ReturnStatement" ||
+        !ready.argument)
+        return false;
+    const waitingCall = returnedCall(loading.consequent.argument);
+    const readyCall = returnedCall(ready.argument);
+    if (!waitingCall || !readyCall)
+        return false;
+    const renderField = { owner, field: "render" };
+    const validCall = (call, waiting) => {
+        if (!parameterMember(renderField, call.callee) ||
+            call.arguments.length !== 2 ||
+            call.arguments[1]?.type !== "Literal" ||
+            call.arguments[1].value !== waiting)
+            return false;
+        const data = call.arguments[0];
+        if (!data)
+            return false;
+        if (waiting)
+            return parameterMember({ owner, field: "placeholder" }, data);
+        return (data.type === "MemberExpression" &&
+            !data.computed &&
+            data.property.type === "Identifier" &&
+            data.property.name === "items" &&
+            data.object.type === "Identifier" &&
+            variableOf(owner.context, data.object) === slotBinding);
+    };
+    if (!validCall(waitingCall, true) || !validCall(readyCall, false))
+        return false;
+    let calls = 0;
+    walk(owner.context.sourceCode, owner.value.body, (node) => {
+        if (node.type === "CallExpression" && parameterMember(renderField, node.callee))
+            calls += 1;
+    });
+    const live = readers.returned(owner);
+    return calls === 2 && live !== null && live.includes(loading.consequent.argument) && live.includes(ready.argument);
+};
+/** A local pure helper is followed by its binding; imported helpers must be actual lower owners. */
+const helperOwner = (content, opening, readers) => {
+    if (opening.name.type === "JSXIdentifier") {
+        const variable = variableOf(content.owner.context, opening.name);
+        const definition = variable?.defs[0];
+        const value = definition?.type === "Variable" && definition.parent.kind === "const"
+            ? definition.node.init
+            : definition?.type === "FunctionName"
+                ? definition.node
+                : null;
+        if (value)
+            return readers.resolve({ context: content.owner.context, value });
+    }
+    const imported = readers.resolve(importedHeader(content.owner.context, opening));
+    if (!imported)
+        return null;
+    const found = hfsOf(content.owner.context).classify(imported.context.filename);
+    return found.status === "owned" && found.slot === "fe.components" && ["frames", "composites", "branches", "leaves"].includes(found.kind ?? "")
+        ? imported
+        : null;
+};
+/** A finite path must consume the content exactly once; unknown JSX/calls/branches fail closed. */
+const rendered = (content, node, readers, seen, contexts) => {
+    if (parameterMember(content, node))
+        return true;
+    if (node.type === "JSXExpressionContainer")
+        return rendered(content, node.expression, readers, seen, contexts);
+    if (node.type === "JSXFragment")
+        return renderedChildren(content, node.children, readers, seen, contexts);
+    if (node.type !== "JSXElement" || node.openingElement.attributes.some((item) => item.type === "JSXSpreadAttribute"))
+        return false;
+    const imported = jsxImport(content.owner.context, node.openingElement);
+    if (imported && canonicalStatusOwnerBinding(imported.source, imported.exported)) {
+        const status = readers.resolve(importedHeader(content.owner.context, node.openingElement));
+        const callback = attributeValue(attribute(node.openingElement, "render"));
+        if (!status || !canonicalRegion(status, readers) || !callback || !isFn(callback))
+            return false;
+        if (references(content, node) !== 1 || references(content, callback) !== 1)
+            return false;
+        const values = readers.returned({ ...content.owner, value: callback });
+        return values !== null && values.length > 0 && values.every((value) => parameterMember(content, value));
+    }
+    const containerContexts = bodyContainer(content.owner, node.openingElement, contexts);
+    if (containerContexts !== null) {
+        if (node.openingElement.attributes.some((item) => references(content, item) > 0))
+            return false;
+        return renderedChildren(content, node.children, readers, seen, containerContexts);
+    }
+    const helper = helperOwner(content, node.openingElement, readers);
+    if (!helper || seen.has(helper.value))
+        return false;
+    const carrying = node.openingElement.attributes.filter((item) => references(content, item) > 0);
+    if (carrying.length !== 1 || references(content, node) !== 1)
+        return false;
+    const input = carrying[0];
+    if (input?.type !== "JSXAttribute" || input.name.type !== "JSXIdentifier" || !parameterMember(content, attributeValue(input)))
+        return false;
+    const target = { owner: helper, field: input.name.name };
+    const values = readers.returned(helper);
+    return (references(target, helper.value) === 1 &&
+        values !== null &&
+        values.length > 0 &&
+        values.every((value) => rendered(target, value, readers, new Set(seen).add(helper.value), contexts)));
+};
+const renderedChildren = (content, children, readers, seen, contexts = new Set()) => {
+    const carrying = children.filter((child) => references(content, child) > 0);
+    return carrying.length === 1 && carrying[0] !== undefined && rendered(content, carrying[0], readers, seen, contexts);
+};
+/** Only Page's body carries owner content; a header/unknown attribute/dead callback cannot stand in for it. */
+export const preservesPageBody = (owner, page, readers) => {
+    const content = { owner, field: "children" };
+    if (references(content, page) !== 1 || page.openingElement.attributes.some((item) => references(content, item) > 0))
+        return false;
+    return renderedChildren(content, page.children, readers, new Set([owner.value]));
+};

package/dist/lib/root-page.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from "@typescript-eslint/utils";
+import { type Owner } from "./owner-source.js";
+import type { AnyContext } from "./rule.js";
+/** A selected public semantic role, never a lexical JSX name. Unknown roles refuse. */
+export declare const isPageRenderer: (context: AnyContext, opening: TSESTree.JSXOpeningElement) => boolean;
+/** Shared with R325: one connected entry, its actual sibling Base, its own Page. */
+export declare const connectedPageDrawing: (context: AnyContext, opening: TSESTree.JSXOpeningElement) => Owner | null;
+export declare const rootPageChildren: (context: AnyContext, member: TSESTree.TypeElement) => boolean;

package/dist/lib/root-page.js

@@ -0,0 +1,423 @@
+/**
+ * The one-level connected page composition of FE-FUNCTION-2 / R325. The selected
+ * canonical catalog owns renderer spellings; this reader owns the source proof.
+ * No app setting, component name or unused JSX grants a block a content door.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { grammarContractFor } from "#runtime/scripts/lib/grammar-lint.mjs";
+import { attribute, attributeValue, walk } from "./ast.js";
+import { importOf, isFn, unwrap, variableOf } from "./bindings.js";
+import { hfsOf } from "./hfs.js";
+import { preservesPageBody, parameterMember } from "./page-body.js";
+import { headerExport, importedHeader, parsedSource } from "./owner-source.js";
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A selected public semantic role, never a lexical JSX name. Unknown roles refuse. */
+export const isPageRenderer = (context, opening) => {
+    const family = hfsOf(context).grammar;
+    if (!family)
+        return false;
+    const contract = grammarContractFor(family);
+    const roles = contract.semanticRoles;
+    const role = record(roles) ? roles.page : null;
+    if (!record(role) || typeof role.export !== "string" || !Array.isArray(role.entries) || !role.entries.every((entry) => typeof entry === "string"))
+        return false;
+    const name = opening.name;
+    const identifier = name.type === "JSXIdentifier" ? name : name.type === "JSXMemberExpression" && name.object.type === "JSXIdentifier" ? name.object : null;
+    if (!identifier)
+        return false;
+    const origin = importOf(context, identifier);
+    const definition = variableOf(context, identifier)?.defs.find((item) => item.type === "ImportBinding");
+    if (!origin ||
+        definition?.type !== "ImportBinding" ||
+        definition.parent.importKind === "type" ||
+        (definition.node.type === "ImportSpecifier" && definition.node.importKind === "type"))
+        return false;
+    const exported = name.type === "JSXMemberExpression" && definition.node.type === "ImportNamespaceSpecifier" ? name.property.name : origin.imported;
+    return exported === role.export && role.entries.some((entry) => origin.source === entry.replace("<family>", family));
+};
+/** Resolve only actual immutable value aliases of the selected public export. */
+const resolvedOwner = (owner, seen = new Set()) => {
+    if (!owner || seen.has(owner.value))
+        return null;
+    const value = unwrap(owner.value);
+    if (isFn(value))
+        return { ...owner, value };
+    if (value.type !== "Identifier")
+        return null;
+    const definition = variableOf(owner.context, value)?.defs[0];
+    if (definition?.type === "FunctionName" && isFn(definition.node))
+        return { ...owner, value: definition.node };
+    if (definition?.type !== "Variable" || definition.parent.kind !== "const" || !definition.node.init)
+        return null;
+    return resolvedOwner({ ...owner, value: definition.node.init }, new Set(seen).add(owner.value));
+};
+/** Constant branch conditions have their actual meaning; unknown expressions are never guessed. */
+const constantBoolean = (context, node, seen = new Set()) => {
+    if (seen.has(node))
+        return null;
+    const visited = new Set(seen).add(node);
+    const value = unwrap(node);
+    if (value.type === "Literal" && typeof value.value === "boolean")
+        return value.value;
+    if (value.type === "Identifier") {
+        const definition = variableOf(context, value)?.defs[0];
+        return definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.init
+            ? constantBoolean(context, definition.node.init, visited)
+            : null;
+    }
+    if (value.type === "UnaryExpression" && value.operator === "!") {
+        const inner = constantBoolean(context, value.argument, visited);
+        return inner === null ? null : !inner;
+    }
+    return null;
+};
+/** Walk control flow, stopping after a return/throw and refusing unsupported return-bearing control flow. */
+const returnedStatements = (context, statements) => {
+    const values = [];
+    const branch = (statement) => returnedStatements(context, statement.type === "BlockStatement" ? statement.body : [statement]);
+    for (const statement of statements) {
+        if (statement.type === "ReturnStatement")
+            return statement.argument ? { values: [...values, unwrap(statement.argument)], fallsThrough: false } : null;
+        if (statement.type === "ThrowStatement")
+            return { values, fallsThrough: false };
+        if (statement.type === "IfStatement") {
+            const known = constantBoolean(context, statement.test);
+            const left = known === false ? { values: [], fallsThrough: true } : branch(statement.consequent);
+            const right = known === true || !statement.alternate ? { values: [], fallsThrough: true } : branch(statement.alternate);
+            if (!left || !right)
+                return null;
+            values.push(...left.values, ...right.values);
+            const fallsThrough = known === true ? left.fallsThrough : known === false ? right.fallsThrough : left.fallsThrough || right.fallsThrough;
+            if (!fallsThrough)
+                return { values, fallsThrough: false };
+            continue;
+        }
+        if (statement.type === "BlockStatement") {
+            const nested = returnedStatements(context, statement.body);
+            if (!nested)
+                return null;
+            values.push(...nested.values);
+            if (!nested.fallsThrough)
+                return { values, fallsThrough: false };
+            continue;
+        }
+        if (![
+            "VariableDeclaration",
+            "ExpressionStatement",
+            "FunctionDeclaration",
+            "EmptyStatement",
+            "DebuggerStatement",
+            "TSTypeAliasDeclaration",
+            "TSInterfaceDeclaration"
+        ].includes(statement.type))
+            return null;
+    }
+    return { values, fallsThrough: true };
+};
+/** Return expressions of this function only: nested helpers and dead JSX do not draw it. */
+const returned = (owner) => {
+    const value = owner.value;
+    if (!isFn(value))
+        return null;
+    if (value.body.type !== "BlockStatement")
+        return [unwrap(value.body)];
+    const result = returnedStatements(owner.context, value.body.body);
+    return result && !result.fallsThrough ? result.values : null;
+};
+/** Empty non-rendering arms are allowed; every rendering arm has exactly one root. */
+const roots = (owner) => {
+    const values = returned(owner);
+    if (!values)
+        return null;
+    const found = [];
+    const add = (node) => {
+        if (node.type === "Literal" && (node.value === null || node.value === false))
+            return true;
+        if (node.type === "ConditionalExpression") {
+            const known = constantBoolean(owner.context, node.test);
+            if (known !== null)
+                return add(unwrap(known ? node.consequent : node.alternate));
+            return add(unwrap(node.consequent)) && add(unwrap(node.alternate));
+        }
+        if (node.type === "JSXElement") {
+            found.push(node);
+            return true;
+        }
+        if (node.type !== "JSXFragment")
+            return false;
+        const children = node.children.filter((child) => child.type !== "JSXText" || child.value.trim() !== "");
+        return children.length === 1 && children[0]?.type === "JSXElement" && add(children[0]);
+    };
+    return values.every(add) && found.length > 0 ? found : null;
+};
+const sameOwner = (left, right) => path.resolve(left.context.filename) === path.resolve(right.context.filename) && left.value.range[0] === right.value.range[0];
+/** Exactly the selected sibling drawing, not any import whose filename resembles it. */
+const ownDrawing = (owner) => {
+    const entry = resolvedOwner(owner);
+    if (!entry)
+        return null;
+    const elements = roots(entry);
+    if (!elements)
+        return null;
+    let drawing = null;
+    for (const element of elements) {
+        const imported = resolvedOwner(importedHeader(entry.context, element.openingElement));
+        if (!imported ||
+            path.dirname(imported.context.filename) !== path.dirname(entry.context.filename) ||
+            hfsOf(entry.context).classify(imported.context.filename).role !== "drawing")
+            return null;
+        if (element.openingElement.attributes.some((item) => item.type === "JSXSpreadAttribute"))
+            return null;
+        if (drawing && !sameOwner(drawing, imported))
+            return null;
+        drawing = imported;
+    }
+    return drawing;
+};
+/** The Page is the returned root on every drawing path, not a nested or unused renderer. */
+const pagesOf = (drawing) => {
+    const elements = roots(drawing);
+    if (!elements || !elements.every((element) => isPageRenderer(drawing.context, element.openingElement)))
+        return null;
+    let nested = false;
+    for (const page of elements)
+        walk(drawing.context.sourceCode, page, (node) => {
+            if (node !== page && node.type === "JSXElement" && isPageRenderer(drawing.context, node.openingElement))
+                nested = true;
+        });
+    return nested ? null : elements;
+};
+/** A segment's link tabs are a fact of its selected renderer API, owned by the catalog. */
+const segmentDrawing = (drawing) => {
+    const family = hfsOf(drawing.context).grammar;
+    if (!family)
+        return false;
+    const roles = grammarContractFor(family).semanticRoles;
+    const role = record(roles) ? roles.page : null;
+    const segment = record(role) ? role.segment : null;
+    if (!record(segment) || typeof segment.attribute !== "string" || typeof segment.member !== "string")
+        return false;
+    const objectOf = (node, seen = new Set()) => {
+        if (!node || seen.has(node))
+            return null;
+        const value = unwrap(node);
+        if (value.type === "ObjectExpression")
+            return value;
+        if (value.type !== "Identifier")
+            return null;
+        const definition = variableOf(drawing.context, value)?.defs[0];
+        return definition?.type === "Variable" && definition.parent.kind === "const" ? objectOf(definition.node.init, new Set(seen).add(node)) : null;
+    };
+    return (pagesOf(drawing)?.every((page) => objectOf(attributeValue(attribute(page.openingElement, segment.attribute)))?.properties.some((property) => property.type === "Property" && !property.computed && property.key.type === "Identifier" && property.key.name === segment.member) === true) === true);
+};
+/** Shared with R325: one connected entry, its actual sibling Base, its own Page. */
+export const connectedPageDrawing = (context, opening) => {
+    const owner = resolvedOwner(importedHeader(context, opening));
+    if (!owner)
+        return null;
+    const classification = hfsOf(context).classify(owner.context.filename);
+    if (classification.slot !== "fe.components" || classification.kind !== "blocks" || classification.role !== "entry")
+        return null;
+    const drawing = ownDrawing(owner) ?? owner;
+    return pagesOf(drawing) ? drawing : null;
+};
+/** An actual reference to the selected function parameter's children. */
+const parameterChildren = (owner, node) => parameterMember({ owner, field: "children" }, node);
+/** The connected half passes children once to its twin; the twin draws it in Page's body. */
+const carriesChildren = (entry, drawing) => {
+    const entryRoots = roots(entry);
+    const pages = pagesOf(drawing);
+    if (!entryRoots || !pages)
+        return false;
+    const directContent = (owner, element) => {
+        const attributes = element.openingElement.attributes;
+        if (attributes.some((item) => item.type === "JSXSpreadAttribute"))
+            return false;
+        const direct = element.children.filter((child) => child.type === "JSXExpressionContainer" && parameterChildren(owner, child.expression)).length +
+            attributes.filter((item) => item.type === "JSXAttribute" && item.name.name === "children" && parameterChildren(owner, attributeValue(item)))
+                .length;
+        let all = 0;
+        walk(owner.context.sourceCode, element, (node) => {
+            if (parameterChildren(owner, node))
+                all += 1;
+        });
+        return direct === 1 && all === 1;
+    };
+    return (entryRoots.every((element) => directContent(entry, element)) &&
+        pages.every((page) => preservesPageBody(drawing, page, { resolve: resolvedOwner, returned })));
+};
+/** Feature composition may use its own pure half, never a second feature/block relay. */
+const featureRoots = (owner) => {
+    const entry = resolvedOwner(owner);
+    if (!entry)
+        return null;
+    const drawing = ownDrawing(entry) ?? entry;
+    const elements = roots(drawing);
+    return elements ? { owner: drawing, roots: elements } : null;
+};
+/** Route files are selected by the HFS route role and imported selected export. */
+const mountedFeatures = (context, directory) => {
+    if (!fs.existsSync(directory))
+        return [];
+    const features = [];
+    for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+        const filename = path.join(directory, item.name);
+        if (item.isDirectory()) {
+            features.push(...mountedFeatures(context, filename));
+            continue;
+        }
+        if (!item.isFile())
+            continue;
+        const classification = hfsOf(context).classify(filename);
+        if (classification.status !== "owned" || classification.slot !== "fe.route" || !["page", "layout"].includes(classification.role ?? ""))
+            continue;
+        const route = parsedSource(context, filename);
+        const owner = resolvedOwner(headerExport(route, "default"));
+        if (!owner)
+            continue;
+        const elements = roots(owner);
+        if (!elements)
+            continue;
+        for (const element of elements) {
+            const feature = resolvedOwner(importedHeader(route, element.openingElement));
+            if (!feature)
+                continue;
+            const found = hfsOf(context).classify(feature.context.filename);
+            const expected = classification.role === "layout" ? "layouts" : "pages";
+            if (found.status === "owned" && found.slot === "fe.feature" && found.kind === expected && found.role === "entry")
+                features.push(feature);
+        }
+    }
+    return features;
+};
+/**
+ * Grant only the actual input type member of a proven mounted root and its twin.
+ * A nearby unrelated type declaration never inherits the proof.
+ */
+const inputMembers = (owner) => {
+    if (!isFn(owner.value))
+        return [];
+    const parameter = owner.value.params[0];
+    const annotation = parameter && "typeAnnotation" in parameter ? parameter.typeAnnotation?.typeAnnotation : null;
+    const seen = new Set();
+    const read = (node) => {
+        if (!node || seen.has(node))
+            return [];
+        seen.add(node);
+        if (node.type === "TSTypeLiteral")
+            return node.members;
+        if (node.type === "TSInterfaceBody")
+            return node.body;
+        if (node.type === "TSIntersectionType")
+            return node.types.flatMap(read);
+        if (node.type !== "TSTypeReference" || node.typeName.type !== "Identifier")
+            return [];
+        const definition = variableOf(owner.context, node.typeName)?.defs[0];
+        if (definition?.type !== "Type")
+            return [];
+        if (definition.node.type === "TSTypeAliasDeclaration")
+            return read(definition.node.typeAnnotation);
+        if (definition.node.type === "TSInterfaceDeclaration")
+            return read(definition.node.body);
+        return [];
+    };
+    return read(annotation);
+};
+/** Each source-code lifetime gets one mounted-owner proof; no process-wide stale app cache. */
+const childrenProofs = new WeakMap();
+export const rootPageChildren = (context, member) => {
+    let proven = childrenProofs.get(context.sourceCode);
+    if (!proven) {
+        const result = new Set();
+        childrenProofs.set(context.sourceCode, result);
+        const found = hfsOf(context).classify(context.filename);
+        if (found.status !== "owned" || found.slot !== "fe.components" || found.kind !== "blocks" || !["entry", "drawing"].includes(found.role ?? ""))
+            return false;
+        if (!fs.existsSync(context.filename))
+            return false;
+        const current = parsedSource(context, context.filename);
+        if (current.sourceCode.text !== context.sourceCode.text)
+            return false;
+        const entryFile = found.role === "entry" ? context.filename : path.join(path.dirname(context.filename), "index.tsx");
+        if (!fs.existsSync(entryFile))
+            return false;
+        const entryContext = found.role === "entry" ? current : parsedSource(context, entryFile);
+        const entries = entryContext.program.body
+            .filter((statement) => statement.type === "ExportNamedDeclaration")
+            .flatMap((statement) => {
+            const declaration = statement.declaration;
+            const names = declaration?.type === "VariableDeclaration"
+                ? declaration.declarations.flatMap((item) => (item.id.type === "Identifier" ? [item.id.name] : []))
+                : declaration?.type === "FunctionDeclaration" && declaration.id
+                    ? [declaration.id.name]
+                    : statement.specifiers.map((specifier) => specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value);
+            return names.map((name) => resolvedOwner(headerExport(entryContext, name)));
+        })
+            .filter((owner) => owner !== null);
+        for (const entry of entries) {
+            const drawing = ownDrawing(entry);
+            if (!drawing || !carriesChildren(entry, drawing))
+                continue;
+            const app = found.bindings?.app;
+            const appSlot = hfsOf(context).slot("fe.app.next");
+            if (!app || !appSlot)
+                continue;
+            const prefix = appSlot.path.split("/{")[0]?.replace("<app>", app);
+            if (!prefix)
+                continue;
+            const mounted = mountedFeatures(context, path.join(hfsOf(context).repoRoot, prefix, "src/app"));
+            let selected = false;
+            const composed = mounted.every((feature) => {
+                const composition = featureRoots(feature);
+                if (!composition) {
+                    const target = ownDrawing(feature) ?? feature;
+                    let usesEntry = false;
+                    walk(target.context.sourceCode, target.value, (node) => {
+                        if (node.type !== "JSXElement")
+                            return;
+                        const block = resolvedOwner(importedHeader(target.context, node.openingElement));
+                        if (block && sameOwner(block, entry))
+                            usesEntry = true;
+                    });
+                    return !usesEntry;
+                }
+                let usesEntry = false;
+                let nestedEntry = false;
+                for (const root of composition.roots)
+                    walk(composition.owner.context.sourceCode, root, (node) => {
+                        if (node.type !== "JSXElement")
+                            return;
+                        const block = resolvedOwner(importedHeader(composition.owner.context, node.openingElement));
+                        if (!block || !sameOwner(block, entry))
+                            return;
+                        usesEntry = true;
+                        if (node !== root)
+                            nestedEntry = true;
+                    });
+                if (!usesEntry)
+                    return true;
+                selected = true;
+                if (nestedEntry)
+                    return false;
+                const valid = composition.roots.every((root) => {
+                    const page = connectedPageDrawing(composition.owner.context, root.openingElement);
+                    const ownsPage = isPageRenderer(composition.owner.context, root.openingElement) || page !== null;
+                    const layout = hfsOf(context).classify(feature.context.filename).kind === "layouts";
+                    return ownsPage && (!layout || (page !== null && segmentDrawing(page)));
+                });
+                return valid;
+            });
+            if (!composed || !selected)
+                continue;
+            const local = found.role === "entry" ? entry : drawing;
+            if (path.resolve(local.context.filename) !== path.resolve(context.filename))
+                continue;
+            for (const input of inputMembers(local))
+                if (input.type === "TSPropertySignature" && input.key.type === "Identifier" && input.key.name === "children")
+                    result.add(input.range[0]);
+        }
+        proven = result;
+    }
+    return proven.has(member.range[0]);
+};

package/dist/props-and-slots.d.ts

@@ -13,11 +13,11 @@ export declare const noPublicFrameCssProps: import("./lib/rule.js").Rule<"css",
 /** Prevent utility types from reintroducing public styling doors. */
 export declare const noCssDoorTypeLaundering: import("./lib/rule.js").Rule<"utility", []>;
 /** Props are readonly all the way down: every field, index signature, nested object and collection (FE-TYPING-2). */
-export declare const propsFieldsReadonly: import("./lib/rule.js").Rule<"index" | "field" | "collection", []>;
+export declare const propsFieldsReadonly: import("./lib/rule.js").Rule<"field" | "index" | "collection", []>;
 /**
  * Children belong to frames. A frame owns a region and draws what its caller places in it; a leaf's only child is its text label; a
- * block, a composite and a branch draw a fixed anatomy from fields and named slots, so nested JSX under them is a type error for every
- * caller (`children?: never`). The tier is the layer folder of the unit (FE-FUNCTION-2).
+ * composite and branch draw fixed anatomy from named fields. A block receives atoms and takes children only when its mounted
+ * one-level RootPage composition is proved; ordinary blocks declare `children?: never` (FE-FUNCTION-2).
  */
 export declare const tierChildren: import("./lib/rule.js").Rule<"leaf" | "none" | "withChildren", []>;
 export declare const rules: Rules;

package/dist/props-and-slots.js

@@ -1,5 +1,6 @@
 /** Rules for named React props, ordinary children, and local visual ownership. */
 import { defineRule } from "./lib/rule.js";
+import { rootPageChildren } from "./lib/root-page.js";
 import { declarationsOf, fileOf as declarationFile } from "./lib/types.js";
 import { isComponentFile, isComponentPath, isProductSource, kindOfFile } from "./lib/scope.js";
 /** The key of a node that names a member (`key`), or the property of a member access. */
@@ -309,16 +310,16 @@ export const propsFieldsReadonly = defineRule({
 });
 /**
  * Children belong to frames. A frame owns a region and draws what its caller places in it; a leaf's only child is its text label; a
- * block, a composite and a branch draw a fixed anatomy from fields and named slots, so nested JSX under them is a type error for every
- * caller (`children?: never`). The tier is the layer folder of the unit (FE-FUNCTION-2).
+ * composite and branch draw fixed anatomy from named fields. A block receives atoms and takes children only when its mounted
+ * one-level RootPage composition is proved; ordinary blocks declare `children?: never` (FE-FUNCTION-2).
  */
 export const tierChildren = defineRule({
     meta: {
         type: "problem",
-        docs: { description: "Only a frame takes children; a leaf takes its text label; blocks, composites and branches take none." },
+        docs: { description: "A frame takes children, a leaf its text label; a block takes children only as the proven one-level connected root of the route Page." },
         schema: [],
         messages: {
-            none: "A {{layer}} unit takes no children: name the slot for its role, or move the unit to components/frames when its job is to host content.",
+            none: "A {{layer}} unit takes no children. A block receives atoms; only the proven one-level connected root of the route Page receives owner content. A pure region host belongs in components/frames.",
             leaf: "A leaf takes its text label as children: string, never a node: name the slot for the node, or move the unit to components/frames.",
             withChildren: "PropsWithChildren gives a {{layer}} unit nested JSX: declare children?: never, or children: string for a leaf.",
         },
@@ -335,7 +336,7 @@ export const tierChildren = defineRule({
                 if (propertyName(node) !== "children")
                     return;
                 const type = node.typeAnnotation?.typeAnnotation;
-                if (type?.type === "TSNeverKeyword" || (text && type?.type === "TSStringKeyword"))
+                if (type?.type === "TSNeverKeyword" || (text && type?.type === "TSStringKeyword") || (layer === "blocks" && rootPageChildren(context, node)))
                     return;
                 context.report({ node, messageId: text ? "leaf" : "none", data: { layer: layer.replace(/s$/, "") } });
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-fe",
-  "version": "9.9.7",
+  "version": "9.9.9",
   "description": "Universal front-end lint laws for TypeScript and Next.js, independent of the selected Grammar family.",
   "type": "module",
   "license": "MIT",

package/runtime/knowledge/grammars/index.yaml

@@ -68,6 +68,18 @@ families:
       package: '@starci/grammar'
       entry: '@starci/grammar/common'
       styleEntry: '@starci/grammar/common.css'
+      semanticRoles:
+        page:
+          export: Page
+          entries: ['@starci/grammar/common', '@starci/grammar/<family>']
+          segment: { attribute: header, member: tabs }
+          bodyContainers: [PaneGrid, Pane, Stack, PaneSection, Section]
+          # Native body transparency follows the renderer's exact context, status and intrinsic-element API.
+          bodyContainerConstraints:
+            Pane: { providesContext: pane }
+            Stack: { literalProps: { as: [div, header, footer] } }
+            PaneSection: { requiresContext: pane, absentProps: [error], literalProps: { as: [div, header, footer] } }
+            Section: { absentProps: [error], literalProps: { kind: [region] } }
       peers: [react, '@heroui/react', '@xyflow/react', react-aria-components]
     packageSnapshot: common/DNA.yaml
     scope: |

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.21.7
+    version: 0.21.9
     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.11.14
+    version: 3.11.16
     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.9.7
+    version: 9.9.9
     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.21.7
+    version: 0.21.9
     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.21.7
+    version: 0.21.9
     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: 5.0.3
+    version: 5.0.5
     group: starci
     install: registry
     side: both

package/runtime/scripts/hfs/architecture/canon-jsx-clones.mjs

@@ -152,12 +152,16 @@ function nestedDataObjects(ts, expression, bindingOf, excluded) {
                 nestedDataObjects(ts, element, bindingOf, excluded);
     }
 }
+/** The one app status-owner binding of FE-ERROR-1, shared by clone and body-flow proofs. */
+export function canonicalStatusOwnerBinding(module, name) {
+    return name === 'SlotView' && module !== null && /(?:^|\/)components\/composites\/SlotView(?:\/index)?(?:\.[cm]?tsx?)?$/.test(module);
+}
 /** Resolve the canonical status owner through its import binding, including aliases and namespaces. */
 function statusOwner(ts, tag, bindingOf) {
     const binding = ts.isIdentifier(tag) ? bindingOf(tag) : ts.isPropertyAccessExpression(tag) && ts.isIdentifier(tag.expression) ? bindingOf(tag.expression) : null;
     const module = binding?.kind === 'component' || binding?.kind === 'namespace' ? binding.module : null;
     const name = binding?.kind === 'component' ? binding.name : ts.isPropertyAccessExpression(tag) ? tag.name.text : null;
-    return name === 'SlotView' && module !== null && /(?:^|\/)components\/composites\/SlotView(?:\/index)?(?:\.[cm]?tsx?)?$/.test(module);
+    return canonicalStatusOwnerBinding(module, name);
 }
 /** The mandated status wiring breaks clone windows; its render body remains ordinary compared code. */
 function statusRecipe(ts, opening, bindingOf, excluded) {