@starci/eslint-canon-fe 9.9.6 → 9.9.8

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 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.
+
 ## 9.9.6
 
 - Changed: Align bundled canon pins and exact sibling requirements with Grammar and its lint families at 0.21.6. Runtime behavior and rule severity are unchanged.

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,209 @@
+import { grammarContractFor } from "#runtime/scripts/lib/grammar-lint.mjs";
+import { canonicalStatusOwnerBinding } from "#runtime/scripts/hfs/architecture/canon-jsx-clones.mjs";
+import { attribute, attributeValue, 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) => {
+    const family = hfsOf(owner.context).grammar;
+    if (!family)
+        return false;
+    const roles = grammarContractFor(family).semanticRoles;
+    const page = record(roles) ? roles.page : null;
+    if (!record(page) || !Array.isArray(page.bodyContainers) || !Array.isArray(page.entries))
+        return false;
+    const imported = jsxImport(owner.context, opening);
+    return (imported !== null &&
+        page.bodyContainers.includes(imported.exported) &&
+        page.entries.some((entry) => typeof entry === "string" && entry.replace("<family>", family) === imported.source));
+};
+/** 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) => {
+    if (parameterMember(content, node))
+        return true;
+    if (node.type === "JSXExpressionContainer")
+        return rendered(content, node.expression, readers, seen);
+    if (node.type === "JSXFragment")
+        return renderedChildren(content, node.children, readers, seen);
+    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));
+    }
+    if (bodyContainer(content.owner, node.openingElement)) {
+        if (node.openingElement.attributes.some((item) => references(content, item) > 0))
+            return false;
+        return renderedChildren(content, node.children, readers, seen);
+    }
+    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))));
+};
+const renderedChildren = (content, children, readers, seen) => {
+    const carrying = children.filter((child) => references(content, child) > 0);
+    return carrying.length === 1 && carrying[0] !== undefined && rendered(content, carrying[0], readers, seen);
+};
+/** 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.6",
+  "version": "9.9.8",
   "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,8 @@ 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] }
       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.6
+    version: 0.21.8
     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.13
+    version: 3.11.15
     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.6
+    version: 9.9.8
     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.6
+    version: 0.21.8
     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.6
+    version: 0.21.8
     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.2
+    version: 5.0.4
     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) {