@formicoidea/labre-core 0.40.0 → 0.42.0

package/dist/_pkgs/affine-block-surface/extensions/validation.js

@@ -328,15 +328,15 @@ function backgroundsOf(rule, elements) {
  * measures against have nothing to invalidate — and a framework whose only rules
  * are on-demand has no incremental pass to protect in the first place.
  *
- * The DECLARED moment, deliberately, and not the one the levels in force decide
- * ({@link momentOf}): this is a set of ids and not a verdict, so an audit rule
- * whose frames it guards costs one extra id and can never make an answer wrong,
- * where reading the levels here would mean re-reading the surface for it.
+ * The moment is read STATICALLY ({@link couldBeRealtime}) and not per instance:
+ * this is a set of ids and not a verdict, so a rule some level could promote
+ * costs one extra id and can never make an answer wrong, where reading the
+ * chosen levels here would mean re-reading the surface for it.
  */
-export function backgroundElementIds(rules, elements) {
+export function backgroundElementIds(rules, elements, profiles = []) {
     const ids = new Set();
     for (const rule of rules) {
-        if (!isRealtime(rule))
+        if (!couldBeRealtime(rule, profiles))
             continue;
         for (const background of backgroundsOf(rule, elements))
             ids.add(background.id);
@@ -2460,6 +2460,146 @@ function evaluateElementInZone(rule, elements, incremental) {
     }
     return violations;
 }
+/**
+ * How far `p` is from the OUTLINE of `bound` — the rectangle's perimeter, and
+ * not its area.
+ *
+ * Zero on the line, and positive on both sides of it: the distance to the
+ * nearest edge for a point inside, the ordinary distance to the rectangle for a
+ * point outside. That two-sided reading is the whole point of the function —
+ * "on the border" is a claim about a LINE, and a family measuring containment
+ * could not tell a glyph sitting on the edge from one buried in the middle.
+ *
+ * Euclidean rather than squared, unlike {@link gapSquared}: the result is
+ * compared against a tolerance a framework declares in model units, so the root
+ * has to be taken somewhere and taking it here keeps the declaration readable.
+ * One `Math.hypot` per (carrier, carried) couple that actually overlaps, which
+ * is a handful per board.
+ */
+function outlineDistance(p, bound) {
+    // Negative inside, positive outside, on each axis independently.
+    const dx = Math.max(bound.x - p[0], p[0] - bound.maxX);
+    const dy = Math.max(bound.y - p[1], p[1] - bound.maxY);
+    if (dx > 0 || dy > 0) {
+        return Math.hypot(Math.max(dx, 0), Math.max(dy, 0));
+    }
+    // Inside: the nearest of the four edges.
+    return Math.min(-dx, -dy);
+}
+/**
+ * "Is this glyph still ON the border of the box it was drawn on?"
+ *
+ * The `border-proximity` family (ADR 0024). See {@link BorderProximityDef} for
+ * the requirement and for the three families that cannot state it.
+ *
+ * ## The walk
+ *
+ * Two passes over the surface to index the carriers and the subjects, then per
+ * subject one test against each carrier: do the two boxes share AREA (or does
+ * the carrier contain the subject outright), and if so how far is the subject's
+ * centre from that carrier's outline. The BEST carrier — smallest distance,
+ * ties broken by the smaller id — is the one the finding is measured against and
+ * the one it names, because it is the box the author was aiming at and the only
+ * one a suggestion can point back to.
+ *
+ * Deliberately not sweep-and-pruned the way `no-overlap` is. The two populations
+ * are disjoint by role and both are small — a component sheet carries units of
+ * components and units of ports — so the couple walk is `carriers × subjects`
+ * over two handfuls, and an index would cost more to build than the walk it
+ * saves. If a framework ever writes this family on two crowded roles, the prune
+ * is the same one `evaluateNoOverlap` already documents.
+ *
+ * ## Overlap is the GATE, and the distance is the verdict
+ *
+ * A subject overlapping no carrier at all raises nothing (the family's
+ * proportionality requirement), so the only thing this reports is a glyph the
+ * author put ON a box and then pushed too far into it. Shared AREA and not a
+ * shared edge — {@link boundsOverlap}'s epsilon — because a glyph tangent
+ * OUTSIDE its carrier is within any tolerance worth declaring anyway, and
+ * treating a snapped edge as an overlap would make the gate depend on float
+ * noise.
+ *
+ * ## One finding, two ids
+ *
+ * One per SUBJECT, however many carriers it touches: the mistake is one glyph in
+ * one wrong place, and a square straddling two nested components would otherwise
+ * be reported twice for one drag. Both ids are indicted — the carrier and the
+ * carried — because the finding has two honest readings (the glyph has drifted,
+ * or the box has grown under it) and only the pair shows the user both brackets.
+ * Sorted, like every other multi-element finding in this file, so the same
+ * situation reports the same way whichever order the surface was walked in.
+ */
+function evaluateBorderProximity(rule, elements) {
+    const subjectRole = rule.appliesTo;
+    const proximity = rule.borderProximity;
+    if (subjectRole === undefined || proximity === undefined)
+        return [];
+    const carrierRole = proximity.carrierRole;
+    // An outline is a box's, so the carrier has to be one. A rule naming an edge
+    // or a text role can never fire; say so once rather than shrugging.
+    const carrierKind = rule.roles[carrierRole]?.kind;
+    if (carrierKind !== 'node') {
+        warnOnce(`border-proximity rule "${rule.id}" names a ` +
+            `"${carrierKind ?? 'unknown'}" role ("${carrierRole}") as its ` +
+            `carrier — only a "node" role has an outline, and "on the border" is a ` +
+            `distance to one, so this rule can never fire.`);
+        return [];
+    }
+    const tolerance = proximity.tolerance;
+    if (!(tolerance > 0)) {
+        // A centre exactly on the line is a drawing no hand and no snap produces,
+        // so a rule declaring no tolerance would indict every subject on the board.
+        warnOnce(`border-proximity rule "${rule.id}" declares no positive tolerance — ` +
+            `the rule is not evaluated.`);
+        return [];
+    }
+    const carriers = [];
+    const subjects = [];
+    for (const el of elements) {
+        // Cheapest possible exit for a neutral element: no role, no evaluation.
+        if (el.role === undefined)
+            continue;
+        if (roleIsA(el.role, carrierRole, rule.roles)) {
+            carriers.push({ id: el.id, bound: el.elementBound });
+            // A role that is BOTH — a framework specialising one from the other —
+            // would be a declaration that cannot mean anything here, so the carrier
+            // reading wins and the element is not also judged as a subject.
+            continue;
+        }
+        if (roleIsA(el.role, subjectRole, rule.roles)) {
+            subjects.push({ id: el.id, bound: el.elementBound });
+        }
+    }
+    if (carriers.length === 0 || subjects.length === 0)
+        return [];
+    const backgrounds = backgroundsOf(rule, elements);
+    const violations = [];
+    for (const subject of subjects) {
+        const centre = centreOf(subject.bound);
+        let host = null;
+        let distance = Infinity;
+        for (const carrier of carriers) {
+            if (!boundsOverlap(carrier.bound, subject.bound) &&
+                !carrier.bound.contains(subject.bound)) {
+                continue;
+            }
+            const away = outlineDistance(centre, carrier.bound);
+            // Strictly nearer wins; an exact tie goes to the smaller id, never to
+            // whichever carrier the surface happened to be walked past first.
+            if (away < distance ||
+                (away === distance && host !== null && carrier.id < host.id)) {
+                distance = away;
+                host = carrier;
+            }
+        }
+        // On no carrier at all: the glyph is a sketch, and this family says nothing
+        // about where a sketch sits.
+        if (host === null || distance <= tolerance)
+            continue;
+        violations.push(raise(rule, [host.id, subject.id].sort(), attributeBackground(subject.bound, backgrounds)?.id));
+    }
+    return violations;
+}
 /**
  * "Does this artefact belong on THIS view?"
  *
@@ -3233,6 +3373,210 @@ function evaluateLabelPresence(rule, elements, incremental) {
     }
     return violations;
 }
+/**
+ * WHERE each {@link LabelTarget} is actually written, in order of preference.
+ *
+ * The one place in this file that names a connector's end-label props:
+ * `sourceLabel` / `targetLabel`, the flat `Y.Text` fields `docs/adr/0020`
+ * chose (mirroring the centre label's `text`). {@link labelSource} also
+ * tolerates a nested `{ text }` under the same key — the shape an importer's
+ * serialized props or a host that modelled the end label as one object would
+ * hand it — so the rule does not break the day the model is reshaped, the same
+ * duck-typing discipline {@link elementLabel} and {@link rawEndpointIds}
+ * already hold.
+ *
+ * Own-property reads only, through {@link labelSource}: these come off a Y.Map
+ * and are whatever a peer or an importer wrote.
+ */
+const LABEL_PROPS = {
+    'center-label': ['text'],
+    'source-label': ['sourceLabel'],
+    'target-label': ['targetLabel'],
+};
+/**
+ * The RAW words of one of an element's labels — newlines and all, `''` when it
+ * carries none.
+ *
+ * {@link elementLabel} one step earlier: it trims, because "is there anything
+ * here" is the only question that family asks. This family has to keep the line
+ * structure, since a compartment is a LIST and the trimming happens per line.
+ */
+function labelSource(el, target) {
+    if (target === 'end-labels') {
+        // The two ends, one per line — see {@link LabelTarget}. An end carrying
+        // nothing contributes no line rather than an empty one, so a connector
+        // labelled at one end alone is one subject and not two.
+        return [labelSource(el, 'source-label'), labelSource(el, 'target-label')]
+            .filter(text => text.trim() !== '')
+            .join('\n');
+    }
+    const props = el;
+    for (const key of LABEL_PROPS[target]) {
+        const raw = props[key];
+        if (raw == null)
+            continue;
+        if (typeof raw === 'string')
+            return raw;
+        if (rendersAsText(raw))
+            return String(raw);
+        // A nested end label — `{ text: Y.Text, xywh }` — read exactly one level
+        // deep. Deeper would be guessing at a shape nobody declared.
+        const nested = raw.text;
+        if (typeof nested === 'string')
+            return nested;
+        if (nested != null && rendersAsText(nested))
+            return String(nested);
+    }
+    return '';
+}
+/**
+ * §9.2.4's elision marker, in both spellings. A line that says "there are more
+ * of these, not shown" is notation, and indicting it would indict the author for
+ * having said so.
+ */
+const ELISION = new Set(['...', '…']);
+/**
+ * The lines of a label that SAY something — trimmed, normalised, in order.
+ *
+ * Deliberately the same three rules `gfx/uml/src/grammar.ts` `parseCompartment`
+ * holds (trim, drop blanks, drop the ellipsis), plus the invisible-code-point
+ * strip {@link elementLabel} does: a line of zero-width joiners is a line the
+ * reader cannot see, and handing it to a parser would indict the author for
+ * something invisible on both the canvas and the finding.
+ *
+ * `perLine === false` folds the whole label into ONE subject — the trimmed text,
+ * newlines kept — which is the reading a transition label or a multiplicity
+ * wants: it is one expression, not a list.
+ */
+function syntaxLines(text, perLine) {
+    const clean = text.normalize('NFC').replace(INVISIBLE_CHARS, '');
+    const lines = perLine ? clean.split('\n') : [clean];
+    return lines
+        .map(line => line.trim())
+        .filter(line => line.length > 0 && !ELISION.has(line));
+}
+/**
+ * How much of an offending line the finding's own sentence repeats.
+ *
+ * A compartment line is normally short, and a pasted one is occasionally a
+ * paragraph. The fallback sentence ends up in a bubble eight units tall, so the
+ * quotation is capped and elided rather than allowed to set the width of the
+ * panel.
+ */
+const QUOTED_LINE_MAX = 80;
+function quoteLine(line) {
+    return line.length <= QUOTED_LINE_MAX
+        ? line
+        : `${line.slice(0, QUOTED_LINE_MAX - 1)}…`;
+}
+/**
+ * "Is this written the way the notation writes it?"
+ *
+ * {@link evaluateLabelPresence} asks whether the artefact says anything; this
+ * asks whether what it says PARSES. The walk is the same walk — subjects by
+ * role, frame attribution through {@link ValidationRule.backgroundRole}, one
+ * finding per offending element — and everything that makes the verdict is in
+ * the function the framework shipped ({@link LabelSyntaxDef}).
+ *
+ * ## One finding per ELEMENT, naming the FIRST bad line
+ *
+ * Not one per line, and the reason is what a compartment looks like halfway
+ * through being typed: six lines of a class's attributes with three of them
+ * unfinished is three brackets on one text element, three entries in the panel
+ * and one thing to fix. The first offending line is the one the author is going
+ * to look at, so it is the one the sentence names.
+ *
+ * The finding keeps the RULE's `messageKey` and quotes the line in the
+ * FALLBACK, which is the honest limit of this engine: a finding carries no
+ * message parameters, so a host translating the key gets the rule's own
+ * sentence and not the line. Recorded in `docs/adr/0021` rather than worked
+ * around here — inventing a parameter channel for one family would be a change
+ * to every family's contract.
+ *
+ * ## Silence
+ *
+ * The usual proportionality, and one addition. An element with no role is not a
+ * subject; a label with no visible line is nothing to parse (that is
+ * `label-presence`'s question, and a framework asking both asks them with two
+ * rules); a blank line and an ellipsis are notation. And a rule whose `parse` is
+ * not a function evaluates nothing at all and warns once — see the header of
+ * {@link LabelSyntaxDef} on why that case exists.
+ *
+ * ## Cost
+ *
+ * One label read and one `parse` per line, paid only by the elements carrying
+ * the subject role. Linear in the WORDS on the board rather than in its
+ * elements, which is the first time this file can say that — and the reason
+ * every rule of the family this library ships is `audit`, hence on-demand
+ * (PF7.6), hence off the drawing path entirely.
+ */
+function evaluateLabelSyntax(rule, elements, incremental) {
+    const subjectRole = rule.appliesTo;
+    const syntax = rule.labelSyntax;
+    if (subjectRole === undefined || syntax === undefined)
+        return [];
+    if (typeof syntax.parse !== 'function') {
+        warnOnce(`label-syntax rule "${rule.id}" carries no parse function — a rule of ` +
+            `this family holds its framework's own grammar and cannot be ` +
+            `serialized; the rule is not evaluated.`);
+        return [];
+    }
+    const target = syntax.target ?? 'center-label';
+    const perLine = syntax.perLine ?? true;
+    // Only resolved when something is actually wrong — a board spelled correctly
+    // pays nothing for the frames it never has to name.
+    let backgrounds = null;
+    const judged = incremental?.subjects;
+    const violations = [];
+    for (const el of elements) {
+        if (judged !== undefined && !judged.has(el.id))
+            continue;
+        // Cheapest possible exit for a neutral element: no role, no evaluation.
+        if (el.role === undefined)
+            continue;
+        if (!roleIsA(el.role, subjectRole, rule.roles))
+            continue;
+        const lines = syntaxLines(labelSource(el, target), perLine);
+        let offending = null;
+        for (const line of lines) {
+            const verdict = syntax.parse(line);
+            if (verdict.ok)
+                continue;
+            offending = {
+                line,
+                ...(verdict.reason ? { reason: verdict.reason } : {}),
+            };
+            break;
+        }
+        if (offending === null)
+            continue;
+        const quoted = quoteLine(offending.line);
+        const words = {
+            messageKey: rule.messageKey,
+            ...(rule.messageFallback !== undefined
+                ? {
+                    messageFallback: offending.reason === undefined
+                        ? `${rule.messageFallback} “${quoted}”`
+                        : `${rule.messageFallback} “${quoted}” — ${offending.reason}.`,
+                }
+                : {}),
+            ...(rule.suggestionKey !== undefined
+                ? { suggestionKey: rule.suggestionKey }
+                : {}),
+            ...(rule.suggestionFallback !== undefined
+                ? { suggestionFallback: rule.suggestionFallback }
+                : {}),
+        };
+        backgrounds ??= backgroundsOf(rule, elements);
+        const frameId = attributeBackground(el.elementBound, backgrounds)?.id;
+        // The TEXT element, and nothing else. A UML compartment belongs to a group
+        // and the mark is drawn on that group already ({@link anchorOf}) — the
+        // group carries no role, is never evaluated, and by the same contract never
+        // appears in a finding's `elementIds`.
+        violations.push(raise(rule, [el.id], frameId, words));
+    }
+    return violations;
+}
 const RULE_FAMILIES = {
     'element-in-background': evaluateElementInBackground,
     'orientation-against-axis': evaluateOrientationAgainstAxis,
@@ -3248,7 +3592,9 @@ const RULE_FAMILIES = {
     'edge-locality': evaluateEdgeLocality,
     reachability: evaluateReachability,
     'label-presence': evaluateLabelPresence,
+    'label-syntax': evaluateLabelSyntax,
     'view-admissibility': evaluateViewAdmissibility,
+    'border-proximity': evaluateBorderProximity,
 };
 /**
  * What a verdict of each family DEPENDS ON (PF5.3) — read off the evaluator
@@ -3298,9 +3644,21 @@ export const RULE_SCOPES = {
     reachability: 'surface',
     // Own words; the frame is attribution only.
     'label-presence': 'element',
+    // Own words again, one question further on: the verdict is the framework's
+    // parser applied to the subject's OWN label, line by line. Nothing about the
+    // neighbourhood takes part — a compartment is right or wrong whatever is drawn
+    // beside it, and an end label is read off the connector that carries it rather
+    // than off what the connector joins.
+    'label-syntax': 'element',
     // Own role against the level the containing view declares; kept at the wider
     // level for the same reason as `tone-convention`.
     'view-admissibility': 'frame',
+    // Widened from 'element' for the reason `attachment` is: the carriers the
+    // subject is measured against are collected from the WHOLE surface and bounded
+    // by no frame, so a carrier moved, resized or deleted anywhere can flip a
+    // subject's verdict — including from "on a border" to "on no carrier at all",
+    // which is the difference between a finding and silence.
+    'border-proximity': 'surface',
 };
 /**
  * The dependency scope in force for `rule`: the WIDER of its family's and its
@@ -3407,11 +3765,14 @@ function attributeAll(elements, frames, add) {
  * it, an incremental pass keeps verdicts measured against a map the user has
  * just stopped calling a map, or judged at a level nobody holds any more.
  *
- * Real-time rules only, and the DECLARED moment, exactly like
- * {@link backgroundElementIds} and for the same reason: an on-demand rule never
- * takes part in an incremental pass, so it has nothing to invalidate.
+ * Real-time rules only, read statically ({@link couldBeRealtime}), exactly like
+ * {@link backgroundElementIds} and for the same reason: an on-demand rule no
+ * level can promote never takes part in an incremental pass, so it has nothing
+ * to invalidate — and one that a level CAN promote has to be remembered here
+ * before anybody chooses that level, because the memory is what the pass after
+ * the choice reads.
  */
-export function frameMembership(rules, elements) {
+export function frameMembership(rules, elements, profiles = []) {
     const membership = new Map();
     const add = (id, frameId) => {
         const held = membership.get(id);
@@ -3423,7 +3784,7 @@ export function frameMembership(rules, elements) {
     const done = new Set();
     let levelled = false;
     for (const rule of rules) {
-        if (!isRealtime(rule))
+        if (!couldBeRealtime(rule, profiles))
             continue;
         levelled = true;
         const key = frameKey(rule);
@@ -3779,17 +4140,62 @@ export function dirtyClosure(elements, dirty, previous, wasIn) {
         },
     };
 }
+/**
+ * Whether a level in force on this surface PROMOTES `rule` — names it, by id,
+ * at a severity the drawing user is shown.
+ *
+ * Named, and not merely resolved: {@link profileSeverity} falls back to the
+ * rule's own severity for a rule a table is silent about, and a fallback is not
+ * a decision. A promotion is a framework writing `'warning'` beside an id, which
+ * is the one statement strong enough to overrule the rule's own `'on-demand'`
+ * ({@link momentOf}).
+ *
+ * The same walk {@link isRuleAuditOnly} does — the framework's default level
+ * unconditionally, then every level a root instance on this surface has CHOSEN.
+ */
+function isRulePromoted(rule, chosen, index) {
+    if (index === null)
+        return false;
+    const promotes = (profile) => profile !== undefined &&
+        profile.framework === rule.framework &&
+        Object.hasOwn(profile.rules, rule.id) &&
+        isDrawn(profile.rules[rule.id]);
+    if (promotes(index.defaults.get(rule.framework)))
+        return true;
+    if (chosen === null)
+        return false;
+    for (const id of chosen.values()) {
+        if (promotes(index.byId.get(id)))
+            return true;
+    }
+    return false;
+}
 /**
  * The moment `rule` is evaluated at, GIVEN the levels of requirement in force
  * on this surface — the one decision {@link runRules} takes before it reads a
  * single element.
  *
- * A rule that declares the second moment keeps it, whatever any level says: an
- * explicit `'on-demand'` is the stronger statement, and a framework that made
- * it is not overruled by a table. Everything else turns on
- * {@link isRuleAuditOnly}: an `audit` finding is dropped before anything draws
- * it ({@link userFacingViolations}), so computing one inside the frame budget
- * buys the user nothing.
+ * Everything turns on {@link isRuleAuditOnly}: an `audit` finding is dropped
+ * before anything draws it ({@link userFacingViolations}), so computing one
+ * inside the frame budget buys the user nothing.
+ *
+ * ## A declared `'on-demand'` yields to a level that PROMOTES the rule
+ *
+ * It did not, until the UML recette of 2026-09-16. An explicit `'on-demand'`
+ * used to win against any table, on the argument that a framework which made
+ * that declaration is not overruled by one — and the consequence was a rule a
+ * level had explicitly raised to `'warning'` that still drew nothing, ever, on
+ * any gesture. `uml.strict` promotes nine of them; the PO chose Specification,
+ * emptied a lifeline's head, and the canvas stayed silent.
+ *
+ * So the arbitration is the other way round, and it is the narrow one:
+ * **choosing a level that NAMES the rule at a drawn severity puts it back on
+ * the drawing path** ({@link isRulePromoted}). A framework keeping a rule
+ * `'audit'` at every level keeps the second moment with it — which is how
+ * `uml.unreachable-*` stays a graph walk nobody pays for on a gesture — and a
+ * declaration nothing promotes is untouched. The rule stays the framework's to
+ * make: it makes it in its profile table now, where the rest of the level lives,
+ * instead of in two places that could disagree.
  *
  * Mixed levels resolve towards EVALUATING, exactly as {@link isRuleSilent}
  * needs `'off'` everywhere before it skips: one frame held to a level that
@@ -3798,8 +4204,9 @@ export function dirtyClosure(elements, dirty, previous, wasIn) {
  * walk where a wrong one costs a silent verdict.
  */
 function momentOf(rule, chosen, index) {
-    if ((rule.moment ?? 'realtime') !== 'realtime')
-        return 'on-demand';
+    if ((rule.moment ?? 'realtime') !== 'realtime') {
+        return isRulePromoted(rule, chosen, index) ? 'realtime' : 'on-demand';
+    }
     return isRuleAuditOnly(rule, chosen, index) ? 'on-demand' : 'realtime';
 }
 /**
@@ -3814,6 +4221,30 @@ function momentOf(rule, chosen, index) {
 function isRealtime(rule) {
     return (rule.moment ?? 'realtime') === 'realtime';
 }
+/**
+ * Whether the drawing path may EVER have to evaluate `rule` on this assembly:
+ * it declares the real-time moment, or some REGISTERED level promotes it past
+ * `audit`, which is what puts it back on that path ({@link momentOf}).
+ *
+ * The three callers below are the ones with no instance to read a chosen level
+ * from — they are computed once, against the registry, before any surface
+ * exists. Asking "could any level in this assembly promote it" is the honest
+ * static approximation of "does a level in force promote it": it can only
+ * over-answer, and over-answering costs one extra id in a set or one extra
+ * watched property, where under-answering costs a verdict that never appears
+ * and a stale one that never clears.
+ *
+ * `profiles` defaults to none, so a caller that has no registry — every unit
+ * fixture, and every host reading the declarations in the abstract — gets the
+ * declared moment, exactly as before.
+ */
+function couldBeRealtime(rule, profiles) {
+    if (isRealtime(rule))
+        return true;
+    return profiles.some(profile => profile.framework === rule.framework &&
+        Object.hasOwn(profile.rules, rule.id) &&
+        isDrawn(profile.rules[rule.id]));
+}
 /** The exceptions an element carries, always an array, never a copy to keep. */
 export function elementExceptions(element) {
     const stored = element.validationExceptions;
@@ -3920,7 +4351,7 @@ function runRules(rules, elements, profiles, moment, incremental) {
      * other moment, which no carry-over and no dirty-set walk can reconstruct. So
      * the answer is not "re-judge more", it is "there is nothing here to build
      * on", and that applies to {@link evaluateNoOverlap} exactly as it does to
-     * the twelve families that filter on subjects.
+     * the thirteen families that filter on subjects.
      *
      * A board with no profile registered has no regime to change and pays nothing
      * for the question.
@@ -4037,7 +4468,11 @@ export function checkupRules(rules, elements, profiles = []) {
 export function evaluateCheckup(rules, elements, profiles = [], seed) {
     return runRules(rules, elements, profiles, 'on-demand', seed === undefined
         ? undefined
-        : { dirty: seed, previous: [], wasIn: frameMembership(rules, elements) });
+        : {
+            dirty: seed,
+            previous: [],
+            wasIn: frameMembership(rules, elements, profiles),
+        });
 }
 /**
  * How long a check-up may hold the thread before yielding it back.
@@ -4290,28 +4725,41 @@ export const VERDICT_PROPS = [
  *
  * ## `text`, and why it is not in the constant
  *
- * `label-presence` is the one family whose verdict turns on an element's words,
- * and words are what a user changes by TYPING. Watched unconditionally, every
- * keystroke in every shape on the board would wake the debounced evaluation —
- * a cost paid by every document, for a question most of them never ask.
- *
- * So it is added exactly when a REAL-TIME rule of that family is registered.
- * The moment filter is deliberate and mirrors {@link backgroundElementIds}: an
- * on-demand rule is never evaluated on the gesture path, so waking that path for
- * it would hand back precisely what declaring the second moment bought — and a
- * framework that wants its naming checked while the user types says so by
- * declaring the rule real-time, which is the one place that decision belongs.
- *
- * The DECLARED moment, like {@link backgroundElementIds} and for the same
- * reason: this set is computed ONCE per manager, before any surface exists to
- * read a level from, and watching a prop nothing turns out to need costs a
+ * `label-presence` and `label-syntax` are the two families whose verdict turns
+ * on an element's words, and words are what a user changes by TYPING. Watched
+ * unconditionally, every keystroke in every shape on the board would wake the
+ * debounced evaluation — a cost paid by every document, for a question most of
+ * them never ask.
+ *
+ * So it is added exactly when a rule of either family COULD reach the gesture
+ * path — it declares the real-time moment, or some registered level promotes it
+ * ({@link couldBeRealtime}). The filter mirrors {@link backgroundElementIds}: an
+ * on-demand rule no level can promote is never evaluated on the gesture path, so
+ * waking that path for it would hand back precisely what declaring the second
+ * moment bought.
+ *
+ * The level half of that test is what makes "Specification is the check-up"
+ * true for the two families that read WORDS. `uml.strict` promotes six spelling
+ * rules and three naming ones; without the promoted rules' `text` in this set,
+ * choosing Specification would raise them once, on the switch, and then never
+ * again while the user retyped the very word the finding is about.
+ *
+ * Read STATICALLY, like {@link backgroundElementIds} and for the same reason:
+ * this set is computed ONCE per manager, before any surface exists to read a
+ * chosen level from, and watching a prop nothing turns out to need costs a
  * debounced pass that finds nothing — never a wrong verdict.
  */
-export function verdictPropsOf(rules) {
+export function verdictPropsOf(rules, profiles = []) {
     const props = new Set(VERDICT_PROPS);
     for (const rule of rules) {
-        if (rule.family === 'label-presence' && isRealtime(rule))
+        // The two families whose verdict turns on an element's words. Neither is
+        // named as a constant: the second reads the same `text` slot (and, for a
+        // connector end label, props that only exist on a connector, which are
+        // watched through their own element's change anyway).
+        if ((rule.family === 'label-presence' || rule.family === 'label-syntax') &&
+            couldBeRealtime(rule, profiles)) {
             props.add('text');
+        }
         // The level a VIEW declares decides which roles it admits, so changing it —
         // or clearing it back to "free sketch", which DELETES the key, which is why
         // `touchesVerdict` reads `oldValues` too — re-judges everything drawn on
@@ -4515,7 +4963,7 @@ export class ValidationManager extends InteractivityExtension {
      * beside the rules it is derived from — see {@link verdictPropsOf}.
      */
     get _watchedProps() {
-        this._verdictProps ??= verdictPropsOf(this._activeRules);
+        this._verdictProps ??= verdictPropsOf(this._activeRules, this._activeProfiles);
         return this._verdictProps;
     }
     /**
@@ -4672,8 +5120,8 @@ export class ValidationManager extends InteractivityExtension {
             ? { dirty, previous, wasIn: this._membership }
             : undefined);
         this._evaluated = true;
-        this._backgrounds = backgroundElementIds(rules, surface.elementModels);
-        this._membership = frameMembership(rules, surface.elementModels);
+        this._backgrounds = backgroundElementIds(rules, surface.elementModels, this._activeProfiles);
+        this._membership = frameMembership(rules, surface.elementModels, this._activeProfiles);
         // Stay silent when nothing changed: `violations$` is the seam a host panel
         // subscribes to, and a clean board must not wake it on every debounce tick.
         if (violations.length === 0 && this.violations$.peek().length === 0)