@starci/eslint-canon-fe 9.0.0 → 9.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 9.1.1 - 2026-10-26
+- Changed: the bundled runtime copies (canon pins) follow the stylelint 2.0.13, hfs 4.7.38 and cli 1.7.38 pins. No rule changes.
+
+## 9.1.0 - 2026-10-26
+- Added: universal CTA-6 button intent laws require `intent`, refuse app `variant`, contain destructive confirms in confirmation dialogs, keep one commit per render path and reserve commit for the view rather than collection items. Run `starci app codemod button-intent` to prepare migration and review its flagged cases.
+
 ## 9.0.0 - 2026-10-26
 - Changed: concrete Grammar component, variant, token and vendor rules move to `@starci/eslint-grammar-starci` under the `starci-grammar` namespace. Consumers compose both flat-config factories for their selected family.
 - Added: explicit shared infrastructure exports under `@starci/eslint-canon-fe/lib/*`; family packages reuse these readers without copying them.

package/README.md

@@ -40,4 +40,9 @@ variants on layer-aware fields and primary Tabs inside painted Grammar surfaces
 within the nearest painted surface (`FE_LIST_PANEL_PADDING`). The R65 budget law's
 `no-app-relative-clock` leaves live relative time and countdowns to Grammar's shared clock.
 
+The [button intent law](docs/button-intent.md) (CTA-6) requires every app Button and IconButton to
+declare intent and leave variants to Grammar. It contains destructive confirms in their same-file
+dialog, counts mutually exclusive render paths separately and reserves commit for the view's
+decision rather than repeated collection items.
+
 Regression specs belong to this package. Application front ends and Grammar libraries have no specs.

package/button-intent.mjs

@@ -0,0 +1,320 @@
+/** CTA-6: app buttons declare consequences; Grammar owns their visual variants. */
+import { attributeValue, stringOf, walk } from "./lib/ast.mjs"
+import { functionOf, importOf, isFn, patternPath, unwrap, variableOf } from "./lib/bindings.mjs"
+import { typedPropertyStrings } from "./lib/typed-class-values.mjs"
+import ts from "typescript"
+
+const GRAMMAR_ENTRY = /^@starci\/grammar(?:\/(?:common|core|heritage|offset-pop))?$/
+const BUTTONS = new Set(["Button", "IconButton"])
+const DIALOGS = new Set(["AlertDialog", "ConfirmDialog"])
+const ITEMS = new Set(["CollectionItem", "ItemActions", "ListItem", "ListRow", "ListBox.Item", "GridList.Item", "Table.Row", "TableRow"])
+
+/** The consuming TypeScript program exposes literal intents and spread properties without executing app code. */
+const typedInfo = (context, node, key) => {
+  const services = context.sourceCode.parserServices
+  if (!services?.program || !services.esTreeNodeToTSNodeMap || !node) return null
+  const checker = services.program.getTypeChecker()
+  const source = services.esTreeNodeToTSNodeMap.get(node)
+  const owner = checker.getTypeAtLocation(source)
+  const symbol = key === undefined ? null : owner.getProperty(key)
+  if (key !== undefined && !symbol) return null
+  const type = symbol ? checker.getTypeOfSymbolAtLocation(symbol, source) : owner
+  const members = type.isUnion() ? type.types : [type]
+  return { values: members.filter((member) => member.isStringLiteral()).map((member) => member.value), optional: Boolean(symbol && (symbol.flags & ts.SymbolFlags.Optional) !== 0) }
+}
+
+/** Resolve the imported Grammar role without confusing a shadowed local component with its namesake. */
+const roleOf = (context, name) => {
+  const parts = []
+  let root = name
+  while (root.type === "JSXMemberExpression") {
+    parts.unshift(root.property.name)
+    root = root.object
+  }
+  if (root.type !== "JSXIdentifier") return null
+  const imported = importOf(context, root)
+  if (!imported || !GRAMMAR_ENTRY.test(imported.source)) return null
+  if (imported.imported) parts.unshift(imported.imported)
+  else if (!variableOf(context, root)?.defs.some((definition) => definition.node.type === "ImportNamespaceSpecifier")) return null
+  return parts.join(".")
+}
+
+/** Static object properties, including aliases and spreads, retain their button obligations. */
+const objectProperty = (context, input, key, seen = new Set()) => {
+  const node = unwrap(input)
+  if (!node || seen.has(node)) return []
+  const next = new Set(seen).add(node)
+  if (node.type === "ObjectExpression") return node.properties.flatMap((property) => {
+    if (property.type === "SpreadElement") return objectProperty(context, property.argument, key, next)
+    const name = property.computed ? stringOf(property.key) : property.key.name ?? property.key.value
+    return name === key ? [property.value] : []
+  })
+  if (node.type === "ConditionalExpression") return [node.consequent, node.alternate].flatMap((branch) => objectProperty(context, branch, key, next))
+  if (node.type === "MemberExpression") {
+    const member = node.computed ? stringOf(node.property) : node.property.name
+    return objectProperty(context, node.object, member, next).flatMap((value) => objectProperty(context, value, key, next))
+  }
+  if (node.type !== "Identifier") return []
+  const definition = variableOf(context, node)?.defs.find((entry) => entry.type === "Variable")
+  if (!definition) return []
+  const path = patternPath(definition.node.id, node.name)
+  if (path === null) return []
+  const values = path.reduce((entries, name) => entries.flatMap((entry) => objectProperty(context, entry, name, next)), [definition.node.init])
+  return values.flatMap((value) => objectProperty(context, value, key, next))
+}
+
+/** Possible statically authored values of an intent or step; dynamic values remain TypeScript's responsibility. */
+const valuesOf = (context, input, seen = new Set()) => {
+  const node = unwrap(input)
+  if (!node || seen.has(node)) return []
+  const next = new Set(seen).add(node)
+  const text = stringOf(node)
+  if (text !== null) return [text]
+  if (node.type === "ConditionalExpression") return [node.consequent, node.alternate].flatMap((branch) => valuesOf(context, branch, next))
+  if (node.type === "LogicalExpression") return valuesOf(context, node.right, next)
+  if (node.type === "MemberExpression") {
+    const name = node.computed ? stringOf(node.property) : node.property.name
+    const values = objectProperty(context, node.object, name, next).flatMap((value) => valuesOf(context, value, next))
+    return values.length ? values : typedInfo(context, node)?.values ?? []
+  }
+  if (node.type !== "Identifier") return typedInfo(context, node)?.values ?? []
+  const definition = variableOf(context, node)?.defs.find((entry) => entry.type === "Variable")
+  if (!definition) return typedInfo(context, node)?.values ?? []
+  const path = patternPath(definition.node.id, node.name)
+  if (path === null) return []
+  const values = path.reduce((entries, name) => entries.flatMap((entry) => objectProperty(context, entry, name, next)), [definition.node.init])
+  return values.flatMap((value) => valuesOf(context, value, next))
+}
+
+/** An explicit attribute or statically resolved spread exposing a prop. */
+const propsOf = (context, opening, key) => opening.attributes.flatMap((entry) => {
+  if (entry.type === "JSXAttribute") return entry.name.name === key ? [{ node: entry, value: attributeValue(entry) }] : []
+  const values = objectProperty(context, entry.argument, key)
+  if (values.length) return values.map((value) => ({ node: entry, value }))
+  const authored = typedPropertyStrings(context, entry.argument, key, "variant")
+  if (authored.length) return authored.map((value) => ({ node: entry, text: value.text }))
+  const typed = typedInfo(context, entry.argument, key)
+  return typed ? [{ node: entry, texts: typed.values }] : []
+})
+
+const hasValue = (context, opening, key, value) => propsOf(context, opening, key).some((prop) => prop.text === value || prop.texts?.includes(value) || valuesOf(context, prop.value).includes(value))
+const isButton = (context, opening) => BUTTONS.has(roleOf(context, opening.name))
+
+/** A conditional props spread supplies intent only when every branch supplies it. */
+const suppliesIntent = (context, input, seen = new Set()) => {
+  const node = unwrap(input)
+  if (!node || seen.has(node)) return false
+  const next = new Set(seen).add(node)
+  if (node.type === "ConditionalExpression") return [node.consequent, node.alternate].every((branch) => suppliesIntent(context, branch, next))
+  if (node.type === "Identifier") {
+    const definition = variableOf(context, node)?.defs.find((entry) => entry.type === "Variable")
+    if (definition?.node.id.type === "Identifier") return suppliesIntent(context, definition.node.init, next)
+    const typed = typedInfo(context, node, "intent")
+    return Boolean(typed && !typed.optional)
+  }
+  return objectProperty(context, node, "intent").length > 0 || typedPropertyStrings(context, node, "intent", "variant").length > 0
+}
+
+const hasIntent = (context, opening) => opening.attributes.some((entry) => {
+  if (entry.type === "JSXSpreadAttribute") return suppliesIntent(context, entry.argument)
+  if (entry.name.name !== "intent") return false
+  const value = unwrap(attributeValue(entry))
+  return Boolean(value) && !(value.type === "Literal" && value.value === null) && !(value.type === "Identifier" && value.name === "undefined")
+})
+
+/** JSX child render callbacks contribute content to their enclosing component render. */
+const inlineRenderCallback = (node) => node.parent?.type === "JSXExpressionContainer" && node.parent.parent?.type !== "JSXAttribute"
+
+const lexicalFunction = (node) => {
+  for (let current = node.parent; current; current = current.parent) if (isFn(current)) return current
+  return null
+}
+
+/** The nearest function owns a render; a component defined in a dialog is still its own subtree. */
+const functionOwner = (node) => {
+  for (let current = node.parent; current; current = current.parent) if (isFn(current) && !inlineRenderCallback(current)) return current
+  return null
+}
+
+/** A trigger opens a dialog and is outside its confirmation subtree. */
+const insideDialog = (context, opening) => {
+  const triggers = new Set()
+  for (let current = opening.parent; current; current = current.parent) {
+    if (isFn(current) && !inlineRenderCallback(current)) return false
+    if (current.type === "JSXAttribute" && current.name.name === "trigger") triggers.add(current.parent)
+    if (current.type === "JSXElement" && !triggers.has(current.openingElement) && DIALOGS.has(roleOf(context, current.openingElement.name))) return true
+  }
+  return false
+}
+
+/** Normalize a condition so `ready` and `!ready` select opposite render paths. */
+const guardOf = (context, input, positive) => {
+  const node = unwrap(input)
+  if (node.type === "UnaryExpression" && node.operator === "!") return guardOf(context, node.argument, !positive)
+  if (node.type === "BinaryExpression" && ["===", "==", "!==", "!="].includes(node.operator)) {
+    const literal = node.right.type === "Literal" ? node.right : node.left.type === "Literal" ? node.left : null
+    if (literal) {
+      const selector = context.sourceCode.getText(literal === node.right ? node.left : node.right).replace(/\s+/g, "")
+      const choice = JSON.stringify(literal.value)
+      const value = node.operator.startsWith("!") ? !positive : positive
+      return { key: `${selector}===${choice}`, value, selector, choice }
+    }
+  }
+  return { key: context.sourceCode.getText(node).replace(/\s+/g, ""), value: positive }
+}
+
+const constrainPath = (context, path, test, positive) => {
+  const guard = guardOf(context, test, positive)
+  path.guards.set(guard.key, guard.value)
+  if (guard.selector && guard.value) path.choices.set(guard.selector, guard.choice)
+  return path
+}
+
+/** Conditional intent values retain the guards selecting commit instead of flattening both alternatives. */
+const valuePaths = (context, input, seen = new Set()) => {
+  const node = unwrap(input)
+  if (!node || seen.has(node)) return []
+  const next = new Set(seen).add(node)
+  if (node.type === "ConditionalExpression") return [node.consequent, node.alternate].flatMap((branch, index) => valuePaths(context, branch, next).map((path) => constrainPath(context, path, node.test, index === 0)))
+  if (node.type === "Identifier") {
+    const definition = variableOf(context, node)?.defs.find((entry) => entry.type === "Variable")
+    if (definition?.node.id.type === "Identifier") return valuePaths(context, definition.node.init, next)
+  }
+  return valuesOf(context, node).includes("commit") ? [{ guards: new Map(), choices: new Map() }] : []
+}
+
+/** Branch guards and return ownership identify mutually exclusive render paths. */
+const renderPath = (context, opening, owner) => {
+  const guards = new Map()
+  const choices = new Map()
+  const path = { guards, choices }
+  let returned = null
+  let child = opening
+  for (let current = opening.parent; current && current !== owner; current = current.parent) {
+    if (current.type === "ReturnStatement" && lexicalFunction(current) === owner) returned = current
+    if (current.type === "ConditionalExpression" && child !== current.test) constrainPath(context, path, current.test, child === current.consequent)
+    if (current.type === "IfStatement" && child !== current.test) constrainPath(context, path, current.test, child === current.consequent)
+    if (current.type === "LogicalExpression" && child === current.right && current.operator !== "??") constrainPath(context, path, current.left, current.operator === "&&")
+    child = current
+  }
+  return { guards, choices, returned }
+}
+
+const canCoexist = (left, right) => {
+  if (left.returned && right.returned && left.returned !== right.returned) return false
+  if ([...left.choices].some(([selector, choice]) => right.choices.has(selector) && right.choices.get(selector) !== choice)) return false
+  return [...left.guards].every(([condition, value]) => !right.guards.has(condition) || right.guards.get(condition) === value)
+}
+
+/** No explicit visual prop: any authored variant, including a known props spread, is an app bypass. */
+const buttonNoVariant = {
+  meta: { type: "problem", docs: { description: "CTA-6: app buttons never choose a variant." }, schema: [], messages: {
+    FE_BUTTON_NO_VARIANT: "FE_BUTTON_NO_VARIANT: declare Button intent instead of variant; Grammar resolves the variant from intent and placement.",
+  } },
+  create(context) {
+    return { JSXOpeningElement(opening) {
+      if (!isButton(context, opening)) return
+      for (const node of new Set(propsOf(context, opening, "variant").map((prop) => prop.node))) context.report({ node, messageId: "FE_BUTTON_NO_VARIANT" })
+    } }
+  },
+}
+
+/** Every app button states its command's intent explicitly. */
+const buttonIntentRequired = {
+  meta: { type: "problem", docs: { description: "CTA-6: every app Button and IconButton declares intent." }, schema: [], messages: {
+    FE_BUTTON_INTENT_REQUIRED: "FE_BUTTON_INTENT_REQUIRED: Button and IconButton require intent (commit, alternative, dismiss, neutral or destructive). Choose it from the command's consequence and rank.",
+  } },
+  create(context) {
+    return { JSXOpeningElement(opening) {
+      if (isButton(context, opening) && !hasIntent(context, opening)) context.report({ node: opening, messageId: "FE_BUTTON_INTENT_REQUIRED" })
+    } }
+  },
+}
+
+/** A destructive final press is contained by its same-file confirmation dialog. */
+const destructiveConfirmInDialog = {
+  meta: { type: "problem", docs: { description: "CTA-6: destructive confirm buttons stay inside AlertDialog or ConfirmDialog." }, schema: [], messages: {
+    FE_DESTRUCTIVE_CONFIRM_IN_DIALOG: "FE_DESTRUCTIVE_CONFIRM_IN_DIALOG: a destructive confirm belongs inside the same-file AlertDialog or ConfirmDialog subtree. The trigger uses step=\"entry\".",
+  } },
+  create(context) {
+    return { JSXOpeningElement(opening) {
+      if (!isButton(context, opening) || !hasValue(context, opening, "intent", "destructive") || !hasValue(context, opening, "step", "confirm")) return
+      if (!insideDialog(context, opening)) context.report({ node: opening, messageId: "FE_DESTRUCTIVE_CONFIRM_IN_DIALOG" })
+    } }
+  },
+}
+
+/** A component render exposes one next action, with exclusive branches counted separately. */
+const singleCommitPerRender = {
+  meta: { type: "problem", docs: { description: "CTA-6: at most one commit is visible in a component render." }, schema: [], messages: {
+    FE_SINGLE_COMMIT_PER_RENDER: "FE_SINGLE_COMMIT_PER_RENDER: this render contains another commit action. Keep the one next action as commit and classify its alternatives by consequence.",
+  } },
+  create(context) {
+    const owners = new Map()
+    return { JSXOpeningElement(opening) {
+      if (!isButton(context, opening) || !hasValue(context, opening, "intent", "commit")) return
+      const owner = functionOwner(opening) ?? context.sourceCode.ast
+      const base = renderPath(context, opening, owner)
+      const paths = propsOf(context, opening, "intent").flatMap((prop) => prop.value ? valuePaths(context, prop.value) : prop.text === "commit" || prop.texts?.includes("commit") ? [{ guards: new Map(), choices: new Map() }] : [])
+        .map((path) => ({ returned: base.returned, guards: new Map([...base.guards, ...path.guards]), choices: new Map([...base.choices, ...path.choices]) }))
+      const prior = owners.get(owner) ?? []
+      if (paths.some((path) => prior.some((entry) => canCoexist(entry, path)))) context.report({ node: opening, messageId: "FE_SINGLE_COMMIT_PER_RENDER" })
+      prior.push(...paths)
+      owners.set(owner, prior)
+    } }
+  },
+}
+
+/** A repeated row's next action is alternative; the enclosing view keeps the commit. */
+const noCommitInCollectionItem = {
+  meta: { type: "problem", docs: { description: "CTA-6: collection item renders cannot expose commit actions." }, schema: [], messages: {
+    FE_NO_COMMIT_IN_COLLECTION_ITEM: "FE_NO_COMMIT_IN_COLLECTION_ITEM: collection items cannot use commit. Use alternative for an item's next action and reserve commit for the view's decision.",
+  } },
+  create(context) {
+    const reported = new Set()
+    const report = (opening) => {
+      if (!reported.has(opening) && isButton(context, opening) && hasValue(context, opening, "intent", "commit")) {
+        reported.add(opening)
+        context.report({ node: opening, messageId: "FE_NO_COMMIT_IN_COLLECTION_ITEM" })
+      }
+    }
+    const scanCallback = (callback) => {
+      if (!callback) return
+      walk(context.sourceCode, callback.body, (node) => {
+        if (isFn(node) && !inlineRenderCallback(node)) return false
+        if (node.type === "JSXOpeningElement") report(node)
+        return undefined
+      })
+    }
+    return {
+      JSXAttribute(attribute) {
+        if (attribute.name.name === "renderCell" && roleOf(context, attribute.parent.name) === "DataTable") scanCallback(functionOf(context, attributeValue(attribute)))
+      },
+      JSXOpeningElement(opening) {
+        for (let current = opening.parent; current; current = current.parent) {
+          if (isFn(current) && !inlineRenderCallback(current)) return
+          if (current.type === "JSXElement" && ITEMS.has(roleOf(context, current.openingElement.name))) return report(opening)
+        }
+      },
+      CallExpression(call) {
+        const callee = unwrap(call.callee)
+        if (callee.type !== "MemberExpression") return
+        const name = callee.computed ? stringOf(callee.property) : callee.property.name
+        if (name !== "map") return
+        scanCallback(functionOf(context, call.arguments[0]))
+      },
+    }
+  },
+}
+
+/** Every intent law is universal across Grammar families and app editions. */
+export const rules = {
+  "button-intent-required": buttonIntentRequired,
+  "button-no-variant": buttonNoVariant,
+  "destructive-confirm-in-dialog": destructiveConfirmInDialog,
+  "single-commit-per-render": singleCommitPerRender,
+  "no-commit-in-collection-item": noCommitInCollectionItem,
+}
+
+/** All five laws reach consumers at error. */
+export const recommended = Object.fromEntries(Object.keys(rules).map((name) => [`starci-fe/${name}`, "error"]))

package/docs/button-intent.md

@@ -0,0 +1,22 @@
+# Button intent (CTA-6)
+
+Owner: knowledge/ui/composition/cta.yaml
+
+App `Button` and `IconButton` commands declare `intent`. Grammar derives their variant from that intent and its placement context. These laws apply to every Grammar family in both app editions; aliases and namespace imports retain the same obligations.
+
+| Rule | Finding code | Required behavior |
+| --- | --- | --- |
+| `starci-fe/button-intent-required` | `FE_BUTTON_INTENT_REQUIRED` | Pass the command's `intent`. A known props spread may supply it. |
+| `starci-fe/button-no-variant` | `FE_BUTTON_NO_VARIANT` | Omit `variant`, including variants in known props spreads. |
+| `starci-fe/destructive-confirm-in-dialog` | `FE_DESTRUCTIVE_CONFIRM_IN_DIALOG` | Put `intent="destructive" step="confirm"` inside the same-file `AlertDialog` or `ConfirmDialog` content subtree. Its trigger uses `step="entry"`. A separate component's definition does not inherit its caller's JSX ancestry. |
+| `starci-fe/single-commit-per-render` | `FE_SINGLE_COMMIT_PER_RENDER` | Render at most one commit per component path. Different return paths, opposite conditional arms and opposite guards are mutually exclusive. |
+| `starci-fe/no-commit-in-collection-item` | `FE_NO_COMMIT_IN_COLLECTION_ITEM` | Use `alternative` for an item's next action. A `.map` callback or explicit Grammar collection item context cannot expose commit. |
+
+```tsx
+<AlertDialog>
+  <Button intent="dismiss">Cancel</Button>
+  <Button intent="destructive" step="confirm">Delete record</Button>
+</AlertDialog>
+```
+
+`starci app codemod button-intent` defaults to a dry run. Use `--write` to apply deterministic mappings, then resolve every case in its JSON and Markdown report from the command's actual consequence. A destructive-looking label is a review signal rather than authority to choose an intent.

package/index.mjs

@@ -12,6 +12,7 @@ import { createRequire } from "node:module"
 import { join } from "node:path"
 import { pathToFileURL } from "node:url"
 import { recommended as brandValuesRecommended, rules as brandValuesRules } from "./brand-values.mjs"
+import { recommended as buttonIntentRecommended, rules as buttonIntentRules } from "./button-intent.mjs"
 import { recommended as clientBoundaryRecommended, rules as clientBoundaryRules } from "./client-boundary.mjs"
 import { recommended as commentsRecommended, rules as commentsRules } from "./comments.mjs"
 import { recommended as classNamesRecommended, rules as classNamesRules } from "./class-names.mjs"
@@ -48,6 +49,7 @@ import { why } from "./lib/why.mjs"
 const CONTRIBUTIONS = [
     { law: "project-graph", rules: projectGraphRules, recommended: projectGraphRecommended },
   { law: "brand-values", rules: brandValuesRules, recommended: brandValuesRecommended },
+  { law: "button-intent", rules: buttonIntentRules, recommended: buttonIntentRecommended },
   { law: "client-boundary", rules: clientBoundaryRules, recommended: clientBoundaryRecommended },
   { law: "comments", rules: commentsRules, recommended: commentsRecommended },
   {

package/lib/config.mjs

@@ -99,6 +99,7 @@ export const SLOT_FREE_RULES = Object.freeze([
   "outcome-kinds-exhaustive", "no-await-in-loop", "prefer-code-point", "prefer-string-raw", "no-nested-conditional", "no-void-operator", "no-unused-import",
   "prefer-export-from", "no-unused-prop-types", "media-has-caption", "max-params",
   "nested-control-variant", "no-list-panel-padding", "no-app-surface-paint",
+  "button-intent-required", "button-no-variant", "destructive-confirm-in-dialog", "single-commit-per-render", "no-commit-in-collection-item",
 ])
 
 /** The source of a plain front-end tree: its `src/`. */

package/lib/why.mjs

@@ -19,6 +19,31 @@
 
 /** @type {Record<string, Why>} */
 export const why = {
+  "button-intent-required": {
+    code: "FE_BUTTON_INTENT_REQUIRED",
+    en: "`<file>` renders a Button or IconButton without the command's intent.",
+    fix: "Declare intent from the command's consequence and rank so Grammar supplies its variant.",
+  },
+  "button-no-variant": {
+    code: "FE_BUTTON_NO_VARIANT",
+    en: "`<file>` chooses a Button or IconButton variant directly.",
+    fix: "Replace variant with intent and let Grammar resolve placement and visual treatment.",
+  },
+  "destructive-confirm-in-dialog": {
+    code: "FE_DESTRUCTIVE_CONFIRM_IN_DIALOG",
+    en: "`<file>` renders a final destructive press outside its confirmation dialog.",
+    fix: "Place the destructive confirm inside the same-file AlertDialog or ConfirmDialog; use entry on its trigger.",
+  },
+  "single-commit-per-render": {
+    code: "FE_SINGLE_COMMIT_PER_RENDER",
+    en: "`<file>` renders more than one commit in the same component render path.",
+    fix: "Keep the next action as commit and assign the other commands their consequence-based intents.",
+  },
+  "no-commit-in-collection-item": {
+    code: "FE_NO_COMMIT_IN_COLLECTION_ITEM",
+    en: "`<file>` repeats a commit inside a collection item render.",
+    fix: "Use alternative for the item's next action and keep the enclosing view's commit unique.",
+  },
   "nested-control-variant": {
     code: "FE_NESTED_VARIANT",
     en: "`<file>` sets a static Grammar field variant, or forces primary Tabs inside a painted surface.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starci/eslint-canon-fe",
-  "version": "9.0.0",
+  "version": "9.1.1",
   "description": "Universal front-end lint laws for TypeScript and Next.js, independent of the selected Grammar family.",
   "type": "module",
   "license": "MIT",

package/runtime/knowledge/grammars/index.yaml

@@ -61,14 +61,23 @@ topics:
       shadow, one pink decision accent with a text-safe accent for text — with DNA, idioms, a
       mobile-first playbook for playful learning or consumer apps, and family boundaries including two
       decisions flagged for the family owner.
+  - id: heritage
+    path: heritage/DNA.yaml
+    title: Heritage Grammar
+    summary: |
+      Generated snapshot of the Heritage family's parity declaration, arrangement, scoped tokens and Common renderers.
 families:
+  - id: heritage
+    title: heritage
+    contractRef: common
+    packageSnapshot: heritage/DNA.yaml
   - id: common
     title: common
     componentContract:
       package: '@starci/grammar'
       entry: '@starci/grammar/common'
       styleEntry: '@starci/grammar/common.css'
-      peers: [react, '@heroui/react', '@xyflow/react']
+      peers: [react, '@heroui/react', '@xyflow/react', react-aria-components]
     packageSnapshot: common/DNA.yaml
     scope: |
       DNA snapshot only. This catalog carries no Common-side family boundary, idiom set or composition

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

@@ -23,42 +23,42 @@ pins:
     source: packages/heroicons/package.json
     why: 'StarCi custom Heroicons-compatible cuts; eslint-grammar-starci (icon.mjs) admits @starci/heroicons/24/outline and /16/solid as icon sources, so an app that uses them gets this exact version.'
   '@starci/grammar':
-    version: 0.12.3
+    version: 0.12.5
     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.4.44
+    version: 3.4.46
     group: starci
     install: registry
     side: be
     source: packages/eslint/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.0.0
+    version: 9.1.1
     group: starci
     install: registry
     side: fe
     source: packages/eslint/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-starci':
-    version: 0.12.3
+    version: 0.12.5
     group: starci
     install: registry
     side: fe
     source: packages/eslint/grammar-starci/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.12.3
+    version: 0.12.5
     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.0.12
+    version: 2.0.13
     group: starci
     install: registry
     side: fe
@@ -91,14 +91,14 @@ pins:
     source: packages/test-world/package.json
     why: 'the shared e2e library of every back end (R47, R48), a devDependency of every back end: the warm stack behind toxiproxy, the network-edge fakes, the Nest boot, the typed useTestWorld handle, useSandbox for contract specs and the outage lock. Kafka is real own infra (the one digest-pinned apache/kafka KRaft image, a broker listener and proxy per slot, slot-prefixed topics, consumer groups and client ids) and Postgres is schema-per-context (a schema and a login role per context in a shared database). Each worker has its own data slot (<ns>_w<k>) with its own databases, Keycloak realm, leased Redis DB, bucket/collection/topic prefixes, fakes host, toxiproxy proxies and outage lock; a run provisions min(jest workers, workers cap, default 2) slots, and state file protocol 2 pairs exactly with @starci/jest-preset (TEST_WORLD_PAIR_MISMATCH otherwise). A modules world boots real peer apps beside its modules, world.apps.<name>.during(fn) is the outage of a peer app, w.keycloak.clientSecret(client) answers the run-generated secret of a confidential realm client, world.keycloak.events/sessions read the realm user events and live sessions, world.infra.postgresql.connection(name) takes one database connection down while the others serve, and world.resolve and scope.resolve take any Nest token. Every path a declaration names (`stack`, seeds, the realm, Dockerfiles) resolves from the app root (the directory of hfs.json); the globalSetup registers the path aliases as TypeScript resolves them. Its CLI main is exported at ./cli for starci app stack.'
   '@starci/cli':
-    version: 1.7.35
+    version: 1.7.38
     group: starci
     install: registry
     side: both
     source: packages/cli/package.json
     why: 'the only StarCi command package; product repositories install it for starci app, while @starci/hfs remains its pinned transitive implementation.'
   '@starci/hfs':
-    version: 4.7.35
+    version: 4.7.38
     group: starci
     install: registry
     side: both
@@ -299,6 +299,11 @@ pins:
     group: ui
     side: fe
     why: 'Grammar FlowGraph imports React Flow from @xyflow/react; every Grammar consumer declares this required peer at the version used by the Grammar package.'
+  react-aria-components:
+    version: 1.21.1
+    group: ui
+    side: fe
+    why: 'Grammar imports React Aria Components directly (Sidebar, Field); every Grammar consumer declares this required peer at the version HeroUI resolves.'
   '@heroui/react':
     version: 3.2.6
     group: ui

package/runtime/knowledge/hfs/fe-stack.yaml

@@ -99,7 +99,7 @@ concerns:
     why: useTranslations for copy and the next-intl formatter for numbers, fixed dates and currency; FE-DATE owns live time display.
   - id: ui
     tier: core
-    packages: ['@heroui/react', '@heroui/styles', tailwindcss, '@starci/grammar']
+    packages: ['@heroui/react', '@heroui/styles', tailwindcss, '@starci/grammar', react-aria-components]
     home: [fe.components, fe.feature]
     pattern: FE-UI
     forbids: ['@mantine/core', '@mui/material', '@chakra-ui/react', antd, styled-components, '@emotion/react', '@emotion/styled']
@@ -121,10 +121,11 @@ concerns:
     pattern: FE-UI
     forbids: ['@dicebear/*', boring-avatars, 'react-nice-avatar', multiavatar]
     why: >-
-      Grammar owns circle avatars: pass the uploaded avatar as src, otherwise pass the user or identity id as seed on
-      Avatar, AvatarButton or AvatarGroup members. Grammar renders deterministic DiceBear images with its fixed DNA style;
-      @dicebear/core and @dicebear/styles are Grammar runtime dependencies pinned in canon-pins.yaml. Apps declare and
-      import @starci/grammar, never @dicebear/*, and draw no avatar visuals. With neither src nor seed, initials remain.
+      Grammar owns avatars: pass the uploaded avatar as src and the user or identity id as seed on Avatar, AvatarButton
+      or AvatarGroup members. Without src, Grammar renders bundled DiceBear initials using the first and last words of
+      name, with colour seeded by seed when present and by name otherwise. kind="agent" adds the Grammar-owned bot badge
+      without changing the name rule. @dicebear/core and @dicebear/styles are Grammar runtime dependencies pinned in
+      canon-pins.yaml. Apps declare and import @starci/grammar, never @dicebear/*, and draw no avatar visuals.
   - id: theme
     tier: core
     packages: [next-themes]