@starci/eslint-canon-fe 9.8.5 → 9.9.2

package/runtime/bundle.json

@@ -44,6 +44,7 @@
     "scripts/hfs/architecture/client-reaches-server.mjs",
     "scripts/hfs/architecture/clones.mjs",
     "scripts/hfs/architecture/config-unread.mjs",
+    "scripts/hfs/architecture/component-tiers.mjs",
     "scripts/hfs/architecture/config.mjs",
     "scripts/hfs/architecture/connection-map.mjs",
     "scripts/hfs/architecture/constructor-deps.mjs",
@@ -96,6 +97,8 @@
     "scripts/hfs/architecture/reachability.mjs",
     "scripts/hfs/architecture/register-once.mjs",
     "scripts/hfs/architecture/registration.mjs",
+    "scripts/hfs/architecture/render-graph.mjs",
+    "scripts/hfs/architecture/render-prop-across-server.mjs",
     "scripts/hfs/architecture/required-files.mjs",
     "scripts/hfs/architecture/route-files-thin.mjs",
     "scripts/hfs/architecture/schema-owner.mjs",
@@ -109,6 +112,7 @@
     "scripts/hfs/architecture/sql-token-forms.mjs",
     "scripts/hfs/architecture/sql-tokens.mjs",
     "scripts/hfs/architecture/staged-consumers.mjs",
+    "scripts/hfs/architecture/surface-nesting.mjs",
     "scripts/hfs/architecture/surface.mjs",
     "scripts/hfs/architecture/symbols.mjs",
     "scripts/hfs/architecture/test-world-files.mjs",

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

@@ -31,42 +31,42 @@ 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.20.2
+    version: 0.21.2
     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.6
+    version: 3.11.9
     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.8.5
+    version: 9.9.2
     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.20.2
+    version: 0.21.2
     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.20.2
+    version: 0.21.2
     group: starci
     install: registry
     side: fe
     source: packages/eslint-grammar-offset-pop/package.json
     why: 'the Offset Pop Grammar component API lint, versioned with @starci/grammar; its shared component contract comes from the StarCi family lint without copying rules.'
   '@starci/stylelint-canon':
-    version: 2.4.0
+    version: 2.5.0
     group: starci
     install: registry
     side: fe
@@ -106,7 +106,7 @@ pins:
     source: packages/ai-router/package.json
     why: 'the AI pool router of a back end: a NestJS module that routes OpenAI-compatible chat, stream and embeddings calls across keys, models and providers, with @starci/ai-router/testing for its specs; @starci/jest-preset compiles it as an ESM-only dependency.'
   '@starci/hfs':
-    version: 4.16.5
+    version: 4.17.2
     group: starci
     install: registry
     side: both

package/runtime/knowledge/hfs/slots.yaml

@@ -196,7 +196,7 @@ tiers:
     feature:      {mayImport: [feature, components, hooks, foundation, modules, package], mayImportKinds: {feature: {from: [pages, layouts], to: [overlays]}}} # pages and layouts compose overlays and blocks; data goes through hooks/swr
     # A component never reaches data: config, routes, i18n and types are foundation; every other module and the api
     # transport are reached through a hook (owner decision 2026-09-29).
-    components:   {mayImport: [components, hooks, foundation, package], lowerLayerOnly: true} # blocks, composites, branches, leaves
+    components:   {mayImport: [components, hooks, foundation, package], lowerLayerOnly: true} # blocks, frames, composites, branches, leaves
     # Across domains a hook is imported only through the other domain's public index (hooks/<domain>/index.ts), never deep.
     hooks:        {mayImport: [hooks, foundation, modules, transport, package], mayImportSlots: {transport: {from: [fe.hooks.swr]}}} # only hooks/swr imports an operation
     foundation:   {mayImport: [foundation, package], acyclic: true}               # modules/{config,i18n,routes,types}
@@ -2227,12 +2227,12 @@ slots:
   - id: fe.components
     since: 3.1.0
     profiles: [fe]
-    path: "apps/<app>/src/components/{blocks,composites,branches,leaves}/<name>/"
+    path: "apps/<app>/src/components/{blocks,frames,composites,branches,leaves}/<name>/"
     presence: optional
     tracked: tracked
     tier: components
     owner: true
-    layers: [blocks, composites, branches, leaves]   # a layer imports only the layers after it
+    layers: [blocks, frames, composites, branches, leaves]   # a layer imports only the layers after it
     requires: [index.tsx]
     allows: [index.tsx, component.tsx, classNames.ts]
     roles: {entry: index.tsx, drawing: component.tsx, styles: classNames.ts}   # the connected entry, the pure drawing half and the styling declarations of a component owner
@@ -2575,12 +2575,12 @@ slots:
     tracked: tracked
     tier: package
     owner: true
-    kinds: [composites, branches, leaves]   # the layer folders under src/ (a package owns no blocks)
+    kinds: [frames, composites, branches, leaves]   # the layer folders under src/ (a package owns no blocks)
     roles: {entry: index.tsx, drawing: component.tsx, styles: classNames.ts}
     requires: [package.json, src/index.ts, tsconfig.json]
     tests: none
     budget: {component.tsx: 300, index.tsx: 200, dataHooks: 6, useState: 6}
-    why: built to dist with explicit named exports; only composites, branches and leaves; no unused export; no colour literal
+    why: built to dist with explicit named exports; only frames, composites, branches and leaves; no unused export; no colour literal
     rules: [FE_PACKAGE_SHAPE, HFS_UNUSED_EXPORT, FE_STYLE_TOKEN_ONLY]
   - id: fe.package.api
     since: 3.1.0

package/runtime/knowledge/patterns/fe/folder.yaml

@@ -364,7 +364,7 @@ rules:
     cases:
       - id: case-1
         when: "A Grammar component (runtime package)"
-        write: "packages/grammar/src/core/<primitive|composite|branch|composition>/<Name>/index.tsx"
+        write: "packages/grammar/src/core/<leaf|branch|composite|frame>/<Name>/index.tsx"
       - id: case-2
         when: "A Grammar component's class strings and spec (runtime package)"
         write: "sibling classNames.ts and index.spec.tsx"

package/runtime/scripts/hfs/architecture/clones.mjs

@@ -255,9 +255,19 @@ const cloneCoverage = (entries, blocks, N, T) => {
     return { status: 'checked', minLines: N, minTokens: T, files: entries.length, cloneBlocks: blocks.length, ownersInvolved: owners.size, duplicatedLines,
         ...(blocks.length > MAX_VIOLATIONS ? { truncated: true } : {}) };
 };
+/**
+ * The threshold of the run. The app root (profile app) answers `ruleParams()` with null: its rule parameters are its sides', and
+ * duplicateBlock is the one value they share (ruleParams.common), so the root reads it from a side. A run on the app root
+ * (the root has its own tsconfig) threw "Cannot destructure property 'lines'" here before.
+ */
+function duplicateBlockOf(resolver) {
+    const own = resolver.ruleParams()?.duplicateBlock;
+    const block = own ?? Object.values(resolver.sides ?? {}).map(side => side.ruleParams().duplicateBlock).find(found => found !== undefined);
+    // reason: the rule-params validators require duplicateBlock on every profile, so a side that runs this check carries it
+    return block;
+}
 export function checkClones({ context, graph }) {
-    // reason: the rule-params validators require duplicateBlock on every profile that runs this check
-    const { lines: N, tokens: T } = graph.resolver.ruleParams()?.duplicateBlock;
+    const { lines: N, tokens: T } = duplicateBlockOf(graph.resolver);
     const ts = context.ts ?? context.loaded.ts;
     const entries = [];
     for (const rel of [...graph.files.keys()].sort(byCodeUnit)) {

package/runtime/scripts/hfs/architecture/component-tiers.mjs

@@ -0,0 +1,161 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { byCodeUnit } from '../../lib/list.mjs';
+/**
+ * The component tier ladder, checked on the source of a component library and of a component tree.
+ *
+ *   FE_GRAMMAR_TIER_DIRECTION  a grammar component imports a tier above it (the ladder leaf, branch, composite, frame: a tier imports
+ *                           nothing above itself), type-only imports included, through a shared untiered module as well;
+ *                           `tiers.grammar` of knowledge/hfs/slots.yaml is the matrix
+ *   FE_GRAMMAR_TIER_STAMP      a `data-tier` stamp names a tier other than the folder the file sits in (`atom`, `primitive` and
+ *                           `composition` are not tiers)
+ *   FE_TIER_DIRECTION       (layers) a component imports a layer at or above its own: blocks, frames, composites, branches, leaves
+ *
+ * A library is a folder holding `src/core/<tier>/<Name>/`; a tree is a folder holding `components/<layer>/<Unit>/` that no hfs
+ * front-end slot already judges (an app without hfs.json, such as the harness desktop app).
+ */
+export const COMPONENT_TIER_RULE_IDS = ['FE_GRAMMAR_TIER_DIRECTION', 'FE_GRAMMAR_TIER_STAMP'];
+const SKIPPED = new Set(['node_modules', '.git', 'dist', '.next', 'storybook-static', 'proof']);
+const SOURCE = /\.(?:ts|tsx)$/u;
+const TEST_OR_STORY = /\.(?:stories|spec|test)\.[jt]sx?$/u;
+const IMPORT = /(?:\bimport|\bexport)\b[^'"`;]*?\bfrom\s*['"]([^'"]+)['"]|\bimport\s*['"]([^'"]+)['"]|\bimport\(\s*['"]([^'"]+)['"]\s*\)/gu;
+const STAMP = /["']?data-tier["']?\s*[=:]\s*\{?\s*["']([a-z-]+)["']/gu;
+const LIBRARY_FILE = /^(.*?)src\/core\/(leaf|branch|composite|frame)\/([^/]+)\//u;
+function walk(root, dir = '') {
+    const out = [];
+    for (const entry of fs.readdirSync(path.join(root, dir), { withFileTypes: true })) {
+        if (SKIPPED.has(entry.name))
+            continue;
+        const rel = dir === '' ? entry.name : `${dir}/${entry.name}`;
+        if (entry.isDirectory())
+            out.push(...walk(root, rel));
+        else if (SOURCE.test(entry.name) && !entry.name.endsWith('.d.ts') && !TEST_OR_STORY.test(entry.name))
+            out.push(rel);
+    }
+    return out;
+}
+const lineOf = (text, index) => text.slice(0, index).split('\n').length;
+/** The file an import specifier names, as a repo-relative path in `files`, or null (a package, or a file outside the walk). */
+function resolveImport(files, from, specifier) {
+    if (!specifier.startsWith('.'))
+        return null;
+    const base = path.posix.normalize(path.posix.join(path.posix.dirname(from), specifier)).replace(/\.(?:js|mjs|cjs)$/u, '');
+    for (const candidate of [`${base}.ts`, `${base}.tsx`, `${base}/index.ts`, `${base}/index.tsx`, base])
+        if (files.has(candidate))
+            return candidate;
+    return null;
+}
+function edgesOf(root, files, cache, file) {
+    const cached = cache.get(file);
+    if (cached)
+        return cached;
+    const text = fs.readFileSync(path.join(root, ...file.split('/')), 'utf8');
+    const edges = [];
+    for (const match of text.matchAll(IMPORT)) {
+        const specifier = match[1] ?? match[2] ?? match[3] ?? '';
+        const to = resolveImport(files, file, specifier);
+        if (to !== null)
+            edges.push({ to, line: lineOf(text, match.index ?? 0), specifier });
+    }
+    const entry = { text, edges };
+    cache.set(file, entry);
+    return entry;
+}
+/** The tier (the folder under `src/core`) and the component of a grammar source file, or null for a file outside the ladder. */
+const gradeOf = (file) => {
+    const match = LIBRARY_FILE.exec(file);
+    return match === null ? null : { tier: match[2], unit: `${match[1]}${match[2]}/${match[3]}` };
+};
+/**
+ * Check the component libraries under `root` against `matrix` (`tiers.grammar`). Not applicable when no folder holds
+ * `src/core/<tier>/<Name>/`. A file outside the tier folders (a shared helper under `src/core`) is not a tier, but an import that
+ * reaches a higher tier through it is the importing tier's edge.
+ */
+export function checkGrammarLibraries({ root, matrix }) {
+    const all = walk(root).filter(file => /(?:^|\/)src\//u.test(file));
+    const library = all.filter(file => gradeOf(file) !== null);
+    if (!library.length)
+        return { violations: [], coverage: { status: 'not-applicable' } };
+    const files = new Set(all);
+    const cache = new Map();
+    const violations = [];
+    const tiers = new Set(Object.keys(matrix));
+    let edgesChecked = 0;
+    let stamps = 0;
+    for (const file of library.sort(byCodeUnit)) {
+        const from = gradeOf(file);
+        const { text, edges } = edgesOf(root, files, cache, file);
+        for (const stamp of text.matchAll(STAMP)) {
+            stamps += 1;
+            if (stamp[1] !== from.tier) {
+                violations.push({ ruleId: 'FE_GRAMMAR_TIER_STAMP', path: file, line: lineOf(text, stamp.index ?? 0), column: 1,
+                    message: `${file} stamps data-tier="${stamp[1]}" and sits in the ${from.tier} folder: the stamp is the folder (${[...tiers].join(', ')}).` });
+            }
+        }
+        // Follow shared untiered modules, so a leaf cannot reach a frame by one hop of indirection.
+        const queue = edges.map(edge => ({ edge, via: [] }));
+        const seen = new Set();
+        for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
+            const { edge, via } = next;
+            const target = gradeOf(edge.to);
+            if (target === null) {
+                if (seen.has(edge.to) || !edge.to.includes('/src/') && !edge.to.startsWith('src/'))
+                    continue;
+                seen.add(edge.to);
+                for (const onward of edgesOf(root, files, cache, edge.to).edges)
+                    queue.push({ edge: { ...onward, line: edge.line }, via: [...via, edge.to] });
+                continue;
+            }
+            if (target.unit === from.unit)
+                continue;
+            edgesChecked += 1;
+            if ((matrix[from.tier]?.mayImport ?? []).includes(target.tier))
+                continue;
+            violations.push({ ruleId: 'FE_GRAMMAR_TIER_DIRECTION', path: file, line: edge.line, column: 1, specifier: edge.specifier, resolvedPath: edge.to,
+                message: `${file} (${from.tier}) imports ${edge.to} (${target.tier})${via.length ? ` through ${via.join(' -> ')}` : ''}: a ${from.tier} may import only ${(matrix[from.tier]?.mayImport ?? []).join(', ') || 'nothing'}. Type-only imports count.` });
+        }
+    }
+    const unique = new Map(violations.map(violation => [`${violation.ruleId}|${violation.path}|${violation.line}|${violation.resolvedPath ?? ''}`, violation]));
+    return { violations: [...unique.values()], coverage: { status: 'checked', files: library.length, edgesChecked, stamps } };
+}
+const LAYER_FILE = /^(.*?)components\/([^/]+)\/([^/]+)\//u;
+/**
+ * Check a component tree under `root` that no hfs slot judges: a component imports only the layers after its own (`layers` in order,
+ * the first layer imports all below it). The layers are the folder names of slot fe.components.
+ */
+export function checkComponentLayers({ root, layers }) {
+    const all = walk(root).filter(file => /(?:^|\/)src\//u.test(file));
+    const placed = (file) => {
+        const match = LAYER_FILE.exec(file);
+        const layer = match === null ? -1 : layers.indexOf(match[2]);
+        return match === null || layer < 0 ? null : { layer, unit: `${match[1]}components/${match[2]}/${match[3]}` };
+    };
+    const tree = all.filter(file => placed(file) !== null);
+    if (!tree.length)
+        return { violations: [], coverage: { status: 'not-applicable' } };
+    const files = new Set(all);
+    const cache = new Map();
+    const violations = [];
+    let edgesChecked = 0;
+    for (const file of tree.sort(byCodeUnit)) {
+        const from = placed(file);
+        for (const edge of edgesOf(root, files, cache, file).edges) {
+            const target = placed(edge.to);
+            if (target === null || target.unit === from.unit)
+                continue;
+            edgesChecked += 1;
+            if (target.layer > from.layer)
+                continue;
+            violations.push({ ruleId: 'FE_TIER_DIRECTION', path: file, line: edge.line, column: 1, specifier: edge.specifier, resolvedPath: edge.to,
+                message: `${file}: a ${layers[from.layer]} component may import only the layers after it (${layers.slice(from.layer + 1).join(', ') || 'none'}); it imports a ${layers[target.layer]}. Type-only imports count.` });
+        }
+    }
+    return { violations, coverage: { status: 'checked', files: tree.length, edgesChecked } };
+}
+/** The machine check: the grammar libraries of the repository, judged by `tiers.grammar` of the slot manifest. */
+export function checkGrammarTiers({ config }) {
+    const matrix = config.hfs.manifest.tiers.grammar;
+    if (matrix === undefined)
+        return { violations: [], coverage: { status: 'not-applicable' } };
+    return checkGrammarLibraries({ root: config.root, matrix });
+}

package/runtime/scripts/hfs/architecture/config.mjs

@@ -208,7 +208,7 @@ function inferredLayout(root, workspaces) {
     // A design-system workspace whose src carries tier dirs (leaves/branches/…) IS a component root;
     // collecting its src/components too would nest two roots in one role and fail the disjoint check.
     const tierSources = new Set(workspaces.map(prefix => `${prefix}/src`)
-        .filter(source => ['leaves', 'branches', 'blocks', 'overlays', 'composites', 'layouts', 'product-shells', 'pages']
+        .filter(source => ['leaves', 'branches', 'blocks', 'frames', 'overlays', 'composites', 'layouts', 'product-shells', 'pages']
         .some(tier => existingDirectory(root, `${source}/${tier}`))));
     const components = collect('src/components')
         .filter(relative => !tierSources.has(path.posix.dirname(relative)));

package/runtime/scripts/hfs/architecture/frontend-world.mjs

@@ -5,7 +5,7 @@ import { WorldRenderAnalysis } from './frontend-world-render.mjs';
 const WORLD_NAVIGATION_CALLS = new Set(['useParams', 'usePathname', 'useRouter', 'useSearchParams', 'useSelectedLayoutSegment', 'useSelectedLayoutSegments']);
 const WORLD_INTL_CALLS = new Set(['useLocale', 'useMessages', 'useNow', 'useTimeZone', 'useTranslations']);
 const WORLD_SWR_CALLS = new Set(['default', 'useSWR', 'useSWRConfig', 'useSWRImmutable', 'useSWRMutation']);
-const LOWER_COMPONENT_TIERS = new Set(['composites', 'branches', 'leaves']);
+const LOWER_COMPONENT_TIERS = new Set(['frames', 'composites', 'branches', 'leaves']);
 function selectedSymbol(ts, checker, expression) {
     const selected = unwrapExpression(ts, expression);
     if (!selected)

package/runtime/scripts/hfs/architecture/frontend.mjs

@@ -8,7 +8,7 @@ import { checkWorldRenderBoundaries } from './frontend-world.mjs';
 import { checkGrammar } from './frontend-grammar.mjs';
 import { checkRoute } from './frontend-routing.mjs';
 const FEATURE_TIERS = new Set(['pages', 'layouts', 'overlays']);
-const COMPONENT_TIERS = new Set(['blocks', 'composites', 'branches', 'leaves', 'providers']);
+const COMPONENT_TIERS = new Set(['blocks', 'frames', 'composites', 'branches', 'leaves', 'providers']);
 function absolute(root, relative) {
     return path.resolve(root, ...relative.split('/'));
 }
@@ -82,7 +82,7 @@ function checkFrontendSourceLayout(config, sourceFile, roots) {
         valid = located.relative.includes('/') || roleEntry(located.relative);
     return valid ? [] : [{ ruleId: 'FE_SOURCE_LAYOUT_INVALID', path: relativePath(config.root, sourceFile.fileName), line: 1, column: 1,
             message: { features: 'Frontend features contain only pages, layouts and overlays plus an optional root public entry.',
-                components: 'Frontend components contain only blocks, composites, branches, leaves and providers plus an optional root public entry.',
+                components: 'Frontend components contain only blocks, frames, composites, branches, leaves and providers plus an optional root public entry.',
                 hooks: 'Every authored custom hook is grouped below a domain folder under hooks; only the root public entry may sit directly under hooks.' }[located.role] }];
 }
 function declarationName(ts, declaration) {

package/runtime/scripts/hfs/architecture/index.mjs

@@ -42,9 +42,12 @@ import { checkBackgroundUnowned, BACKGROUND_UNOWNED_RULE_IDS } from './backgroun
 import { checkTransportOwner, TRANSPORT_OWNER_RULE_IDS } from './transport-owner.mjs';
 import { checkRouteFilesThin, ROUTE_FILES_THIN_RULE_IDS } from './route-files-thin.mjs';
 import { checkHooksAreHooks, HOOKS_ARE_HOOKS_RULE_IDS } from './hooks-are-hooks.mjs';
+import { checkRenderPropAcrossServer, RENDER_PROP_ACROSS_SERVER_RULE_IDS } from './render-prop-across-server.mjs';
+import { checkSurfaceNesting, SURFACE_NESTING_RULE_IDS } from './surface-nesting.mjs';
 import { checkClientReachesServer, CLIENT_REACHES_SERVER_RULE_IDS } from './client-reaches-server.mjs';
 import { checkCrossAppDuplicate, CROSS_APP_DUPLICATE_RULE_IDS } from './cross-app-duplicate.mjs';
 import { checkPackageShape, PACKAGE_SHAPE_RULE_IDS } from './package-shape.mjs';
+import { COMPONENT_TIER_RULE_IDS, checkGrammarTiers } from './component-tiers.mjs';
 import { checkFeSlotAllows, FE_SLOT_ALLOWS_RULE_IDS } from './fe-slot-allows.mjs';
 import { checkI18nKeys, I18N_KEYS_RULE_IDS } from './i18n-keys.mjs';
 import { checkDocLanguage, DOC_LANGUAGE_RULE_IDS } from './doc-language.mjs';
@@ -92,10 +95,13 @@ const FRONTEND_MACHINE = {
     hooksAreHooks: [checkHooksAreHooks, HOOKS_ARE_HOOKS_RULE_IDS],
     packageShape: [checkPackageShape, PACKAGE_SHAPE_RULE_IDS],
     clientReachesServer: [checkClientReachesServer, CLIENT_REACHES_SERVER_RULE_IDS],
+    surfaceNesting: [checkSurfaceNesting, SURFACE_NESTING_RULE_IDS],
+    renderPropAcrossServer: [checkRenderPropAcrossServer, RENDER_PROP_ACROSS_SERVER_RULE_IDS],
     crossAppDuplicate: [checkCrossAppDuplicate, CROSS_APP_DUPLICATE_RULE_IDS],
     feSlotAllows: [checkFeSlotAllows, FE_SLOT_ALLOWS_RULE_IDS],
     i18nKeys: [checkI18nKeys, I18N_KEYS_RULE_IDS],
     serverActions: [checkServerActions, SERVER_ACTION_RULE_IDS],
+    grammarTiers: [checkGrammarTiers, COMPONENT_TIER_RULE_IDS],
 };
 /** Errors the machine reports when a program cannot be built or an edge cannot be proven: it cannot judge, so it refuses. */
 const COMMON_REFUSAL_RULE_IDS = [