@starci/eslint-canon-fe 9.9.8 → 9.9.9

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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.

package/dist/lib/page-body.js

@@ -1,6 +1,6 @@
 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 { 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";
@@ -28,18 +28,52 @@ const references = (content, node) => {
     });
     return count;
 };
-const bodyContainer = (owner, opening) => {
+const bodyContainer = (owner, opening, contexts) => {
     const family = hfsOf(owner.context).grammar;
     if (!family)
-        return false;
+        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 false;
+        return null;
     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));
+    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) => {
@@ -155,13 +189,13 @@ const helperOwner = (content, opening, readers) => {
         : null;
 };
 /** A finite path must consume the content exactly once; unknown JSX/calls/branches fail closed. */
-const rendered = (content, node, readers, seen) => {
+const rendered = (content, node, readers, seen, contexts) => {
     if (parameterMember(content, node))
         return true;
     if (node.type === "JSXExpressionContainer")
-        return rendered(content, node.expression, readers, seen);
+        return rendered(content, node.expression, readers, seen, contexts);
     if (node.type === "JSXFragment")
-        return renderedChildren(content, node.children, readers, seen);
+        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);
@@ -175,10 +209,11 @@ const rendered = (content, node, readers, seen) => {
         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)) {
+    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);
+        return renderedChildren(content, node.children, readers, seen, containerContexts);
     }
     const helper = helperOwner(content, node.openingElement, readers);
     if (!helper || seen.has(helper.value))
@@ -194,11 +229,11 @@ const rendered = (content, node, readers, seen) => {
     return (references(target, helper.value) === 1 &&
         values !== null &&
         values.length > 0 &&
-        values.every((value) => rendered(target, value, readers, new Set(seen).add(helper.value))));
+        values.every((value) => rendered(target, value, readers, new Set(seen).add(helper.value), contexts)));
 };
-const renderedChildren = (content, children, readers, seen) => {
+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);
+    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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-fe",
-  "version": "9.9.8",
+  "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

@@ -69,7 +69,17 @@ families:
       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] }
+        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.8
+    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.15
+    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.8
+    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.8
+    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.8
+    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.4
+    version: 5.0.5
     group: starci
     install: registry
     side: both