@starci/eslint-grammar-core 0.13.0 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.15.0 - 2026-10-28
+
+- Changed: versioned together with Grammar 0.15.0; `@starci/eslint-canon-fe` 9.4.0 is the peer dependency, and the bundled canon pins follow release C (Grammar family 0.15.0, hfs 4.9.1, canon-fe 9.4.0, canon-be 3.6.0, jest-preset 2.4.1, `@starci/ai-router` 0.2.1), so an app installs the released versions without pin drift.
+- Changed: the source is TypeScript in `src/`, built to `dist/` (`npm run build`; `prepack` builds); the package ships `dist/`, `runtime/` and `docs/` and no hand-written JavaScript or `index.d.ts` (the build emits the declarations, with the same public types). No rule or behaviour changed; the exports and specifiers (`.` and the default plugin) are unchanged.
+- Changed: the specs are `src/*.spec.ts`, typechecked first by `npm test`.
+- Fixed: the built declarations name `.js`, not the `.ts` sources (`tsc` keeps a relative `.ts` specifier in a `.d.ts`, which a consumer tsc cannot read).
+
+## 0.14.0 - 2026-10-27
+
+- Changed: versioned together with Grammar 0.14.0; the bundled canon pins name the 0.14.0 Grammar family.
+- Added: `starci-grammar/chip-label-starts-uppercase` (R322 `FE_CHIP_LABEL_CASE`): a literal `StatusDot` or `Badge` label starts with an uppercase letter, Vietnamese included; the fix uppercases it in place.
+- Changed: `@starci/eslint-canon-fe` 9.3.0 is the peer dependency; the bundled canon pins name `starci-harness` 1.1.0-alpha.1 (`source: cli/package.json`) in place of the retired `@starci/cli`, the one command line a product installs for `starci app`, and follow hfs 4.9.0, canon-fe 9.3.0 and canon-be 3.5.0. No rule changes.
+
 ## 0.13.0 - 2026-10-27
 
 - Changed: `@starci/eslint-canon-fe` is a peer dependency (9.2.0), installed by the app beside this package, instead of a nested dependency.

package/README.md

@@ -19,7 +19,7 @@ Family helpers and the generated runtime closure belong to this package.
 
 The rule IDs remain stable when their namespace moves. Laws cover the fixed app shell and navbar,
 Grammar-owned structural elements, glyphs and icon sizes, destructive menu entries, status inks,
-heading and token scales, vendor ownership and slot-status composition. Each rule's metadata cites
+chip labels that start uppercase, heading and token scales, vendor ownership and slot-status composition. Each rule's metadata cites
 its behavioral knowledge source and the governing ownership test. The R318 surface composition
 rules (nested control variants, panel-list alignment, layout-only CSS) stay in the universal canon.
 
@@ -49,3 +49,6 @@ Offset Pop inherits the Common component contract through `@starci/eslint-gramma
 Its own adapter selects that family and reuses these implementations.
 
 Regression checks live in this ESLint package. The Grammar and consuming app front ends carry no specs.
+
+The source is TypeScript in `src/` (`src/lib/` holds the shared readers, `src/vendor.d.ts` types the untyped canon and runtime
+JavaScript it imports); `npm run build` emits `dist/`, which is what the package ships beside `runtime/` and `docs/`.

package/dist/app-shell.d.ts

@@ -0,0 +1,15 @@
+import type { Rule } from "eslint";
+/** The app frame is the fixed-viewport Grammar shell; hand-written frame landmarks are rejected. */
+export declare const appShellFrame: Rule.RuleModule;
+/** Bottom navigation is not an alternative compact app-shell frame. */
+export declare const noShellBottomTabs: Rule.RuleModule;
+/** Every visible control in a navbar band uses the shared control size. */
+export declare const navbarControlSize: Rule.RuleModule;
+/** The right cluster is checked at the bar's actions composition, in visual source order. */
+export declare const navbarCluster: Rule.RuleModule;
+/** Creation belongs to its page, never to the global app bar. */
+export declare const noNavbarCreate: Rule.RuleModule;
+/** Every app-shell enforcer is gathered into the ordinary FE lint and gate path. */
+export declare const rules: Record<string, Rule.RuleModule>;
+/** Every rule is mandatory. */
+export declare const recommended: Record<string, "error">;

package/dist/app-shell.js

@@ -0,0 +1,224 @@
+import { defineFamilyRules, defineRule } from "./lib/rule-contract.js";
+/** FE-APP-SHELL-1..5: static app-frame and visible navbar composition from the UI canon. */
+import { isProductSource } from "@starci/eslint-canon-fe/lib/scope.mjs";
+import { grammarName, isBarControl, propOf, resolveLocal, semanticText, textProp } from "./lib/app-shell.js";
+import { appBarOpenings, isAppBar, isAppShell, isNavigationDrawer, ownsAppFrame } from "./lib/app-shell-scope.js";
+import { visitVisible } from "./lib/app-shell-visible.js";
+import { clusterAlternatives } from "./lib/app-shell-cluster.js";
+import { isCreateAction, menuHasCreate } from "./lib/app-shell-create.js";
+import { provesImportedBar, provesNavigationOpener } from "./lib/app-shell-owner.js";
+import { variableOf } from "@starci/eslint-canon-fe/lib/bindings.mjs";
+import { walk } from "@starci/eslint-canon-fe/lib/ast.mjs";
+const CANON = "knowledge/ui/composition/app-shell.yaml";
+const BOTTOM_TABS = /^(?:BottomNav|BottomNavigation|BottomTabBar|MobileBottomNav|MobileTabBar)$/;
+const EXPECTED_CLUSTER = ["language:IconButton", "theme:Switch", "notifications:IconButton", "account:AvatarButton"];
+const meta = (code, description, messages) => ({
+    type: "problem",
+    docs: { description: `${code}: ${description}`, url: CANON },
+    schema: [],
+    messages,
+});
+/** Whether a slot is present; unknown spreads do not prove either presence or absence. */
+const slotPresence = (context, opening, name) => {
+    const prop = propOf(context, opening, name);
+    if (!prop.known)
+        return null;
+    const value = resolveLocal(context, prop.value);
+    if (value === null || value === undefined || value.type === "Literal" && (value.value == null || value.value === false))
+        return false;
+    return !(value.type === "Identifier" && value.name === "undefined" && !variableOf(context, value)?.defs.length);
+};
+/** Resolve constants and require every possible conditional value to prove the slot contract. */
+const everyValue = (context, expression, proves, seen = new Set()) => {
+    const node = resolveLocal(context, expression);
+    if (!node || seen.has(node))
+        return false;
+    if (node.type !== "ConditionalExpression")
+        return proves(node);
+    const visited = new Set(seen).add(node);
+    return [node.consequent, node.alternate].every((branch) => everyValue(context, branch, proves, visited));
+};
+const hasMobileNavigation = (context, opening) => {
+    const drawerProp = propOf(context, opening, "navigationDrawer");
+    const drawer = drawerProp.known && everyValue(context, drawerProp.value, (value) => value.type === "ObjectExpression");
+    const opener = drawer || provesNavigationOpener(context, propOf(context, opening, "compactHeader").value);
+    const visibility = propOf(context, opening, "navigationVisibility");
+    const defaultsWide = opener && visibility.known && slotPresence(context, opening, "navigationVisibility") === false;
+    if (!defaultsWide && (!visibility.known || !everyValue(context, visibility.value, (value) => value.type === "Literal" && value.value === "wide")))
+        return false;
+    return opener;
+};
+/** App-owned tab names count only in a frame owner or a shell's rendered slots. */
+const visibleFromShell = (context, target) => {
+    let visible = false;
+    walk(context.sourceCode, context.sourceCode.ast, (node) => {
+        if (node.type !== "JSXOpeningElement" || !isAppShell(context, node))
+            return;
+        const inspect = (opening) => { if (opening === target)
+            visible = true; };
+        for (const slot of ["header", "compactHeader", "navigation", "primary", "floatingLayer", "compactNavigation"])
+            visitVisible(context, propOf(context, node, slot).value, inspect);
+        for (const child of node.parent.children)
+            visitVisible(context, child, inspect);
+    });
+    return visible;
+};
+/** The app frame is the fixed-viewport Grammar shell; hand-written frame landmarks are rejected. */
+export const appShellFrame = defineRule({
+    meta: meta("FE_APP_SHELL_FRAME", "FE-APP-SHELL-1 uses WorkspaceShell viewport=fixed.", {
+        frame: "FE_APP_SHELL_FRAME: compose the app frame with WorkspaceShell viewport=\"fixed\"; navigation must resolve to navigationVisibility=\"wide\" and have navigationDrawer or a compactHeader with a left Drawer containing Sidebar presentation=\"drawer\". Grammar owns its header, navigation and independent scroll regions.",
+    }),
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        return { JSXOpeningElement(node) {
+                const shell = isAppShell(context, node);
+                const wrongViewport = shell && textProp(context, node, "viewport") !== "fixed";
+                const missingVisibility = shell && slotPresence(context, node, "navigation") !== false && !hasMobileNavigation(context, node);
+                const handFrame = ownsAppFrame(context, node) && (node.name.type === "JSXIdentifier" && ["header", "nav", "main"].includes(node.name.name) || isAppBar(context, node) && !appBarOpenings(context).has(node));
+                if (wrongViewport || missingVisibility || handFrame) {
+                    context.report({ node, messageId: "frame" });
+                }
+            } };
+    },
+});
+/** Bottom navigation is not an alternative compact app-shell frame. */
+export const noShellBottomTabs = defineRule({
+    meta: meta("FE_APP_SHELL_BOTTOM_TABS", "FE-APP-SHELL-4 keeps mobile navigation in the sidebar drawer.", {
+        bottom: "FE_APP_SHELL_BOTTOM_TABS: the app shell uses a mobile subnav opener and Sidebar drawer. Remove bottom tab navigation and WorkspaceShell compactNavigation.",
+    }),
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        return { JSXOpeningElement(node) {
+                const name = grammarName(context, node);
+                const appTab = name === null && node.name.type === "JSXIdentifier" && BOTTOM_TABS.test(node.name.name) && (ownsAppFrame(context, node) || visibleFromShell(context, node));
+                const compact = name === "WorkspaceShell" ? propOf(context, node, "compactNavigation") : null;
+                const value = compact ? resolveLocal(context, compact.value) : null;
+                const absent = value?.type === "Identifier" && value.name === "undefined" && !variableOf(context, value)?.defs.length;
+                if (BOTTOM_TABS.test(name ?? "") || appTab || compact && !absent && (!compact.known || compact.value !== null || compact.present))
+                    context.report({ node, messageId: "bottom" });
+            } };
+    },
+});
+const visitBar = (context, node, visit) => {
+    const name = grammarName(context, node);
+    if (name === "WorkspaceShell" && isAppShell(context, node)) {
+        for (const slot of ["header", "compactHeader"])
+            visitVisible(context, propOf(context, node, slot).value, visit);
+    }
+    else if (isAppBar(context, node)) {
+        visitVisible(context, node.parent, visit);
+    }
+    else if (isNavigationDrawer(context, node)) {
+        visitVisible(context, propOf(context, node, "trigger").value, visit);
+    }
+};
+const delegatesImportedBar = (context, expression) => {
+    let imported = false;
+    let controls = false;
+    let unknown = false;
+    visitVisible(context, expression, (opening, name) => {
+        if (isBarControl(context, opening, name))
+            controls = true;
+        if (name !== null)
+            return;
+        const proof = provesImportedBar(context, opening);
+        if (proof === true)
+            imported = true;
+        if (proof === false)
+            unknown = true;
+    });
+    return imported && !controls && !unknown;
+};
+/** Every visible control in a navbar band uses the shared control size. */
+export const navbarControlSize = defineRule({
+    meta: meta("FE_NAVBAR_CONTROL_SIZE", "FE-APP-SHELL-2 requires size=control on bar controls.", {
+        control: "FE_NAVBAR_CONTROL_SIZE: {{name}} in the navbar band needs size=\"control\" so every bar control shares Grammar's control height.",
+    }),
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        const reported = new Set();
+        return { JSXOpeningElement(node) {
+                visitBar(context, node, (control, name) => {
+                    if (!isBarControl(context, control, name) || textProp(context, control, "size") === "control" || reported.has(control))
+                        return;
+                    reported.add(control);
+                    context.report({ node: control, messageId: "control", data: { name } });
+                });
+            } };
+    },
+});
+/** The right cluster is checked at the bar's actions composition, in visual source order. */
+export const navbarCluster = defineRule({
+    meta: meta("FE_NAVBAR_CLUSTER", "FE-APP-SHELL-3 fixes navbar action kinds and order.", {
+        cluster: "FE_NAVBAR_CLUSTER: navbar actions must be a tertiary Language IconButton in DropdownMenu, theme Switch, notification IconButton in Popover, account AvatarButton in DropdownMenu, in that order. Mobile retains notifications then account and moves language/theme into the drawer.",
+    }),
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        return { JSXOpeningElement(node) {
+                const name = grammarName(context, node);
+                if (!isAppShell(context, node) && !isAppBar(context, node))
+                    return;
+                const shellHeader = name === "WorkspaceShell";
+                const actions = propOf(context, node, shellHeader ? "header" : "actions");
+                const { alternatives, ownsBar } = clusterAlternatives(context, actions.value, shellHeader);
+                if (ownsBar)
+                    return;
+                if (shellHeader && delegatesImportedBar(context, actions.value))
+                    return;
+                const desktop = EXPECTED_CLUSTER.join("|");
+                const mobile = EXPECTED_CLUSTER.slice(2).join("|");
+                const sequences = alternatives.map((sequence) => sequence.join("|"));
+                if (!sequences.includes(desktop) || sequences.some((sequence) => sequence !== desktop && sequence !== mobile))
+                    context.report({ node, messageId: "cluster" });
+            } };
+    },
+});
+/** Creation belongs to its page, never to the global app bar. */
+export const noNavbarCreate = defineRule({
+    meta: meta("FE_NAVBAR_CREATE", "FE-APP-SHELL-5 keeps create actions on pages.", {
+        create: "FE_NAVBAR_CREATE: move this create action from the navbar to its page.",
+    }),
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        const reported = new Set();
+        const report = (node) => {
+            if (reported.has(node))
+                return;
+            reported.add(node);
+            context.report({ node, messageId: "create" });
+        };
+        const inspect = (control, name) => {
+            if (name === "DropdownMenu" || name === "Popover") {
+                if (["entries", "items", "sections"].some((slot) => menuHasCreate(context, propOf(context, control, slot).value)))
+                    report(control);
+                visitVisible(context, propOf(context, control, "content").value, inspect);
+                for (const child of control.parent.children)
+                    visitVisible(context, child, inspect);
+            }
+            if (!isBarControl(context, control, name) || reported.has(control))
+                return;
+            const text = `${semanticText(context, control)} ${control.parent.children.map((child) => context.sourceCode.getText(child)).join(" ")}`;
+            if (isCreateAction(text))
+                report(control);
+        };
+        return { JSXOpeningElement(node) {
+                visitBar(context, node, inspect);
+            } };
+    },
+});
+/** Every app-shell enforcer is gathered into the ordinary FE lint and gate path. */
+export const rules = {
+    "app-shell-frame": appShellFrame,
+    "no-shell-bottom-tabs": noShellBottomTabs,
+    "navbar-control-size": navbarControlSize,
+    "navbar-cluster": navbarCluster,
+    "no-navbar-create": noNavbarCreate,
+};
+defineFamilyRules(rules, "knowledge/ui/composition/app-shell.yaml");
+/** Every rule is mandatory. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-grammar/${name}`, "error"]));

package/dist/chip-label.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "eslint";
+/** The first character of a trimmed label, and its offset in the raw source text, or null when the label is empty. */
+export declare const firstCharacter: (text: string) => {
+    char: string;
+    offset: number;
+} | null;
+/** True when a label's first character is a lowercase letter. */
+export declare const startsLowercase: (text: string) => boolean;
+/** A chip label (`StatusDot` text, `Badge`) starts with an uppercase letter. */
+export declare const chipLabelStartsUppercase: Rule.RuleModule;
+/** The rules this law contributes to the plugin. */
+export declare const rules: Record<string, Rule.RuleModule>;
+/** Every rule of this law is an error. */
+export declare const recommended: Record<string, "error">;

package/dist/chip-label.js

@@ -0,0 +1,117 @@
+import { isProductSource } from "@starci/eslint-canon-fe/lib/scope.mjs";
+import { defineFamilyRules, defineRule } from "./lib/rule-contract.js";
+/**
+ * The rule that holds the chip label law (HFS R322, `FE_CHIP_LABEL_CASE`): a chip label starts with an uppercase
+ * letter. A status chip (`StatusDot` with text, a `Badge`, dot or not) is a label read at a glance beside the thing it
+ * qualifies; "running" beside "Failed" in one table reads as two vocabularies.
+ *
+ * WHAT IT READS. The children of a `StatusDot` or `Badge` element that the source states literally: JSX text, a string
+ * literal or a template literal with no expression in a `{...}`, and every branch of a conditional or logical expression
+ * made of them. The first character of the trimmed text is judged: a lowercase letter is a finding, and the fix
+ * uppercases it in place.
+ *
+ * WHAT IT LEAVES ALONE: text the source cannot show (a translation call, a variable, a template with an expression), a
+ * label that starts with a digit or a symbol, and an uncased script.
+ */
+/** The components whose children are a chip label. */
+const CHIP_COMPONENTS = new Set(["StatusDot", "Badge"]);
+/** The first character of a trimmed label, and its offset in the raw source text, or null when the label is empty. */
+export const firstCharacter = (text) => {
+    const offset = text.search(/\S/u);
+    if (offset < 0)
+        return null;
+    const char = String.fromCodePoint(text.codePointAt(offset) ?? 0);
+    return { char, offset };
+};
+/** True when a label's first character is a lowercase letter. */
+export const startsLowercase = (text) => {
+    const first = firstCharacter(text);
+    return first !== null && /^\p{Ll}$/u.test(first.char);
+};
+/** The literal text nodes a JSX child carries: `{ node, text, quoteOffset }`, the offset of the text inside the node's source. */
+function* literalTexts(node) {
+    if (!node || typeof node.type !== "string")
+        return;
+    switch (node.type) {
+        case "JSXText":
+            yield { node, text: node.value, quoteOffset: 0 };
+            return;
+        case "JSXExpressionContainer":
+            yield* literalTexts(node.expression);
+            return;
+        case "Literal":
+            if (typeof node.value === "string")
+                yield { node, text: node.value, quoteOffset: 1 };
+            return;
+        case "TemplateLiteral":
+            if (node.expressions.length === 0)
+                yield { node, text: node.quasis[0]?.value.cooked ?? "", quoteOffset: 1 };
+            return;
+        case "ConditionalExpression":
+            yield* literalTexts(node.consequent);
+            yield* literalTexts(node.alternate);
+            return;
+        case "LogicalExpression":
+            yield* literalTexts(node.right);
+            return;
+        default:
+    }
+}
+/** The element name of a JSX opening element (`Badge`, or `Grammar.Badge` as `Badge`). */
+const elementName = (opening) => {
+    const name = opening.name;
+    if (name.type === "JSXIdentifier")
+        return name.name;
+    if (name.type === "JSXMemberExpression")
+        return name.property.name;
+    return null;
+};
+/** The first non-blank child of an element: the one that starts the visible label. */
+const leadingChild = (children) => children.find((child) => child.type !== "JSXText" || child.value.trim() !== "") ?? null;
+/** A chip label (`StatusDot` text, `Badge`) starts with an uppercase letter. */
+export const chipLabelStartsUppercase = defineRule({
+    meta: {
+        type: "problem",
+        fixable: "code",
+        docs: { description: "R322: the label of a StatusDot or Badge chip starts with an uppercase letter." },
+        schema: [],
+        messages: {
+            lowercase: "The {{component}} label `{{text}}` starts with a lowercase letter. A chip label is read at a glance beside the thing it qualifies, and every chip of the app starts uppercase, so one table never mixes `running` with `Failed`. Write `{{fixed}}`.",
+        },
+    },
+    create(context) {
+        if (!isProductSource(context))
+            return {};
+        const source = context.sourceCode;
+        return {
+            JSXElement(element) {
+                const component = elementName(element.openingElement);
+                if (component === null || !CHIP_COMPONENTS.has(component))
+                    return;
+                const child = leadingChild(element.children);
+                for (const { node, text, quoteOffset } of literalTexts(child)) {
+                    const first = firstCharacter(text);
+                    if (!startsLowercase(text) || first === null)
+                        continue;
+                    const trimmed = text.trim();
+                    const fixed = first.char.toLocaleUpperCase() + trimmed.slice(first.char.length);
+                    const raw = source.getText(node);
+                    const at = node.range[0] + quoteOffset + raw.slice(quoteOffset).indexOf(first.char);
+                    context.report({
+                        node,
+                        messageId: "lowercase",
+                        data: { component, text: trimmed, fixed },
+                        fix: (fixer) => fixer.replaceTextRange([at, at + first.char.length], first.char.toLocaleUpperCase()),
+                    });
+                }
+            },
+        };
+    },
+});
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "chip-label-starts-uppercase": chipLabelStartsUppercase,
+};
+defineFamilyRules(rules, "knowledge/hfs/rules.yaml#R322");
+/** Every rule of this law is an error. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-grammar/${name}`, "error"]));

package/dist/drawing.d.ts

@@ -0,0 +1,8 @@
+/** StarCi per-slot status composition, governed by FE-RULE-OWNERSHIP. */
+import type { Rule } from "eslint";
+/** A block's pure half never branches on a data status itself. */
+export declare const slotStatusThroughSlotView: Rule.RuleModule;
+/** The family status recipe retains its published rule ID. */
+export declare const rules: Record<string, Rule.RuleModule>;
+/** Every family composition rule is mandatory. */
+export declare const recommended: Record<string, "error">;

package/dist/drawing.js

@@ -0,0 +1,59 @@
+import { pureHalf } from "@starci/eslint-canon-fe/lib/drawing-scope.mjs";
+import { defineFamilyRules, defineRule } from "./lib/rule-contract.js";
+// -- DRAWING-4 ----------------------------------------------------------------------------------
+/** Flags that are a slot's data status. */
+const STATUS_FLAG = /^(?:isLoading|isError|isForbidden|isPending|isValidating|isEmpty)$/;
+/** The name a test expression reads, if it is a status flag. */
+const statusFlagOf = (node) => {
+    if (!node)
+        return null;
+    if (node.type === "UnaryExpression")
+        return statusFlagOf(node.argument);
+    if (node.type === "ChainExpression")
+        return statusFlagOf(node.expression);
+    if (node.type === "Identifier" && STATUS_FLAG.test(node.name))
+        return node.name;
+    if (node.type === "MemberExpression" && node.property?.type === "Identifier" && STATUS_FLAG.test(node.property.name)) {
+        return node.property.name;
+    }
+    if (node.type === "LogicalExpression" || node.type === "BinaryExpression")
+        return statusFlagOf(node.left) ?? statusFlagOf(node.right);
+    return null;
+};
+/** A block's pure half never branches on a data status itself. */
+export const slotStatusThroughSlotView = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "A block's pure half renders data status through `SlotView`, never its own branch." },
+        schema: [],
+        messages: {
+            branch: "This branches on `{{flag}}` by hand. Every slot renders its status through `SlotView`, the one recipe: a second branch drifts from it and becomes one more variant somebody draws.",
+        },
+    },
+    create(context) {
+        if (pureHalf(context) !== "blocks")
+            return {};
+        const check = (node, test) => {
+            const flag = statusFlagOf(test);
+            if (flag)
+                context.report({ node, messageId: "branch", data: { flag } });
+        };
+        return {
+            ConditionalExpression(node) {
+                check(node, node.test);
+            },
+            IfStatement(node) {
+                check(node, node.test);
+            },
+            LogicalExpression(node) {
+                if (node.operator === "&&" && node.parent?.type === "JSXExpressionContainer")
+                    check(node, node.left);
+            },
+        };
+    },
+});
+/** The family status recipe retains its published rule ID. */
+export const rules = { "slot-status-through-slotview": slotStatusThroughSlotView };
+defineFamilyRules(rules, "knowledge/grammars/core/playbook.yaml#state-recipes");
+/** Every family composition rule is mandatory. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-grammar/${name}`, "error"]));

package/dist/grammar-boundary.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "eslint";
+/**
+ * The intrinsic elements of page structure and text, each with the grammar components that render it.
+ * Read against packages/grammar/src (`export const <Component>`); `grammar-boundary.spec.ts` fails when one is not exported.
+ */
+export declare const GRAMMAR_OWNERS: Readonly<Record<string, string>>;
+/** No raw structural or text element in app source or in a package that composes the grammar. */
+export declare const noRawStructuralElement: Rule.RuleModule;
+/** The rules this law contributes to the plugin. */
+export declare const rules: Record<string, Rule.RuleModule>;
+/** Every rule is an error. */
+export declare const recommended: Record<string, "error">;

package/dist/grammar-boundary.js

@@ -0,0 +1,88 @@
+import { defineFamilyRules, defineRule } from "./lib/rule-contract.js";
+/**
+ * The boundary between product code and `@starci/grammar`.
+ *
+ * Grammar is a business-neutral HeroUI-backed component package. Product code composes its components with ordinary React
+ * children and typed props. A page's structure and text are made of those components, not of raw HTML: a raw `<section>`, `<p>`
+ * or `<ul>` carries no density, no focus or landmark contract and no dark value from the design system, and the class names
+ * written by hand to compensate are where a second visual language starts.
+ *
+ * Which tags are refused is decided by the package: a tag is in the list only when `@starci/grammar` exports a component that
+ * renders it (`GRAMMAR_OWNERS` below, each entry verified against the package source by the twin test). A tag the grammar has no
+ * component for (`div`, `br`, `aside`, `article`) is not refused: there is nothing to compose instead, and refusing it would
+ * demand a workaround. When the grammar gains a component for one, the tag joins the list.
+ *
+ * WHERE IT APPLIES. App source that composes the grammar (slots `fe.feature`, `fe.components`, `fe.route`, `fe.hooks`) and any
+ * workspace package except the `<family>-ui` package (`fe.package.ui`), whose components are the renderers and are the one place
+ * a raw tag belongs. Spec files render raw HTML as a harness and are not judged. A file no slot owns is not judged either: the
+ * rule refuses to guess a scope.
+ */
+import { hfsOf } from "@starci/eslint-canon-fe/lib/hfs.mjs";
+/**
+ * The intrinsic elements of page structure and text, each with the grammar components that render it.
+ * Read against packages/grammar/src (`export const <Component>`); `grammar-boundary.spec.ts` fails when one is not exported.
+ */
+export const GRAMMAR_OWNERS = Object.freeze({
+    h1: "Heading", h2: "Heading", h3: "Heading", h4: "Heading", h5: "Heading", h6: "Heading",
+    p: "Text", span: "Text",
+    hr: "Divider",
+    label: "Label",
+    form: "Form",
+    fieldset: "Fieldset",
+    dl: "DescriptionList", dt: "DescriptionList", dd: "DescriptionList",
+    table: "DataTable", thead: "DataTable", tbody: "DataTable", tr: "DataTable", td: "DataTable", th: "DataTable",
+    ul: "List, SurfaceListCard or StaticStateRow", ol: "List, SurfaceListCard or StaticStateRow", li: "ListItem, SurfaceListCard or StaticStateRow",
+    header: "SectionHeader or TopBar",
+    footer: "Footer",
+    nav: "NavLandmark, Subnav, Breadcrumbs or NavigationFeatureNav",
+    section: "Region or SurfaceCard",
+    main: "WorkspaceShell",
+    figure: "MediaFrame", figcaption: "MediaFrame",
+});
+/** The slots of app source that compose the grammar: features, components, routes and hooks. */
+const APP_SLOTS = new Set(["fe.feature", "fe.components", "fe.route", "fe.hooks"]);
+/** The slot of the package whose leaves ARE the renderers: the only place raw structural tags belong. */
+const RENDERER_SLOT = "fe.package.ui";
+/**
+ * True for a file that composes the grammar: app source (`fe.feature`, `fe.components`, `fe.route`, `fe.hooks`) and any
+ * workspace package but the `<family>-ui` package, whose components are the renderers.
+ */
+const composesGrammar = (context, file) => {
+    const hfs = hfsOf(context);
+    const slot = hfs.slotOf(file);
+    if (slot === null || slot === RENDERER_SLOT)
+        return false;
+    return APP_SLOTS.has(slot) || hfs.tierOf(file) === "package";
+};
+/** No raw structural or text element in app source or in a package that composes the grammar. */
+export const noRawStructuralElement = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Page structure and text are grammar components, not raw `div`-family HTML; only `fe.package.ui` renderers draw raw tags." },
+        schema: [],
+        messages: {
+            raw: "A raw `<{{tag}}>`. Page structure and text are composed from the grammar (`@starci/grammar`, or the repository's `<family>-ui` package): use {{owner}}. A raw tag brings none of the design system's density, landmark and state contract, and the class names written to make up for it start a second visual language. If the grammar cannot express this structure, add the component to the grammar or the ui package rather than drawing it here.",
+        },
+    },
+    create(context) {
+        const file = context.filename || context.getFilename();
+        if (!composesGrammar(context, file))
+            return {};
+        return {
+            JSXOpeningElement(node) {
+                if (node.name.type !== "JSXIdentifier")
+                    return;
+                const owner = Object.hasOwn(GRAMMAR_OWNERS, node.name.name) ? GRAMMAR_OWNERS[node.name.name] ?? null : null;
+                if (owner !== null)
+                    context.report({ node, messageId: "raw", data: { tag: node.name.name, owner: `\`${owner}\`` } });
+            },
+        };
+    },
+});
+/** The rules this law contributes to the plugin. */
+export const rules = {
+    "no-raw-structural-element": noRawStructuralElement,
+};
+defineFamilyRules(rules, "knowledge/patterns/fe/ui.yaml#FE-UI");
+/** Every rule is an error. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-grammar/${name}`, "error"]));

package/dist/icon.d.ts

@@ -0,0 +1,27 @@
+import type { Rule } from "eslint";
+/** A glyph library is named in one file, and a caller asks for a MEANING instead. */
+export declare const noVendorIconOutsideIconLeaf: Rule.RuleModule;
+/**
+ * The icon leaf owns the map, but that ownership does not license a second glyph vocabulary: every glyph comes from the
+ * heroicons family on its two cuts. Phosphor, Iconify, Lucide and every other glyph catalogue are refused, including the
+ * ones no list can name in advance.
+ */
+export declare const heroiconsIsTheGlyphVendor: Rule.RuleModule;
+/** A glyph takes one of the two steps; a fraction or an arbitrary value is a third. */
+export declare const noOffScaleGlyphSize: Rule.RuleModule;
+/** The icon's size is its usage's: the call site passes the glyph and never a size class. */
+export declare const noIconSizeClass: Rule.RuleModule;
+/** A repeated metric cell does not invent a feature glyph absent from the reference. */
+export declare const noDecorativeIconInMetricCell: Rule.RuleModule;
+/** Inline SVG belongs only to an explicitly declared brand mark in a leaf entry. */
+export declare const noInlineSvgOutsideBrandMarkLeaf: Rule.RuleModule;
+/** The rules this law contributes to the plugin. */
+export declare const rules: Record<string, Rule.RuleModule>;
+/**
+ * The level this law asks for, as the plugin's own opinion.
+ *
+ * A consuming repository's `eslint.config.mjs` stays the authority on what is actually switched on.
+ * Both rules are exact - a package prefix and a size pattern - so neither carries the false-positive
+ * risk that would justify adopting it at `warn`.
+ */
+export declare const recommended: Record<string, "error">;