cbrowser 20.2.2 → 21.0.0

package/dist/cif-score.js

@@ -11,16 +11,46 @@
  * 4. Sensory Fitness (15%) -- can they process without overload?
  * 5. Navigation Fitness (20%) -- can they get around?
  *
+ * Every number the score computes with is read through param() from
+ * visual/provenance/cif.ts, which says where it comes from: five are WCAG's,
+ * four are units or display choices, and the rest (the weights above among
+ * them) were set by hand. tests/cif-no-literals.test.ts keeps it that way.
+ *
+ * MISSING INPUTS follow one rule, stated with its rationale at cif.noData.score
+ * in visual/provenance/cif.ts: a component scores only from inputs the caller
+ * supplied, no assumed value ever stands in for a missing one, and a component
+ * with none of its inputs supplied is marked `measured: false`, scores
+ * cif.noData.score, says "Not measured" in its details, is listed in
+ * `notMeasured` and is never a top issue. `barriers` counts as supplied when it
+ * is an array, even an empty one (an audit ran and found nothing); undefined
+ * means no audit ran.
+ *
+ * CERTIFICATION needs every component measured. The grade is read from the
+ * composite as always, but platinum, gold, silver and bronze are issued only
+ * when all 25 components were measured; otherwise the certification is "none"
+ * and `certificationNote` says how many were not. An unmeasured component scores
+ * cif.noData.score, so without this a page with nothing measured certified
+ * bronze. (Alexa, 2026-10-24.)
+ *
  * @copyright 2026 Alexandria Eden alexandria.shai.eden@gmail.com https://cbrowser.ai
  * @license MIT
  * @since v19.0.0
  */
+import { param } from "./visual/model-provenance.js";
+import { bandSentence, isPercentile, rankStatement } from "./visual/ctc-bands.js";
 // ============================================================================
 // Utility functions
 // ============================================================================
-/** Clamp value between 0 and 100 */
+/** Read every id in `ids` through param(); one object per call so the reads are recorded. */
+function readParams(ids) {
+    const out = {};
+    for (const k in ids)
+        out[k] = param(ids[k]);
+    return out;
+}
+/** Clamp value between 0 and the top of the scale */
 function clamp(val) {
-    return Math.max(0, Math.min(100, val));
+    return Math.max(0, Math.min(param("cif.scale.max"), val));
 }
 /** Sigmoid function centered at 0, scaled to [0, 1] */
 function sigmoid(x) {
@@ -28,19 +58,36 @@ function sigmoid(x) {
 }
 /** Weighted average of component scores */
 function weightedAvg(components) {
+    const empty = param("cif.emptyAverage");
     let totalWeight = 0;
     let totalScore = 0;
     for (const c of components) {
         totalScore += c.score * c.weight;
         totalWeight += c.weight;
     }
-    return totalWeight > 0 ? totalScore / totalWeight : 50;
+    return totalWeight > 0 ? totalScore / totalWeight : empty;
 }
-/** Safe number that defaults if input is null/undefined/NaN */
-function safe(val, fallback) {
-    if (val == null || isNaN(val))
-        return fallback;
-    return val;
+/** True when the caller supplied a usable number (not null, undefined or NaN). */
+function supplied(val) {
+    return val != null && !Number.isNaN(val);
+}
+/** A measured component score. */
+function measured(score, details) {
+    return { score, details, measured: true };
+}
+/** A component none of whose inputs was supplied; `missing` names them. See cif.noData.score. */
+function notMeasured(missing) {
+    return { score: param("cif.noData.score"), details: `Not measured: no ${missing} supplied`, measured: false };
+}
+/**
+ * Score at the knee of a two-slope piecewise component: where the slope from
+ * the free point reaches it. Derived rather than registered, so the branch
+ * above the knee always starts where the branch below ends. overloadThreshold
+ * stepped from 61 to 60 at its knee because its knee score was a separate
+ * constant (21.0).
+ */
+function kneeScore(top, free, knee, slopeBelow) {
+    return top - (knee - free) * slopeBelow;
 }
 /** Count barriers of a given type */
 function countBarriersByType(barriers, type) {
@@ -48,97 +95,137 @@ function countBarriersByType(barriers, type) {
         return 0;
     return barriers.filter((b) => b.type === type).length;
 }
-/** Count barriers matching a substring in type or description */
-function countBarriersMatching(barriers, pattern) {
+/**
+ * Does a barrier's type or description name `word`? As a whole word or its
+ * plural, with "_" and "-" as separators: "form_unlabeled", "long-form",
+ * "Form input" and "captions" match; "Information", "platform", "format",
+ * "performance", "conform" and "skipped" do not. A substring match counted
+ * empathy_audit's colour-only barrier ("Information conveyed by color alone")
+ * as a form barrier too (21.0).
+ */
+function matchesBarrier(b, word) {
+    const named = new RegExp(`(^|[^\\p{L}\\p{N}])${word.toLowerCase()}s?([^\\p{L}\\p{N}]|$)`, "u");
+    return named.test(b.type.toLowerCase()) || named.test((b.description || "").toLowerCase());
+}
+/** Count barriers whose type or description names `word` (matchesBarrier). */
+function countBarriersMatching(barriers, word) {
     if (!barriers)
         return 0;
-    const p = pattern.toLowerCase();
-    return barriers.filter((b) => b.type.toLowerCase().includes(p) ||
-        (b.description || "").toLowerCase().includes(p)).length;
+    return barriers.filter((b) => matchesBarrier(b, word)).length;
+}
+/** empathy_audit's close-spacing barrier, which it weights as target_spacing. */
+function isCloseSpacing(b) {
+    return b.weightKey === "target_spacing";
+}
+function countCloseSpacingBarriers(barriers) {
+    return barriers ? barriers.filter(isCloseSpacing).length : 0;
 }
 // ============================================================================
 // Category Scorers
 // ============================================================================
+const MOTOR_IDS = {
+    scale: "cif.scale.max",
+    targetPx: "cif.wcag.targetSizeEnhancedPx",
+    touchBarrierPenalty: "cif.motor.touchTarget.barrierPenalty",
+    touchBarrierFloor: "cif.motor.touchTarget.barrierFloor",
+    hitMidpointPx: "cif.motor.hit.midpointPx",
+    hitScalePx: "cif.motor.hit.scalePx",
+    interactiveFree: "cif.motor.interactive.freeCount",
+    interactiveKnee: "cif.motor.interactive.kneeCount",
+    interactiveSlopeBelow: "cif.motor.interactive.slopeBelowKnee",
+    interactiveSlopeAbove: "cif.motor.interactive.slopeAboveKnee",
+    spacingBarrierPenalty: "cif.motor.spacing.barrierPenalty",
+    spacingGapPx: "cif.motor.spacing.minGapPx",
+    dragBarrierPenalty: "cif.motor.drag.barrierPenalty",
+    wTouchTarget: "cif.motor.weight.touchTargetCompliance",
+    wHit: "cif.motor.weight.hitProbability",
+    wInteraction: "cif.motor.weight.interactionCount",
+    wSpacing: "cif.motor.weight.spacingAdequacy",
+    wDrag: "cif.motor.weight.dragFreeAlternatives",
+};
 function computeMotorFitness(data) {
+    const P = readParams(MOTOR_IDS);
+    const targets = data.touchTargets && data.touchTargets.length > 0 ? data.touchTargets : null;
     // --- touchTargetCompliance (30%) ---
     let touchTargetCompliance;
-    if (data.touchTargets && data.touchTargets.length > 0) {
-        const nonExempt = data.touchTargets.filter((t) => !t.exempt);
+    if (targets) {
+        const nonExempt = targets.filter((t) => !t.exempt);
         if (nonExempt.length === 0) {
-            touchTargetCompliance = { score: 100, details: "All interactive elements are exempt from size requirements" };
+            touchTargetCompliance = measured(P.scale, "All interactive elements are exempt from size requirements");
         }
         else {
-            const compliant = nonExempt.filter((t) => Math.min(t.width, t.height) >= 44).length;
-            const pct = (compliant / nonExempt.length) * 100;
-            touchTargetCompliance = {
-                score: clamp(Math.round(pct)),
-                details: `${compliant}/${nonExempt.length} interactive elements meet 44px minimum (${Math.round(pct)}%)`,
-            };
+            const compliant = nonExempt.filter((t) => Math.min(t.width, t.height) >= P.targetPx).length;
+            const pct = (compliant / nonExempt.length) * P.scale;
+            touchTargetCompliance = measured(clamp(Math.round(pct)), `${compliant}/${nonExempt.length} interactive elements meet ${P.targetPx}px minimum (${Math.round(pct)}%)`);
         }
     }
-    else {
-        // Fall back to barrier count as proxy
+    else if (data.barriers) {
+        // No sizes: fall back to the audit's touch_target barriers
         const touchBarriers = countBarriersByType(data.barriers, "touch_target");
-        touchTargetCompliance = {
-            score: clamp(Math.max(30, 100 - touchBarriers * 15)),
-            details: touchBarriers > 0
-                ? `${touchBarriers} touch target barriers detected (no size data available)`
-                : "No touch target data available -- estimated from barriers",
-        };
+        touchTargetCompliance = measured(clamp(Math.max(P.touchBarrierFloor, P.scale - touchBarriers * P.touchBarrierPenalty)), touchBarriers > 0
+            ? `${touchBarriers} touch target barriers detected (no size data; scored from barriers)`
+            : "No touch target barriers detected (no size data; scored from barriers)");
+    }
+    else {
+        touchTargetCompliance = notMeasured("touch target sizes or audit barriers");
     }
     // --- hitProbability (25%) ---
     let hitProbability;
-    if (data.touchTargets && data.touchTargets.length > 0) {
-        const nonExempt = data.touchTargets.filter((t) => !t.exempt);
+    if (targets) {
+        const nonExempt = targets.filter((t) => !t.exempt);
         if (nonExempt.length === 0) {
-            hitProbability = { score: 100, details: "No non-exempt interactive elements" };
+            hitProbability = measured(P.scale, "No non-exempt interactive elements");
         }
         else {
             const avgMinDim = nonExempt.reduce((sum, t) => sum + Math.min(t.width, t.height), 0) /
                 nonExempt.length;
-            const score = sigmoid((avgMinDim - 20) / 10) * 100;
-            hitProbability = {
-                score: clamp(Math.round(score)),
-                details: `Average minimum dimension: ${Math.round(avgMinDim)}px (sigmoid-scored)`,
-            };
+            const score = sigmoid((avgMinDim - P.hitMidpointPx) / P.hitScalePx) * P.scale;
+            hitProbability = measured(clamp(Math.round(score)), `Average minimum dimension: ${Math.round(avgMinDim)}px (sigmoid-scored)`);
         }
     }
     else {
-        hitProbability = {
-            score: 100,
-            details: "No touch target barriers detected",
-        };
+        hitProbability = notMeasured("touch target sizes");
     }
     // --- interactionCount (20%) ---
-    // Under 20 interactive elements is fine; penalize progressively above that
-    const interactiveCount = safe(data.interactiveCount, 50);
-    const interactionCountScore = interactiveCount <= 20 ? 100
-        : interactiveCount <= 40 ? clamp(Math.round(100 - (interactiveCount - 20) * 2.5))
-            : clamp(Math.round(50 - (interactiveCount - 40) * 1));
-    const interactionCount = {
-        score: interactionCountScore,
-        details: interactiveCount <= 20
+    // Under the free count interactive elements are fine; penalize progressively above that
+    let interactionCount;
+    if (supplied(data.interactiveCount)) {
+        const interactiveCount = data.interactiveCount;
+        const interactionCountScore = interactiveCount <= P.interactiveFree ? P.scale
+            : interactiveCount <= P.interactiveKnee ? clamp(Math.round(P.scale - (interactiveCount - P.interactiveFree) * P.interactiveSlopeBelow))
+                : clamp(Math.round(kneeScore(P.scale, P.interactiveFree, P.interactiveKnee, P.interactiveSlopeBelow) - (interactiveCount - P.interactiveKnee) * P.interactiveSlopeAbove));
+        interactionCount = measured(interactionCountScore, interactiveCount <= P.interactiveFree
             ? `${interactiveCount} interactive elements — manageable for motor impairments`
-            : `${interactiveCount} interactive elements on page (fewer is easier for motor impairments)`,
-    };
+            : `${interactiveCount} interactive elements on page (fewer is easier for motor impairments)`);
+    }
+    else {
+        interactionCount = notMeasured("interactive element count");
+    }
     // --- spacingAdequacy (15%) ---
-    const touchTargetBarriers = countBarriersByType(data.barriers, "touch_target");
-    const spacingScore = clamp(Math.round(100 - touchTargetBarriers * 15));
-    const spacingAdequacy = {
-        score: spacingScore,
-        details: touchTargetBarriers > 0
-            ? `${touchTargetBarriers} touch target/spacing barriers detected`
-            : "No spacing barriers detected",
-    };
+    // Reads only the audit's close-spacing barrier. touch_target barriers are SIZE
+    // findings and belong to touchTargetCompliance; counting them here too
+    // penalised a page twice for the same barrier.
+    let spacingAdequacy;
+    if (data.barriers) {
+        const closeSpacing = countCloseSpacingBarriers(data.barriers);
+        spacingAdequacy = measured(clamp(Math.round(P.scale - closeSpacing * P.spacingBarrierPenalty)), closeSpacing > 0
+            ? `${closeSpacing} close-spacing barriers detected (interactive elements under ${P.spacingGapPx}px apart)`
+            : "No close-spacing barriers detected");
+    }
+    else {
+        spacingAdequacy = notMeasured("audit barriers");
+    }
     // --- dragFreeAlternatives (10%) ---
-    const dragBarriers = countBarriersMatching(data.barriers, "drag");
-    const dragScore = clamp(100 - dragBarriers * 25);
-    const dragFreeAlternatives = {
-        score: dragScore,
-        details: dragBarriers > 0
+    let dragFreeAlternatives;
+    if (data.barriers) {
+        const dragBarriers = countBarriersMatching(data.barriers, "drag");
+        dragFreeAlternatives = measured(clamp(P.scale - dragBarriers * P.dragBarrierPenalty), dragBarriers > 0
             ? `${dragBarriers} drag-dependent interactions found without alternatives`
-            : "No drag-dependent interactions detected",
-    };
+            : "No drag-dependent interactions detected");
+    }
+    else {
+        dragFreeAlternatives = notMeasured("audit barriers");
+    }
     const components = {
         touchTargetCompliance,
         hitProbability,
@@ -147,79 +234,101 @@ function computeMotorFitness(data) {
         dragFreeAlternatives,
     };
     const score = clamp(Math.round(weightedAvg([
-        { score: touchTargetCompliance.score, weight: 0.30 },
-        { score: hitProbability.score, weight: 0.25 },
-        { score: interactionCount.score, weight: 0.20 },
-        { score: spacingAdequacy.score, weight: 0.15 },
-        { score: dragFreeAlternatives.score, weight: 0.10 },
+        { score: touchTargetCompliance.score, weight: P.wTouchTarget },
+        { score: hitProbability.score, weight: P.wHit },
+        { score: interactionCount.score, weight: P.wInteraction },
+        { score: spacingAdequacy.score, weight: P.wSpacing },
+        { score: dragFreeAlternatives.score, weight: P.wDrag },
     ])));
     return { score, components };
 }
+const VISUAL_IDS = {
+    scale: "cif.scale.max",
+    normalText: "cif.wcag.contrastNormalText",
+    largeText: "cif.wcag.contrastLargeText",
+    contrastBarrierPenalty: "cif.visual.contrast.barrierPenalty",
+    proxySlope: "cif.visual.contrast.proxySlope",
+    proxyIntercept: "cif.visual.contrast.proxyIntercept",
+    densityKnee: "cif.visual.textScalability.densityKnee",
+    scalabilitySlope: "cif.visual.textScalability.slope",
+    resizePct: "cif.wcag.resizeTextPercent",
+    colorBarrierPenalty: "cif.visual.color.barrierPenalty",
+    wContrast: "cif.visual.weight.contrastCompliance",
+    wScalability: "cif.visual.weight.textScalability",
+    wColor: "cif.visual.weight.colorIndependence",
+    wFocus: "cif.visual.weight.focusVisibility",
+    wSpacing: "cif.visual.weight.spacingDensity",
+};
 function computeVisualFitness(data) {
+    const P = readParams(VISUAL_IDS);
     // --- contrastCompliance (30%) ---
     let contrastCompliance;
+    const contrastBarriers = countBarriersByType(data.barriers, "contrast");
     if (data.contrastIssues && data.contrastIssues.length > 0) {
-        // Use element count as proxy for total text elements
-        const totalTextEstimate = Math.max(safe(data.elementCount, 50), data.contrastIssues.length);
-        const failRatio = data.contrastIssues.length / totalTextEstimate;
-        const score = clamp(Math.round(100 - failRatio * 100));
-        const failingBelow45 = data.contrastIssues.filter((c) => !c.isLargeText && c.ratio < 4.5).length;
-        const failingBelow3 = data.contrastIssues.filter((c) => c.isLargeText && c.ratio < 3).length;
-        contrastCompliance = {
-            score,
-            details: `${data.contrastIssues.length} contrast issues (${failingBelow45} normal text below 4.5:1, ${failingBelow3} large text below 3:1)`,
-        };
-    }
-    else {
-        // Fall back to contrast barriers
-        const contrastBarriers = countBarriersByType(data.barriers, "contrast");
-        if (contrastBarriers > 0) {
-            contrastCompliance = {
-                score: clamp(100 - contrastBarriers * 10),
-                details: `${contrastBarriers} contrast barriers detected`,
-            };
+        const issues = data.contrastIssues.length;
+        const failingNormalText = data.contrastIssues.filter((c) => !c.isLargeText && c.ratio < P.normalText).length;
+        const failingLargeText = data.contrastIssues.filter((c) => c.isLargeText && c.ratio < P.largeText).length;
+        const breakdown = `${failingNormalText} normal text below ${P.normalText}:1, ${failingLargeText} large text below ${P.largeText}:1`;
+        if (supplied(data.elementCount)) {
+            // Share of elements with an issue, the element count standing in for the text elements checked
+            const failRatio = issues / Math.max(data.elementCount, issues);
+            contrastCompliance = measured(clamp(Math.round(P.scale - failRatio * P.scale)), `${issues} contrast issues among ${Math.max(data.elementCount, issues)} elements (${breakdown})`);
         }
         else {
-            // Use agent_ready accessibility subscore as proxy
-            const accessibilityProxy = safe(data.agentReadyScore, 60);
-            contrastCompliance = {
-                score: clamp(Math.round(accessibilityProxy * 0.8 + 20)),
-                details: "No contrast data -- estimated from agent-ready accessibility score",
-            };
+            // No element count, so no share: scored per issue, like contrast barriers
+            contrastCompliance = measured(clamp(P.scale - issues * P.contrastBarrierPenalty), `${issues} contrast issues (${breakdown}); no element count, so scored per issue`);
         }
     }
+    else if (contrastBarriers > 0) {
+        contrastCompliance = measured(clamp(P.scale - contrastBarriers * P.contrastBarrierPenalty), `${contrastBarriers} contrast barriers detected`);
+    }
+    else if (supplied(data.agentReadyScore)) {
+        // Use agent_ready accessibility subscore as proxy
+        contrastCompliance = measured(clamp(Math.round(data.agentReadyScore * P.proxySlope + P.proxyIntercept)), "No contrast data -- estimated from agent-ready accessibility score");
+    }
+    else {
+        contrastCompliance = notMeasured("contrast issues, contrast barriers or agent-ready score");
+    }
     // --- textScalability (20%) ---
-    // Assume text scales correctly unless density is very high (which breaks at zoom)
-    const density = safe(data.informationDensity, 0.5);
-    const scalabilityDeduction = density > 0.6 ? (density - 0.6) * 80 : 0;
-    const textScalability = {
-        score: clamp(Math.round(100 - scalabilityDeduction)),
-        details: scalabilityDeduction > 0
-            ? `High density (${(density * 100).toFixed(0)}%) may cause overlap at 200% zoom (-${Math.round(scalabilityDeduction)})`
-            : "Text content can scale to 200% without loss of functionality",
-    };
+    // A proxy: nothing is zoomed. Penalised only when density is high enough that
+    // zooming would plausibly break the layout; the details say it was not checked.
+    let textScalability;
+    if (supplied(data.informationDensity)) {
+        const density = data.informationDensity;
+        const scalabilityDeduction = density > P.densityKnee ? (density - P.densityKnee) * P.scalabilitySlope : 0;
+        textScalability = measured(clamp(Math.round(P.scale - scalabilityDeduction)), scalabilityDeduction > 0
+            ? `High density (${(density * P.scale).toFixed(0)}%) may cause overlap at ${P.resizePct}% zoom (-${Math.round(scalabilityDeduction)}); estimated from density, the page was not zoomed`
+            : `Information density ${(density * P.scale).toFixed(0)}% is at or below ${(P.densityKnee * P.scale).toFixed(0)}%, so no deduction; resizing text to ${P.resizePct}% (WCAG 1.4.4) was not checked`);
+    }
+    else {
+        textScalability = notMeasured("information density");
+    }
     // --- colorIndependence (20%) ---
-    const colorOnlyBarriers = countBarriersMatching(data.barriers, "color");
-    const colorScore = clamp(100 - colorOnlyBarriers * 20);
-    const colorIndependence = {
-        score: colorScore,
-        details: colorOnlyBarriers > 0
+    let colorIndependence;
+    if (data.barriers) {
+        const colorOnlyBarriers = countBarriersMatching(data.barriers, "color");
+        colorIndependence = measured(clamp(P.scale - colorOnlyBarriers * P.colorBarrierPenalty), colorOnlyBarriers > 0
             ? `${colorOnlyBarriers} color-only information barriers detected`
-            : "No color-only information barriers detected",
-    };
+            : "No color-only information barriers detected");
+    }
+    else {
+        colorIndependence = notMeasured("audit barriers");
+    }
     // --- focusVisibility (15%) ---
-    const semanticProxy = safe(data.semanticScore, safe(data.agentReadyScore, 50));
-    const focusScore = clamp(Math.round((semanticProxy / 100) * 100));
-    const focusVisibility = {
-        score: focusScore,
-        details: `Estimated from semantic score (${Math.round(semanticProxy)}/100)`,
-    };
+    let focusVisibility;
+    if (supplied(data.semanticScore)) {
+        focusVisibility = measured(clamp(Math.round(data.semanticScore)), `Estimated from semantic score (${Math.round(data.semanticScore)}/${P.scale})`);
+    }
+    else if (supplied(data.agentReadyScore)) {
+        focusVisibility = measured(clamp(Math.round(data.agentReadyScore)), `Estimated from agent-ready score (${Math.round(data.agentReadyScore)}/${P.scale})`);
+    }
+    else {
+        focusVisibility = notMeasured("semantic or agent-ready score");
+    }
     // --- spacingDensity (15%) ---
-    const spacingDensityScore = clamp(Math.round(100 - density * 100));
-    const spacingDensity = {
-        score: spacingDensityScore,
-        details: `Information density: ${(density * 100).toFixed(0)}% (lower is better for visual processing)`,
-    };
+    const spacingDensity = supplied(data.informationDensity)
+        ? measured(clamp(Math.round(P.scale - data.informationDensity * P.scale)), `Information density: ${(data.informationDensity * P.scale).toFixed(0)}% (lower is better for visual processing)`)
+        : notMeasured("information density");
     const components = {
         contrastCompliance,
         textScalability,
@@ -228,82 +337,77 @@ function computeVisualFitness(data) {
         spacingDensity,
     };
     const score = clamp(Math.round(weightedAvg([
-        { score: contrastCompliance.score, weight: 0.30 },
-        { score: textScalability.score, weight: 0.20 },
-        { score: colorIndependence.score, weight: 0.20 },
-        { score: focusVisibility.score, weight: 0.15 },
-        { score: spacingDensity.score, weight: 0.15 },
+        { score: contrastCompliance.score, weight: P.wContrast },
+        { score: textScalability.score, weight: P.wScalability },
+        { score: colorIndependence.score, weight: P.wColor },
+        { score: focusVisibility.score, weight: P.wFocus },
+        { score: spacingDensity.score, weight: P.wSpacing },
     ])));
     return { score, components };
 }
+const COGNITIVE_IDS = {
+    scale: "cif.scale.max",
+    costDecimals: "cif.display.costDecimals",
+    decisionCostSlope: "cif.cognitive.decision.costSlope",
+    fleschGain: "cif.cognitive.readability.fleschGain",
+    densityFree: "cif.cognitive.density.freeCount",
+    densityKnee: "cif.cognitive.density.kneeCount",
+    densityDivisorBelow: "cif.cognitive.density.divisorBelowKnee",
+    densityDivisorAbove: "cif.cognitive.density.divisorAboveKnee",
+    captureGain: "cif.cognitive.attention.captureGain",
+    navFree: "cif.cognitive.predictability.freeCount",
+    navSlope: "cif.cognitive.predictability.slope",
+    wDecision: "cif.cognitive.weight.decisionComplexity",
+    wReadability: "cif.cognitive.weight.readability",
+    wDensity: "cif.cognitive.weight.informationDensity",
+    wAttention: "cif.cognitive.weight.attentionClarity",
+    wPredictability: "cif.cognitive.weight.predictability",
+};
 function computeCognitiveFitness(data) {
+    const P = readParams(COGNITIVE_IDS);
     // --- decisionComplexity (25%) ---
-    let decisionCost = 0;
-    if (data.layers && data.layers.length > 0) {
-        const decisionLayer = data.layers.find((l) => l.name.toLowerCase().includes("decision") || l.name.toLowerCase().includes("choice"));
-        decisionCost = decisionLayer ? decisionLayer.cost : 0;
-    }
-    const decisionScore = clamp(Math.round(100 - decisionCost * 200));
-    const decisionComplexity = {
-        score: decisionScore,
-        details: decisionCost > 0
-            ? `Decision layer cost: ${decisionCost.toFixed(3)} (lower is better)`
-            : "No CTC decision layer data available",
-    };
+    const decisionLayer = data.layers?.find((l) => l.name.toLowerCase().includes("decision") || l.name.toLowerCase().includes("choice"));
+    const decisionComplexity = decisionLayer
+        ? measured(clamp(Math.round(P.scale - decisionLayer.cost * P.decisionCostSlope)), `Decision layer cost: ${decisionLayer.cost.toFixed(P.costDecimals)} (lower is better)`)
+        : notMeasured(data.layers && data.layers.length > 0 ? "decision or choice layer among the CTC layers" : "CTC layers");
     // --- readability (20%) ---
-    const flesch = data.fleschScore;
-    const readabilityScore = flesch != null
-        ? clamp(Math.round(Math.min(100, flesch * 1.2)))
-        : 60; // No data = assume mediocre readability (not optimistic)
-    const readability = {
-        score: readabilityScore,
-        details: flesch != null
-            ? `Flesch readability score: ${Math.round(flesch)} (higher = more readable)`
-            : "No readability data available — estimated 60 (conservative)",
-    };
+    const readability = supplied(data.fleschScore)
+        ? measured(clamp(Math.round(Math.min(P.scale, data.fleschScore * P.fleschGain))), `Flesch readability score: ${Math.round(data.fleschScore)} (higher = more readable)`)
+        : notMeasured("Flesch reading-ease score");
     // --- informationDensity (20%) ---
     // A well-structured page can have many elements without being overwhelming.
     // Only penalize when element count is extremely high relative to viewport.
-    // Threshold: 200 elements is fine, 500+ starts getting dense, 2000+ is overwhelming.
-    const elemCount = safe(data.elementCount, 100);
-    const infoScore = elemCount <= 200 ? 100
-        : elemCount <= 500 ? clamp(Math.round(100 - (elemCount - 200) / 6))
-            : clamp(Math.round(50 - (elemCount - 500) / 30));
-    const informationDensity = {
-        score: infoScore,
-        details: elemCount <= 200
+    // Threshold: the free count is fine, the knee starts getting dense, 2000+ is overwhelming.
+    let informationDensity;
+    if (supplied(data.elementCount)) {
+        const elemCount = data.elementCount;
+        const infoScore = elemCount <= P.densityFree ? P.scale
+            : elemCount <= P.densityKnee ? clamp(Math.round(P.scale - (elemCount - P.densityFree) / P.densityDivisorBelow))
+                : clamp(Math.round(kneeScore(P.scale, P.densityFree, P.densityKnee, 1 / P.densityDivisorBelow) - (elemCount - P.densityKnee) / P.densityDivisorAbove));
+        informationDensity = measured(infoScore, elemCount <= P.densityFree
             ? `${elemCount} elements — well within cognitive limits`
-            : `${elemCount} elements on page (progressive penalty above 200)`,
-    };
+            : `${elemCount} elements on page (progressive penalty above ${P.densityFree})`);
+    }
+    else {
+        informationDensity = notMeasured("element count");
+    }
     // --- attentionClarity (20%) ---
-    const captureRate = data.ctaCaptureRate;
-    const attentionScore = captureRate != null
-        ? clamp(Math.round(Math.min(100, captureRate * 200)))
-        : 60; // No data = assume mediocre CTA clarity (not optimistic)
-    const attentionClarity = {
-        score: attentionScore,
-        details: captureRate != null
-            ? `CTA capture rate: ${(captureRate * 100).toFixed(1)}% (higher = clearer attention guidance)`
-            : "No attention data available — estimated 60 (conservative)",
-    };
+    const attentionClarity = supplied(data.ctaCaptureRate)
+        ? measured(clamp(Math.round(Math.min(P.scale, data.ctaCaptureRate * P.captureGain))), `CTA capture rate: ${(data.ctaCaptureRate * P.scale).toFixed(1)}% (higher = clearer attention guidance)`)
+        : notMeasured("CTA capture rate");
     // --- predictability (15%) ---
-    const navItems = safe(data.navItemCount, 5);
-    let predictScore;
-    if (navItems <= 7) {
-        predictScore = 100;
-    }
-    else if (navItems <= 12) {
-        predictScore = clamp(Math.round(100 - (navItems - 7) * 5));
+    let predictability;
+    if (supplied(data.navItemCount)) {
+        const navItems = data.navItemCount;
+        // One slope above the free count. The knee at 12 it replaced joined two equal
+        // slopes, so it changed no score (21.0).
+        predictability = measured(navItems <= P.navFree ? P.scale : clamp(Math.round(P.scale - (navItems - P.navFree) * P.navSlope)), navItems <= P.navFree
+            ? `${navItems} navigation items — clear, predictable structure`
+            : `${navItems} navigation items (${P.navFree} or fewer is optimal for cognitive predictability)`);
     }
     else {
-        predictScore = clamp(Math.round(75 - (navItems - 12) * 5));
+        predictability = notMeasured("navigation item count");
     }
-    const predictability = {
-        score: predictScore,
-        details: navItems <= 7
-            ? `${navItems} navigation items — clear, predictable structure`
-            : `${navItems} navigation items (7 or fewer is optimal for cognitive predictability)`,
-    };
     const components = {
         decisionComplexity,
         readability,
@@ -312,71 +416,123 @@ function computeCognitiveFitness(data) {
         predictability,
     };
     const score = clamp(Math.round(weightedAvg([
-        { score: decisionComplexity.score, weight: 0.25 },
-        { score: readability.score, weight: 0.20 },
-        { score: informationDensity.score, weight: 0.20 },
-        { score: attentionClarity.score, weight: 0.20 },
-        { score: predictability.score, weight: 0.15 },
+        { score: decisionComplexity.score, weight: P.wDecision },
+        { score: readability.score, weight: P.wReadability },
+        { score: informationDensity.score, weight: P.wDensity },
+        { score: attentionClarity.score, weight: P.wAttention },
+        { score: predictability.score, weight: P.wPredictability },
     ])));
     return { score, components };
 }
+const SENSORY_IDS = {
+    scale: "cif.scale.max",
+    costDecimals: "cif.display.costDecimals",
+    controlledFloor: "cif.sensory.animation.controlledFloor",
+    controlledPenalty: "cif.sensory.animation.controlledPenalty",
+    uncontrolledPenalty: "cif.sensory.animation.uncontrolledPenalty",
+    audioBarrierPenalty: "cif.sensory.audio.barrierPenalty",
+    calmDensityWeight: "cif.sensory.calm.densityWeight",
+    calmAnimationPenalty: "cif.sensory.calm.animationPenalty",
+    // The verdict bands' cut points (provenance/ctc-reference.ts), not CIF's own:
+    // totalCTC is a percentile of real pages since 21.x, and CIF's 0.3 and 0.6
+    // were cuts on the logistic it used to be.
+    easyCTC: "ctcBands.upperHalf",
+    kneeCTC: "ctcBands.high",
+    overloadSlopeBelow: "cif.sensory.overload.slopeBelowKnee",
+    overloadSlopeAbove: "cif.sensory.overload.slopeAboveKnee",
+    wAnimation: "cif.sensory.weight.animationControl",
+    wIndependence: "cif.sensory.weight.sensoryIndependence",
+    wCalm: "cif.sensory.weight.visualCalm",
+    wLayout: "cif.sensory.weight.layoutConsistency",
+    wOverload: "cif.sensory.weight.overloadThreshold",
+};
 function computeSensoryFitness(data) {
+    const P = readParams(SENSORY_IDS);
     // --- animationControl (30%) ---
-    const animCount = safe(data.animationCount, 0);
-    const hasMotionSupport = !!data.hasReducedMotionSupport;
-    // If prefers-reduced-motion is supported, animations are user-controllable → score 95 (not 100, small tax for having them at all)
-    // Without support, each animation is a hard penalty
-    const animScore = hasMotionSupport
-        ? clamp(Math.max(90, 100 - animCount)) // 90-100 range — minor tax for quantity
-        : animCount === 0 ? 100 : clamp(Math.round(100 - animCount * 20));
-    const animationControl = {
-        score: animScore,
-        details: animCount === 0
-            ? "No animations detected"
-            : hasMotionSupport
-                ? `${animCount} animations detected — prefers-reduced-motion supported (user can disable)`
-                : `${animCount} animations detected without motion preference support (each deducts 20 points)`,
-    };
+    // With prefers-reduced-motion support, animations are user-controllable → a small tax per animation, down to the floor.
+    // Without support, each animation is a hard penalty. With animations and no support flag, the score is not measured.
+    const motionSupport = data.hasReducedMotionSupport;
+    let animationControl;
+    if (!supplied(data.animationCount)) {
+        animationControl = notMeasured("animation count");
+    }
+    else if (data.animationCount === 0) {
+        animationControl = measured(P.scale, "No animations detected");
+    }
+    else if (motionSupport === true) {
+        animationControl = measured(clamp(Math.max(P.controlledFloor, P.scale - data.animationCount * P.controlledPenalty)), // floor-to-top range — minor tax for quantity
+        `${data.animationCount} animations detected — prefers-reduced-motion supported (user can disable)`);
+    }
+    else if (motionSupport === false) {
+        animationControl = measured(clamp(Math.round(P.scale - data.animationCount * P.uncontrolledPenalty)), `${data.animationCount} animations detected without motion preference support (each deducts ${P.uncontrolledPenalty} points)`);
+    }
+    else {
+        animationControl = notMeasured(`prefers-reduced-motion support flag for the ${data.animationCount} animations detected`);
+    }
     // --- sensoryIndependence (25%) ---
-    const captionBarriers = countBarriersMatching(data.barriers, "caption");
-    const audioBarriers = countBarriersMatching(data.barriers, "audio");
-    const sensoryDeductions = (captionBarriers + audioBarriers) * 15;
-    const sensoryScore = clamp(100 - sensoryDeductions);
-    const sensoryIndependence = {
-        score: sensoryScore,
-        details: sensoryDeductions > 0
-            ? `${captionBarriers + audioBarriers} audio/caption barriers (each deducts 15)`
-            : "No audio/caption accessibility barriers detected",
-    };
+    let sensoryIndependence;
+    if (data.barriers) {
+        // Each barrier once, even when it mentions both captions and audio
+        const sensoryBarriers = data.barriers.filter((b) => matchesBarrier(b, "caption") || matchesBarrier(b, "audio")).length;
+        sensoryIndependence = measured(clamp(P.scale - sensoryBarriers * P.audioBarrierPenalty), sensoryBarriers > 0
+            ? `${sensoryBarriers} audio/caption barriers (each deducts ${P.audioBarrierPenalty})`
+            : "No audio/caption accessibility barriers detected");
+    }
+    else {
+        sensoryIndependence = notMeasured("audit barriers");
+    }
     // --- visualCalm (20%) ---
-    const density = safe(data.informationDensity, 0.5);
-    // If animations are user-controllable, they don't contribute to visual noise
-    const animCalmPenalty = hasMotionSupport ? 0 : animCount * 15;
-    const calmScore = clamp(Math.round(100 - density * 50 - animCalmPenalty));
-    const visualCalm = {
-        score: calmScore,
-        details: hasMotionSupport
-            ? `Information density: ${(density * 100).toFixed(0)}% (animations controllable via prefers-reduced-motion)`
-            : `Information density: ${(density * 100).toFixed(0)}%, ${animCount} uncontrolled animations`,
-    };
+    // Density is the input; animations adjust it only when their count and, if any, their motion support are known.
+    // If animations are user-controllable, they don't contribute to visual noise.
+    let visualCalm;
+    if (supplied(data.informationDensity)) {
+        const density = data.informationDensity;
+        const densityText = `Information density: ${(density * P.scale).toFixed(0)}%`;
+        let animCalmPenalty = 0;
+        let animText;
+        if (!supplied(data.animationCount)) {
+            animText = ", animations not measured";
+        }
+        else if (motionSupport === true) {
+            animText = " (animations controllable via prefers-reduced-motion)";
+        }
+        else if (motionSupport === false || data.animationCount === 0) {
+            animCalmPenalty = data.animationCount * P.calmAnimationPenalty;
+            animText = `, ${data.animationCount} uncontrolled animations`;
+        }
+        else {
+            animText = `, ${data.animationCount} animations (prefers-reduced-motion support not measured)`;
+        }
+        visualCalm = measured(clamp(Math.round(P.scale - density * P.calmDensityWeight - animCalmPenalty)), `${densityText}${animText}`);
+    }
+    else {
+        visualCalm = notMeasured("information density");
+    }
     // --- layoutConsistency (15%) ---
-    const agentReady = safe(data.agentReadyScore, 70);
-    const consistencyScore = clamp(Math.round(agentReady));
-    const layoutConsistency = {
-        score: consistencyScore,
-        details: `Layout consistency derived from structural score (${Math.round(agentReady)}/100)`,
-    };
+    const layoutConsistency = supplied(data.agentReadyScore)
+        ? measured(clamp(Math.round(data.agentReadyScore)), `Layout consistency derived from structural score (${Math.round(data.agentReadyScore)}/${P.scale})`)
+        : notMeasured("agent-ready score");
     // --- overloadThreshold (10%) ---
-    // CTC ≤ 0.3 is "easy" per our scale, 0.3-0.6 moderate, 0.6-1.0 hard, >1.0 very hard
-    const totalCTC = safe(data.totalCTC, 0.7);
-    const overloadScore = totalCTC <= 0.3 ? 100
-        : totalCTC <= 0.6 ? clamp(Math.round(100 - (totalCTC - 0.3) * 130))
-            : clamp(Math.round(60 - (totalCTC - 0.6) * 100));
-    const overloadThreshold = {
-        score: overloadScore,
-        details: totalCTC <= 0.3 ? `Total CTC: ${totalCTC.toFixed(3)} — within easy range`
-            : `Total CTC: ${totalCTC.toFixed(3)} (lower = less cognitive overload risk)`,
-    };
+    // totalCTC is a percentile of real pages. Full marks through the lower half
+    // (ctcBands.upperHalf), sloping to the knee at the high band (ctcBands.high),
+    // then steeper. The details state the rank; the CTC is untested against
+    // human data, so they say nothing about how easy the page is.
+    let overloadThreshold;
+    if (supplied(data.totalCTC) && !isPercentile(data.totalCTC)) {
+        // A value outside zero to one is from another scale (a raw cost, or a
+        // number from before 21.x): it has no rank to score.
+        overloadThreshold = notMeasured(`percentile total CTC (${data.totalCTC} is not a percentile, so it is from another scale and has no rank among the real pages we measured)`);
+    }
+    else if (supplied(data.totalCTC)) {
+        const totalCTC = data.totalCTC;
+        const overloadScore = totalCTC <= P.easyCTC ? P.scale
+            : totalCTC <= P.kneeCTC ? clamp(Math.round(P.scale - (totalCTC - P.easyCTC) * P.overloadSlopeBelow))
+                : clamp(Math.round(kneeScore(P.scale, P.easyCTC, P.kneeCTC, P.overloadSlopeBelow) - (totalCTC - P.kneeCTC) * P.overloadSlopeAbove));
+        overloadThreshold = measured(overloadScore, `Total CTC ${totalCTC.toFixed(P.costDecimals)}: ${rankStatement(totalCTC)}. ${bandSentence(totalCTC)}`);
+    }
+    else {
+        overloadThreshold = notMeasured("total CTC");
+    }
     const components = {
         animationControl,
         sensoryIndependence,
@@ -385,15 +541,27 @@ function computeSensoryFitness(data) {
         overloadThreshold,
     };
     const score = clamp(Math.round(weightedAvg([
-        { score: animationControl.score, weight: 0.30 },
-        { score: sensoryIndependence.score, weight: 0.25 },
-        { score: visualCalm.score, weight: 0.20 },
-        { score: layoutConsistency.score, weight: 0.15 },
-        { score: overloadThreshold.score, weight: 0.10 },
+        { score: animationControl.score, weight: P.wAnimation },
+        { score: sensoryIndependence.score, weight: P.wIndependence },
+        { score: visualCalm.score, weight: P.wCalm },
+        { score: layoutConsistency.score, weight: P.wLayout },
+        { score: overloadThreshold.score, weight: P.wOverload },
     ])));
     return { score, components };
 }
+const NAVIGATION_IDS = {
+    scale: "cif.scale.max",
+    keyboardBarrierPenalty: "cif.navigation.keyboard.barrierPenalty",
+    skipBarrierPenalty: "cif.navigation.skip.barrierPenalty",
+    formBarrierPenalty: "cif.navigation.form.barrierPenalty",
+    wSemantic: "cif.navigation.weight.semanticStructure",
+    wKeyboard: "cif.navigation.weight.keyboardOperability",
+    wSkip: "cif.navigation.weight.skipMechanisms",
+    wLinkButton: "cif.navigation.weight.linkButtonClarity",
+    wForm: "cif.navigation.weight.formAccessibility",
+};
 function computeNavigationFitness(data) {
+    const P = readParams(NAVIGATION_IDS);
     // --- semanticStructure (25%) ---
     const subScores = [];
     if (data.semanticScore != null)
@@ -402,51 +570,71 @@ function computeNavigationFitness(data) {
         subScores.push(data.headingScore);
     if (data.landmarkScore != null)
         subScores.push(data.landmarkScore);
-    const semanticAvg = subScores.length > 0
-        ? subScores.reduce((a, b) => a + b, 0) / subScores.length
-        : safe(data.agentReadyScore, 50);
-    const semanticStructure = {
-        score: clamp(Math.round(semanticAvg)),
-        details: subScores.length > 0
-            ? `Average of ${subScores.length} semantic sub-scores: ${Math.round(semanticAvg)}/100`
-            : `Estimated from agent-ready score: ${Math.round(semanticAvg)}/100`,
-    };
+    let semanticStructure;
+    if (subScores.length > 0) {
+        const semanticAvg = subScores.reduce((a, b) => a + b, 0) / subScores.length;
+        semanticStructure = measured(clamp(Math.round(semanticAvg)), `Average of ${subScores.length} semantic sub-scores: ${Math.round(semanticAvg)}/${P.scale}`);
+    }
+    else if (supplied(data.agentReadyScore)) {
+        semanticStructure = measured(clamp(Math.round(data.agentReadyScore)), `Estimated from agent-ready score: ${Math.round(data.agentReadyScore)}/${P.scale}`);
+    }
+    else {
+        semanticStructure = notMeasured("semantic, heading or landmark score, or agent-ready score");
+    }
     // --- keyboardOperability (25%) ---
-    const keyboardBarriers = countBarriersMatching(data.barriers, "keyboard");
-    const motorPrecision = countBarriersByType(data.barriers, "motor_precision");
-    const kbDeductions = (keyboardBarriers + motorPrecision) * 15;
-    const kbScore = clamp(100 - kbDeductions);
-    const keyboardOperability = {
-        score: kbScore,
-        details: kbDeductions > 0
-            ? `${keyboardBarriers + motorPrecision} keyboard/motor barriers detected`
-            : "No keyboard accessibility barriers detected",
-    };
+    let keyboardOperability;
+    if (data.barriers) {
+        // Each barrier once: a keyboard finding, or a motor_precision one other than
+        // the close-spacing barrier (spacingAdequacy counts that)
+        const kbBarriers = data.barriers.filter((b) => matchesBarrier(b, "keyboard") || (b.type === "motor_precision" && !isCloseSpacing(b))).length;
+        // empathy_audit's keyboard findings are hover-only and drag-without-keyboard
+        // interactions; the details say what it looks for and what it does not. The
+        // scope is the audit's, stated as such: a caller's list may hold other
+        // keyboard findings (a trap, an unreachable control), counted as found.
+        const auditScope = "keyboard reachability, traps or focus order";
+        keyboardOperability = measured(clamp(P.scale - kbBarriers * P.keyboardBarrierPenalty), kbBarriers > 0
+            ? `${kbBarriers} keyboard barriers detected; empathy_audit looks for hover-only and drag-without-keyboard interactions, not ${auditScope}`
+            : `No hover-only or drag-without-keyboard barriers detected; empathy_audit does not check ${auditScope}`);
+    }
+    else {
+        keyboardOperability = notMeasured("audit barriers");
+    }
     // --- skipMechanisms (15%) ---
-    const skipBarriers = countBarriersMatching(data.barriers, "skip");
-    const skipScore = clamp(100 - skipBarriers * 25);
-    const skipMechanisms = {
-        score: skipScore,
-        details: skipBarriers > 0
+    // Measured only when a skip-link check is known to have run: the caller says
+    // so (skipLinksChecked), or the list holds a skip finding. empathy_audit has
+    // no skip-link detector, so its empty list said nothing about skip links, and
+    // this read a clean 100 on every page (21.0).
+    let skipMechanisms;
+    const skipBarriers = data.barriers ? countBarriersMatching(data.barriers, "skip") : 0;
+    if (!data.barriers) {
+        skipMechanisms = notMeasured("audit barriers");
+    }
+    else if (data.skipLinksChecked !== true && skipBarriers === 0) {
+        skipMechanisms = notMeasured("skip-link check");
+    }
+    else {
+        skipMechanisms = measured(clamp(P.scale - skipBarriers * P.skipBarrierPenalty), skipBarriers > 0
             ? `${skipBarriers} skip mechanism issues detected`
-            : "No skip navigation issues detected",
-    };
+            : "No skip navigation issues detected");
+    }
     // --- linkButtonClarity (15%) ---
-    const ariaProxy = safe(data.ariaScore, 50);
-    const linkButtonClarity = {
-        score: clamp(Math.round(ariaProxy)),
-        details: `ARIA label score: ${Math.round(ariaProxy)}/100`,
-    };
+    const linkButtonClarity = supplied(data.ariaScore)
+        ? measured(clamp(Math.round(data.ariaScore)), `ARIA label score: ${Math.round(data.ariaScore)}/${P.scale}`)
+        : notMeasured("ARIA score");
     // --- formAccessibility (20%) ---
-    let formScore = safe(data.formLabelScore, 60);
-    const formBarriers = countBarriersMatching(data.barriers, "form");
-    formScore = clamp(formScore - formBarriers * 10);
-    const formAccessibility = {
-        score: clamp(Math.round(formScore)),
-        details: formBarriers > 0
-            ? `Form label score: ${Math.round(safe(data.formLabelScore, 60))}/100, ${formBarriers} form barriers`
-            : `Form label score: ${Math.round(safe(data.formLabelScore, 60))}/100`,
-    };
+    // The label score is the base; the audit's form barriers deduct from it. Either alone is a measurement.
+    let formAccessibility;
+    if (supplied(data.formLabelScore) || data.barriers) {
+        const labelScore = supplied(data.formLabelScore) ? data.formLabelScore : null;
+        const formBarriers = data.barriers ? countBarriersMatching(data.barriers, "form") : 0;
+        const labelText = labelScore !== null ? `Form label score: ${Math.round(labelScore)}/${P.scale}` : "Form label score not measured";
+        const barrierText = !data.barriers ? ", form barriers not measured"
+            : formBarriers > 0 ? `, ${formBarriers} form barriers` : "";
+        formAccessibility = measured(clamp(Math.round((labelScore ?? P.scale) - formBarriers * P.formBarrierPenalty)), `${labelText}${barrierText}`);
+    }
+    else {
+        formAccessibility = notMeasured("form label score or audit barriers");
+    }
     const components = {
         semanticStructure,
         keyboardOperability,
@@ -455,92 +643,134 @@ function computeNavigationFitness(data) {
         formAccessibility,
     };
     const score = clamp(Math.round(weightedAvg([
-        { score: semanticStructure.score, weight: 0.25 },
-        { score: keyboardOperability.score, weight: 0.25 },
-        { score: skipMechanisms.score, weight: 0.15 },
-        { score: linkButtonClarity.score, weight: 0.15 },
-        { score: formAccessibility.score, weight: 0.20 },
+        { score: semanticStructure.score, weight: P.wSemantic },
+        { score: keyboardOperability.score, weight: P.wKeyboard },
+        { score: skipMechanisms.score, weight: P.wSkip },
+        { score: linkButtonClarity.score, weight: P.wLinkButton },
+        { score: formAccessibility.score, weight: P.wForm },
     ])));
     return { score, components };
 }
 // ============================================================================
 // Grading & Certification
 // ============================================================================
-function computeGrade(composite) {
-    if (composite >= 95)
+const GRADE_IDS = {
+    aPlus: "cif.grade.aPlus",
+    a: "cif.grade.a",
+    b: "cif.grade.b",
+    c: "cif.grade.c",
+    d: "cif.grade.d",
+};
+/**
+ * The grade for a composite, from the registered cif.grade.* bands. Exported so
+ * a caller that grades an average of composites (the dashboard) uses these bands
+ * rather than a copy of their numbers.
+ */
+export function computeGrade(composite) {
+    const G = readParams(GRADE_IDS);
+    if (composite >= G.aPlus)
         return "A+";
-    if (composite >= 85)
+    if (composite >= G.a)
         return "A";
-    if (composite >= 70)
+    if (composite >= G.b)
         return "B";
-    if (composite >= 50)
+    if (composite >= G.c)
         return "C";
-    if (composite >= 30)
+    if (composite >= G.d)
         return "D";
     return "F";
 }
+const CERTIFICATION_IDS = {
+    platinum: "cif.certification.platinum",
+    gold: "cif.certification.gold",
+    silver: "cif.certification.silver",
+    bronze: "cif.certification.bronze",
+};
 function computeCertification(motor, visual, cognitive, sensory, navigation) {
+    const C = readParams(CERTIFICATION_IDS);
     const all = [motor, visual, cognitive, sensory, navigation];
     const minScore = Math.min(...all);
-    if (minScore >= 95)
+    if (minScore >= C.platinum)
         return "platinum";
-    if (minScore >= 85)
+    if (minScore >= C.gold)
         return "gold";
-    if (minScore >= 70)
+    if (minScore >= C.silver)
         return "silver";
-    if (minScore >= 50)
+    if (minScore >= C.bronze)
         return "bronze";
     return "none";
 }
 // ============================================================================
 // Fix Recommendations
 // ============================================================================
-function generateFixRecommendation(category, component, score, data) {
+// Every number a fix quotes is one of these, so the advice cannot drift from
+// the scorer (tests/cif-fix-text.test.ts parses this file to hold it there).
+const FIX_IDS = {
+    scale: "cif.scale.max",
+    targetPx: "cif.wcag.targetSizeEnhancedPx",
+    normalText: "cif.wcag.contrastNormalText",
+    largeText: "cif.wcag.contrastLargeText",
+    nonTextContrast: "cif.wcag.nonTextContrast",
+    resizePct: "cif.wcag.resizeTextPercent",
+    interactiveFree: "cif.motor.interactive.freeCount",
+    spacingGapPx: "cif.motor.spacing.minGapPx",
+    densityKnee: "cif.visual.textScalability.densityKnee",
+    choiceThreshold: "cif.fix.decision.choiceThreshold",
+    fleschGain: "cif.cognitive.readability.fleschGain",
+    elementsFree: "cif.cognitive.density.freeCount",
+    navFree: "cif.cognitive.predictability.freeCount",
+};
+/** Fix text for a measured component. Exported for tests; topIssues is the only caller. */
+export function generateFixRecommendation(category, component, score, data) {
+    const F = readParams(FIX_IDS);
     const key = `${category}.${component}`;
     switch (key) {
         case "motor.touchTargetCompliance": {
             const count = data.touchTargets
-                ? data.touchTargets.filter((t) => !t.exempt && Math.min(t.width, t.height) < 44).length
+                ? data.touchTargets.filter((t) => !t.exempt && Math.min(t.width, t.height) < F.targetPx).length
                 : countBarriersByType(data.barriers, "touch_target");
-            return `Increase ${count || "undersized"} interactive element sizes to at least 44x44px (WCAG 2.5.5 AAA)`;
+            return `Increase ${count || "undersized"} interactive element sizes to at least ${F.targetPx}x${F.targetPx}px (WCAG 2.5.5 AAA)`;
+        }
+        case "motor.hitProbability": {
+            const sizes = (data.touchTargets ?? []).filter((t) => !t.exempt).map((t) => Math.min(t.width, t.height));
+            const avg = sizes.length > 0 ? Math.round(sizes.reduce((a, b) => a + b, 0) / sizes.length) : null;
+            return `Increase interactive element sizes${avg !== null ? ` (smaller side ${avg}px on average)` : ""} toward ${F.targetPx}x${F.targetPx}px (WCAG 2.5.5 AAA) for reliable motor access`;
         }
-        case "motor.hitProbability":
-            return "Increase average interactive element dimensions -- target 48px minimum for reliable motor access";
         case "motor.interactionCount":
-            return `Reduce interactive elements from ${safe(data.interactiveCount, 0)} to under 30 on a single view`;
+            return `Reduce interactive elements on a single view from ${data.interactiveCount} to ${F.interactiveFree} or fewer`;
         case "motor.spacingAdequacy":
-            return "Add at least 8px spacing between adjacent interactive elements to prevent mis-taps";
+            return `Space adjacent interactive elements at least ${F.spacingGapPx}px apart (the gap below which the close-spacing barrier is reported) to prevent mis-taps`;
         case "motor.dragFreeAlternatives":
             return "Provide keyboard/click alternatives for all drag-and-drop interactions";
         case "visual.contrastCompliance": {
             const count = data.contrastIssues?.length || countBarriersByType(data.barriers, "contrast");
-            return `Fix ${count} elements with contrast ratios below 4.5:1 for normal text or 3:1 for large text`;
+            return `Fix ${count} elements with contrast ratios below ${F.normalText}:1 for normal text or ${F.largeText}:1 for large text`;
         }
         case "visual.textScalability":
-            return "Ensure text scales to 200% without loss of content or functionality (WCAG 1.4.4)";
+            return `Ensure text resizes to ${F.resizePct}% without loss of content or functionality (WCAG 1.4.4); this score is estimated from information density and the page was not zoomed`;
         case "visual.colorIndependence":
             return "Add non-color indicators (icons, patterns, text labels) wherever color conveys meaning";
         case "visual.focusVisibility":
-            return "Ensure all interactive elements have visible focus indicators with at least 3:1 contrast";
+            return `Ensure every interactive element has a visible focus indicator (WCAG 2.4.7) with at least ${F.nonTextContrast}:1 contrast against adjacent colors (WCAG 1.4.11)`;
         case "visual.spacingDensity":
-            return "Increase whitespace between content blocks -- reduce information density below 60%";
+            return `Increase whitespace between content blocks to lower information density${supplied(data.informationDensity) ? ` (now ${(data.informationDensity * F.scale).toFixed(0)}%)` : ""}; above ${(F.densityKnee * F.scale).toFixed(0)}% textScalability is penalised too`;
         case "cognitive.decisionComplexity": {
-            const choices = safe(data.interactiveCount, 0);
-            if (choices > 10) {
-                return `Reduce choices from ${choices} to 5-7 options per decision point (Hick's Law)`;
+            const choices = data.interactiveCount;
+            if (supplied(choices) && choices > F.choiceThreshold) {
+                return `Reduce choices from ${choices} to ${F.choiceThreshold} or fewer per decision point (decision time grows with the number of options: Hick-Hyman law)`;
             }
             return "Simplify decision points -- group related options, provide defaults, reduce choices per step";
         }
         case "cognitive.readability":
-            return `Simplify text to 8th-grade reading level (current Flesch: ${Math.round(safe(data.fleschScore, 0))})`;
+            return `Simplify text to raise Flesch reading ease from ${Math.round(data.fleschScore)} to ${Math.ceil(F.scale / F.fleschGain)} or more, where readability scores full marks`;
         case "cognitive.informationDensity":
-            return `Reduce visible elements from ${safe(data.elementCount, 0)} -- use progressive disclosure to reveal content incrementally`;
+            return `Reduce visible elements from ${data.elementCount} toward ${F.elementsFree} -- use progressive disclosure to reveal content incrementally`;
         case "cognitive.attentionClarity":
             return "Make primary CTA visually dominant -- increase size, contrast, and whitespace around conversion elements";
         case "cognitive.predictability":
-            return `Reduce navigation items from ${safe(data.navItemCount, 0)} to 7 or fewer -- group secondary items in submenus`;
+            return `Reduce navigation items from ${data.navItemCount} to ${F.navFree} or fewer -- group secondary items in submenus`;
         case "sensory.animationControl":
-            return `Add prefers-reduced-motion support for ${safe(data.animationCount, 0)} animations and provide pause controls`;
+            return `Add prefers-reduced-motion support for ${data.animationCount} animations and provide pause controls`;
         case "sensory.sensoryIndependence":
             return "Add captions/transcripts for all audio and video content";
         case "sensory.visualCalm":
@@ -560,33 +790,27 @@ function generateFixRecommendation(category, component, score, data) {
         case "navigation.formAccessibility":
             return "Associate every form field with a visible label using <label for> or aria-labelledby";
         default:
-            return `Improve ${component} in ${category} category (current score: ${score}/100)`;
+            return `Improve ${component} in ${category} category (current score: ${score}/${F.scale})`;
     }
 }
 // ============================================================================
 // Top Issues
 // ============================================================================
+/** Every component of the five categories, in category order. */
+function everyComponent(...categories) {
+    const names = ["motor", "visual", "cognitive", "sensory", "navigation"];
+    return categories.flatMap((cat, i) => Object.entries(cat.components).map(([component, val]) => ({
+        category: names[i], component, score: val.score, measured: val.measured,
+    })));
+}
 function buildTopIssues(motor, visual, cognitive, sensory, navigation, data) {
-    const allComponents = [];
-    for (const [name, val] of Object.entries(motor.components)) {
-        allComponents.push({ category: "motor", component: name, score: val.score });
-    }
-    for (const [name, val] of Object.entries(visual.components)) {
-        allComponents.push({ category: "visual", component: name, score: val.score });
-    }
-    for (const [name, val] of Object.entries(cognitive.components)) {
-        allComponents.push({ category: "cognitive", component: name, score: val.score });
-    }
-    for (const [name, val] of Object.entries(sensory.components)) {
-        allComponents.push({ category: "sensory", component: name, score: val.score });
-    }
-    for (const [name, val] of Object.entries(navigation.components)) {
-        allComponents.push({ category: "navigation", component: name, score: val.score });
-    }
+    // A component that was not measured is not an issue found, so it is never listed
+    const allComponents = everyComponent(motor, visual, cognitive, sensory, navigation)
+        .filter((c) => c.measured);
     // Sort by score ascending (worst first)
     allComponents.sort((a, b) => a.score - b.score);
-    // Return top 5
-    return allComponents.slice(0, 5).map((c) => ({
+    // Return the top few
+    return allComponents.slice(0, param("cif.topIssues.count")).map((c) => ({
         category: c.category,
         component: c.component,
         score: c.score,
@@ -600,33 +824,58 @@ function buildTopIssues(motor, visual, cognitive, sensory, navigation, data) {
  * Compute the CIF (Cognitive Interface Fitness) score from raw tool data.
  *
  * Accepts data from empathy_audit, agent_ready_audit, cognitive_effort CTC,
- * page_understand, and attention_analysis. All fields are optional --
- * missing data produces conservative estimates with lower confidence.
+ * page_understand, and attention_analysis. All fields are optional; a
+ * component whose inputs are all missing is reported as not measured (see
+ * MISSING INPUTS at the top of this file), never estimated.
  */
+const COMPOSITE_IDS = {
+    motor: "cif.weight.motor",
+    visual: "cif.weight.visual",
+    cognitive: "cif.weight.cognitive",
+    sensory: "cif.weight.sensory",
+    navigation: "cif.weight.navigation",
+};
 export function computeCIFScore(data) {
+    const W = readParams(COMPOSITE_IDS);
     const motor = computeMotorFitness(data);
     const visual = computeVisualFitness(data);
     const cognitive = computeCognitiveFitness(data);
     const sensory = computeSensoryFitness(data);
     const navigation = computeNavigationFitness(data);
-    const composite = clamp(Math.round(0.20 * motor.score +
-        0.20 * visual.score +
-        0.25 * cognitive.score +
-        0.15 * sensory.score +
-        0.20 * navigation.score));
+    const composite = clamp(Math.round(W.motor * motor.score +
+        W.visual * visual.score +
+        W.cognitive * cognitive.score +
+        W.sensory * sensory.score +
+        W.navigation * navigation.score));
     const grade = computeGrade(composite);
-    const certification = computeCertification(motor.score, visual.score, cognitive.score, sensory.score, navigation.score);
     const topIssues = buildTopIssues(motor, visual, cognitive, sensory, navigation, data);
+    const components = everyComponent(motor, visual, cognitive, sensory, navigation);
+    const notMeasuredComponents = components
+        .filter((c) => !c.measured)
+        .map((c) => `${c.category}.${c.component}`);
+    // A certification speaks for the whole page, so it needs every component
+    // measured. The band is still computed from the category scores; it is only
+    // issued when nothing was left unmeasured.
+    const allMeasured = notMeasuredComponents.length === 0;
+    const certification = allMeasured
+        ? computeCertification(motor.score, visual.score, cognitive.score, sensory.score, navigation.score)
+        : "none";
+    const certificationNote = allMeasured
+        ? null
+        : `Not certified: ${notMeasuredComponents.length} of ${components.length} components not measured.`;
     return {
         composite,
         grade,
         certification,
+        notMeasuredCount: notMeasuredComponents.length,
+        certificationNote,
         motor,
         visual,
         cognitive,
         sensory,
         navigation,
         topIssues,
+        notMeasured: notMeasuredComponents,
         url: data.url,
         timestamp: new Date().toISOString(),
     };