@starci/eslint-grammar-core 0.0.0-stage → 0.14.0

package/CHANGELOG.md

@@ -0,0 +1,73 @@
+# Changelog
+
+## Unreleased (0.15.0 with the Grammar family)
+
+- Unreleased: the Grammar family (`grammar`, `eslint-grammar-core`, `eslint-grammar-offset-pop`) keeps one version and `packages/grammar` is outside this lane, so the minor bump to 0.15.0 lands with the family's release; the package stays 0.14.0 until then.
+- 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`.
+
+## 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.
+- Changed: the package lives in github.com/starci183/starci-harness under `packages/` and publishes from there; its bundled `runtime/` is committed source, edited in place (no generator, no `prepack`/`pretest` hook).
+- Changed: owner ruling: there are exactly two Grammar families, `core` and `offset-pop`. This package is renamed from
+  `@starci/eslint-grammar-starci` to `@starci/eslint-grammar-core`, and its factory from `starciGrammarConfig` to
+  `coreGrammarConfig`, which loads for `sides.fe.grammar: core`.
+- Removed: the ids `starci` and `starci-core` are not families and have no alias; an app that names them is refused.
+  Migrate: `sides.fe.grammar: core`, depend on `@starci/eslint-grammar-core`, call `coreGrammarConfig`.
+
+## 0.12.14 - 2026-10-27
+
+- Changed: versioned together with Grammar 0.12.14; bundled canon pins moved.
+
+## 0.12.13 - 2026-10-26
+
+- Changed: versioned together with Grammar 0.12.13 (control height 40, shared scroll carets).
+
+## 0.12.12 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.12 (the family equality spec); the bundled canon pins and runtime copies follow the final package versions. No rule changes.
+
+## 0.12.11 - 2026-10-26
+
+- Changed: versioned with the other lint families; depends on the exact front-end canon 9.1.7; the alpha.31.1 round folded into alpha.31; the bundled canon pins and runtime copies follow the final package versions. No rule changes.
+
+## 0.12.10 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.10; depends on the exact canon-fe 9.1.6; the bundled canon pins follow the new package pins. No rule changes.
+
+## 0.12.9 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.9; depends on the exact canon-fe 9.1.5; the bundled canon pins follow the new package pins. No rule changes.
+
+## 0.12.8 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.8; depends on the exact canon-fe 9.1.4; the bundled canon pins follow the new package pins. No rule changes.
+
+## 0.12.7 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.7; depends on the exact canon-fe 9.1.3; the bundled canon pins follow the new package pins. No rule changes.
+
+## 0.12.6 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.6; depends on @starci/eslint-canon-fe 9.1.2; the bundled runtime copies follow the new sources. No rule changes.
+
+## 0.12.5 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.5; depends on @starci/eslint-canon-fe 9.1.1; the bundled canon pins follow the new package pins. No rule changes.
+
+## 0.12.4 - 2026-10-26
+
+- Changed: versioned with Grammar 0.12.4; no rule changes beyond the version pin.
+
+## 0.12.3 - 2026-10-26
+
+- Added: the StarCi Grammar lint package, released with Grammar 0.12.3. Concrete family laws move from the universal FE canon with their rule IDs and behavioral specs, including the Grammar 0.12.3 lane's `no-icon-size-class` and `destructive-menu-entry-needs-danger-tone` in their latest form. The R318 surface composition rules stay in the universal canon.
+- Added: the `starciGrammarConfig` flat-config factory, complete error-level recommendations, ownership citations and a generated runtime closure.
+- Shared: generic lint readers are imported from `@starci/eslint-canon-fe` 9.0.0.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) StarCi contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# @starci/eslint-grammar-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Concrete StarCi Grammar component, prop, variant and token contracts belong here under
+[FE-RULE-OWNERSHIP](../../contexts/code/fe/README.md#the-placement-test-fe-rule-ownership).
+The package version follows `@starci/grammar`; universal FE laws remain in `@starci/eslint-canon-fe`.
+
+```js
+import { loadHfs, starciFeConfig } from "@starci/eslint-canon-fe"
+import { coreGrammarConfig } from "@starci/eslint-grammar-core"
+
+const hfs = loadHfs(import.meta.url)
+export default [...starciFeConfig({ hfs }), ...coreGrammarConfig({ hfs })]
+```
+
+Every rule uses the `starci-grammar` namespace and runs at error. The factory checks the selected
+Grammar and covers the same source files as the universal factory. Shared AST, type, slot and
+binding readers are imported from the universal package's explicit infrastructure exports.
+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,
+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.
+
+## Migrating from @starci/eslint-canon-fe 8.x
+
+The pinned canon-fe release moved twenty rules here. Their IDs, finding codes and error severity are unchanged;
+only the namespace changes from `starci-fe/` to `starci-grammar/`: `app-shell-frame`,
+`no-shell-bottom-tabs`, `navbar-control-size`, `navbar-cluster`, `no-navbar-create`,
+`no-raw-structural-element`, `no-heading-tag-outside-heading-component`,
+`status-text-uses-soft-foreground`, `vendor-primitive-has-named-owner`,
+`no-vendor-icon-outside-icon-leaf`, `heroicons-is-the-glyph-vendor`, `no-off-scale-glyph-size`,
+`no-icon-size-class`, `destructive-menu-entry-needs-danger-tone`,
+`no-decorative-icon-in-metric-cell`, `no-inline-svg-outside-brand-mark-leaf`, `no-fractional-step`,
+`no-hand-rolled-heading`, `no-unresolved-token-class` and `slot-status-through-slotview`.
+
+1. Set `sides.fe.grammar` to `core` in `hfs.json`; no family is inferred.
+2. Install this package at its canon-pins version beside `@starci/eslint-canon-fe` 9 in the app
+   root `devDependencies`. `starci app check` refuses canon-fe 9 without it
+   (`FE_STACK_FAMILY_LINT_MISSING`), so the rules cannot be lost silently.
+3. Compose the universal factory first and this one second, with the same HFS view (the block
+   above). `starci app sync` renders that managed `fe/eslint.config.mjs`.
+4. Rename references to the moved rules from `starci-fe/` to `starci-grammar/`.
+
+Consuming apps migrate in their own release.
+
+Offset Pop inherits the Common component contract through `@starci/eslint-grammar-offset-pop`.
+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">;