@starci/eslint-grammar-core 0.15.34 → 0.16.2

package/runtime/knowledge/hfs/slots.yaml

@@ -51,7 +51,7 @@ versioning:
 # 3.10.0 is a minor (2026-10-29): it ADDS the lite be.platform.database.entities slot, the entity registry (slot fields role and importedBy), so the
 # tier matrix and the public-entry rules admit exactly its <c>Entities imports and its deep importers (persistence.md BE-PERSISTENCE-3).
 # 3.11.0 (ruling:lite-official-postgres-image, 2026-10-29) is, like 3.9.0, a change for lite only: it ADDS the managed app.db.image slot
-# (db/Dockerfile, written by `starci app sync --write`), narrows ruleParams.db.extensions to the extensions that image carries, and gives
+# (db/Dockerfile, written by `starci app sync --execute`), narrows ruleParams.db.extensions to the extensions that image carries, and gives
 # @nestjs/schedule and cron one owner, platform/jobs (R335).
 # 3.13.0 (rulings lite-pgmq-bus-bullmq-jobs and lite-db-image-in-stacks, 2026-10-29) is a change for lite only: ruleParams.db.extensions
 # admits pgmq, the event bus, ruleParams.db.queueOutbox is retired with the pg_cron half of R258, the lite event-bus functions replace
@@ -940,7 +940,7 @@ slots:
 
   # ----- app root: the database of a lite app (ruling:lite-self-hosted-postgres-passport-minio): a self-hosted PostgreSQL in the app's
   # stack (the `db` service, built from the managed .starcistacks/images/db/Dockerfile: the official postgres image plus pgvector and pgmq, ruling:lite-db-image-in-stacks), migrated by
-  # `starci app db migrate --url-env <NAME>`. A full app keeps its TypeORM migrations under be/ and has no such folder.
+  # `starci app db migrate --db-url-env <NAME>`. A full app keeps its TypeORM migrations under be/ and has no such folder.
   - id: app.db
     profiles: [app]
     editions: [lite]

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

@@ -24,7 +24,7 @@ rules:
   - id: FE-UI
     title: Compose the selected Grammar
     kind: mandatory
-    hfsRules: [R93, R244, R313, R314, R315, R316, R317, R318, R319, R320]
+    hfsRules: [R93, R244, R313, R314, R315, R316, R317, R318, R319, R320, R338, R339, R340]
     requirement: |-
       Components compose the selected Grammar through its published entry and props; application CSS carries
       layout only (css.yaml). A missing visual capability is added to that Grammar before the app consumes it.
@@ -59,6 +59,15 @@ rules:
           (owner:agent-avatar-initials-bot-badge). Apps neither declare nor import an avatar-generation
           library and draw no avatar visuals; the family owns the renderer API (the StarCi recipe is
           groupIdentity in its playbook).
+      - id: case-4
+        date: "2026-10-30"
+        source: owner
+        when: A screen shows generated character art (a mascot)
+        write: |-
+          Render it with the selected Grammar's Mascot at a step of its size scale (sm, md, lg, or hero for a split
+          screen), passing the asset slot it was requested under (assetSlot, and assetSha256 once delivered); a scene
+          or illustration is framed by MediaFrame. Generated art under /images/ never renders through a bare Image or
+          img (R338, R339).
     verification:
       automated:
         - FE_VENDOR_BOUNDARY
@@ -81,5 +90,8 @@ rules:
         - FE_SINGLE_COMMIT_PER_RENDER
         - FE_NO_COMMIT_IN_COLLECTION_ITEM
         - FE_CONTROL_HEIGHT
+        - FE_GENERATED_ART_OUTSIDE_FRAME
+        - FE_MASCOT_ASSET_SLOT_MISSING
+        - FE_RAISED_SURFACE_IN_SURFACE
       manual: []
     relatedExamples: [full-app-shell, lite-app-shell]

package/runtime/scripts/hfs/allows.mjs

@@ -1,7 +1,6 @@
 import path from 'node:path';
 import { braceVariants, globExpression } from '../lib/glob.mjs';
 import { declaredLogicOf } from './manifest-shape.mjs';
-
 /**
  * What a slot's `requires`, `allows` and `forbids` entries (knowledge/hfs/slots.yaml) say about a file, read through the
  * resolver of scripts/hfs/slots.mjs. The machine checks that judge "this folder holds only what its slot allows"
@@ -14,65 +13,65 @@ import { declaredLogicOf } from './manifest-shape.mjs';
  */
 const VAR = /<([A-Za-z][A-Za-z0-9-]*)>/g;
 const SPEC = /\.spec\.ts$/;
-
 /**
  * Whether `relative` is the unit spec `<stem>.spec.ts` of a measured file beside it that the slot names: a file the slot declares in
  * `logic`, or a `requires`/`allows` file of a logic role (ruleParams.be.logicRoles), in a slot whose coverage is required and whose tests
  * are unit-beside. The slot admits that spec without listing it, as unit-test-colocated (R47) accepts it.
  */
 function isMeasuredSpec(resolver, classified, slot, relative, named) {
-  if (!SPEC.test(relative) || slot.coverage !== 'required' || slot.tests !== 'unit-beside') return false;
-  const subject = relative.replace(SPEC, '.ts');
-  if (declaredLogicOf(slot).includes(subject)) return true;
-  const role = /\.([a-z0-9-]+)\.ts$/.exec(subject)?.[1];
-  // An app resolver keeps no rule parameters of its own: a path on a side reads that side's.
-  const params = classified.side ? resolver.sides?.[classified.side]?.ruleParams() : resolver.ruleParams?.();
-  return (params?.logicRoles ?? []).includes(role) && named.some(matcher => matcher.expression.test(subject));
+    if (!SPEC.test(relative) || slot.coverage !== 'required' || slot.tests !== 'unit-beside')
+        return false;
+    const subject = relative.replace(SPEC, '.ts');
+    if (declaredLogicOf(slot).includes(subject))
+        return true;
+    const role = /\.([a-z0-9-]+)\.ts$/.exec(subject)?.[1];
+    // An app resolver keeps no rule parameters of its own: a path on a side reads that side's.
+    const params = classified.side ? resolver.sides?.[classified.side]?.ruleParams() : resolver.ruleParams?.();
+    return (params?.logicRoles ?? []).includes(role) && named.some((matcher) => matcher.expression.test(subject));
 }
-
 function matchersOf(entries, bindings) {
-  return (entries ?? []).flatMap(entry => {
-    const directory = entry.endsWith('/');
-    const body = directory ? entry.slice(0, -1) : entry;
-    const filled = body.replace(VAR, (whole, name) => bindings[name] ?? '*');
-    return braceVariants(filled).map(variant => ({ entry, directory, expression: globExpression(directory ? `${variant}/**` : variant) }));
-  });
+    return (entries ?? []).flatMap((entry) => {
+        const directory = entry.endsWith('/');
+        const body = directory ? entry.slice(0, -1) : entry;
+        const filled = body.replace(VAR, (_whole, name) => bindings[name] ?? '*');
+        return braceVariants(filled).map((variant) => ({ entry, directory, expression: globExpression(directory ? `${variant}/**` : variant) }));
+    });
 }
-
 /** The path of `file` below the instance root of the slot that owns it. */
 export function relativeToRoot(file, root) {
-  return root && file.startsWith(`${root}/`) ? file.slice(root.length + 1) : path.posix.basename(file);
+    return root && file.startsWith(`${root}/`) ? file.slice(root.length + 1) : path.posix.basename(file);
 }
-
 /**
  * Whether the slot that owns `file` names it in `requires` or `allows` (and does not forbid it); null when no enabled slot
  * owns it. Unlike allowsFile it judges a slot that lists only `requires` too, so a folder closed by its slot (an app's
  * src/) is read from the slot and never from a check's own list.
  */
 export function slotAdmitsFile(resolver, file) {
-  const classified = resolver.classifyPath(file);
-  if (classified.status === 'no-slot' || classified.status === 'ambiguous' || !classified.slot) return null;
-  const slot = resolver.slot(classified.slot);
-  const relative = relativeToRoot(classified.path, classified.root);
-  const named = matchersOf([...(slot.requires ?? []), ...(slot.allows ?? [])], classified.bindings);
-  const hit = named.some(matcher => matcher.expression.test(relative)) || isMeasuredSpec(resolver, classified, slot, relative, named);
-  const forbidden = matchersOf(slot.forbids, classified.bindings).some(matcher => matcher.expression.test(relative) || matcher.expression.test(`${relative}/`));
-  return hit && !forbidden;
+    const classified = resolver.classifyPath(file);
+    if (classified.status === 'no-slot' || classified.status === 'ambiguous' || !classified.slot)
+        return null;
+    const slot = resolver.slot(classified.slot);
+    const relative = relativeToRoot(classified.path, classified.root);
+    const named = matchersOf([...(slot.requires ?? []), ...(slot.allows ?? [])], classified.bindings);
+    const hit = named.some(matcher => matcher.expression.test(relative)) || isMeasuredSpec(resolver, classified, slot, relative, named);
+    const forbidden = matchersOf(slot.forbids, classified.bindings).some(matcher => matcher.expression.test(relative) || matcher.expression.test(`${relative}/`));
+    return hit && !forbidden;
 }
-
 /**
  * {slot, root, relative, allowed, entry?, forbiddenBy?} for a repository-relative file, or null when no enabled slot owns
  * it or the slot names no `allows`. `allowed` is true when the relative path matches a `requires` or `allows` entry.
  */
 export function allowsFile(resolver, file) {
-  const classified = resolver.classifyPath(file);
-  if (classified.status === 'no-slot' || classified.status === 'ambiguous' || !classified.slot) return null;
-  const slot = resolver.slot(classified.slot);
-  if (!slot?.allows?.length) return null;
-  const relative = relativeToRoot(classified.path, classified.root);
-  const named = matchersOf([...(slot.requires ?? []), ...slot.allows], classified.bindings);
-  const hit = named.find(matcher => matcher.expression.test(relative));
-  const spec = !hit && isMeasuredSpec(resolver, classified, slot, relative, named);
-  const forbidden = matchersOf(slot.forbids, classified.bindings).find(matcher => matcher.expression.test(relative) || matcher.expression.test(`${relative}/`));
-  return { slot: slot.id, root: classified.root, relative, allowed: (Boolean(hit) || spec) && !forbidden, entry: hit?.entry, forbiddenBy: forbidden?.entry, allows: slot.allows };
+    const classified = resolver.classifyPath(file);
+    if (classified.status === 'no-slot' || classified.status === 'ambiguous' || !classified.slot)
+        return null;
+    const slot = resolver.slot(classified.slot);
+    if (!slot?.allows?.length)
+        return null;
+    const relative = relativeToRoot(classified.path, classified.root);
+    const named = matchersOf([...(slot.requires ?? []), ...slot.allows], classified.bindings);
+    const hit = named.find(matcher => matcher.expression.test(relative));
+    const spec = !hit && isMeasuredSpec(resolver, classified, slot, relative, named);
+    const forbidden = matchersOf(slot.forbids, classified.bindings).find(matcher => matcher.expression.test(relative) || matcher.expression.test(`${relative}/`));
+    return { slot: slot.id, root: classified.root, relative, allowed: (Boolean(hit) || spec) && !forbidden, entry: hit?.entry, forbiddenBy: forbidden?.entry, allows: slot.allows };
 }