cbrowser 20.2.2 → 21.0.0

package/dist/visual/cognitive-transport.js

@@ -4,7 +4,7 @@
  * Treats persona cognitive profiles as probability measures in Wasserstein space.
  * Provides mathematically grounded operations:
  *
- * - Cognitive distance: W₁(personaA, personaB) — true distance between minds
+ * - Cognitive distance: generalized W₁(personaA, personaB) — trait shape AND level
  * - Barycenter: consensus cognitive profile from multiple personas
  * - Geodesic interpolation: principled persona blending preserving trait coupling
  * - Adversarial generation: worst-case persona via distributionally robust optimization
@@ -22,6 +22,9 @@
  * @since v18.27.0
  * @see https://github.com/alexandriashai/cbrowser/issues/159
  */
+import { param } from "./model-provenance.js";
+import { choosingSeconds, distanceToScreenCentre, fittsIndexOfDifficulty, klmSeconds, noviceSearchSeconds, hickHymanSeconds, labelReadingSeconds, pointingSeconds, readingSeconds, smallerOfWidth, } from "./demand-laws.js";
+import { exactW1 } from "./exact-w1.js";
 // ── The 26 Cognitive Traits ──
 //
 // These names MUST match the `CognitiveTraits` interface in ../types.ts, because
@@ -69,11 +72,17 @@ export const COGNITIVE_TRAITS = [
  * Traits in the same domain are closer. This is the critical design
  * decision — it determines what "nearby" means in cognitive space.
  *
- * Organized by domain proximity:
- * - Same subdomain (e.g. both "Core"): distance 0.2
- * - Same domain (e.g. both "Perception"): distance 0.4
- * - Related domains: distance 0.6
- * - Unrelated domains: distance 1.0
+ * Organized by domain proximity (the values are read from the provenance
+ * registry, provenance/distance.ts, where each is labelled `hypothesis`: the
+ * grouping and the three levels are hand-assigned, untested against data):
+ * - Same trait: 0
+ * - Same domain (e.g. both "core"): distance.groundSameDomain (0.2)
+ * - Related domains: distance.groundRelatedDomain (0.5)
+ * - Unrelated domains, or either trait unknown: distance.groundUnrelatedDomain /
+ *   distance.groundUnknownTrait (both 0.8)
+ *
+ * The docstring used to say 0.2 / 0.4 / 0.6 / 1.0, which the code never
+ * returned. (2026-10-21)
  */
 function traitGroundDistance(a, b) {
     if (a === b)
@@ -119,12 +128,112 @@ function traitGroundDistance(a, b) {
     // That is how the phantom vocabulary above stayed invisible for so long.
     // Treat unknown as maximally distant instead. (2026-07-28)
     if (!domainA || !domainB)
-        return 0.8;
+        return param("distance.groundUnknownTrait");
     if (domainA === domainB)
-        return 0.2; // Same subdomain
+        return param("distance.groundSameDomain");
     if (related.has(`${domainA}-${domainB}`))
-        return 0.5; // Related
-    return 0.8; // Unrelated
+        return param("distance.groundRelatedDomain");
+    return param("distance.groundUnrelatedDomain");
+}
+/**
+ * The 29 x 29 ground-cost matrix C[i][j] = traitGroundDistance(trait_i, trait_j),
+ * built once and reused by every distance call.
+ *
+ * The four registry values are still read through `param()` on every call (four
+ * lookups, negligible), so a provenance recording started at any point sees the
+ * ids the distance depends on; the matrix is rebuilt only if one of them changes.
+ */
+let groundCostCache = null;
+function groundCostMatrix() {
+    const key = [
+        param("distance.groundSameDomain"),
+        param("distance.groundRelatedDomain"),
+        param("distance.groundUnrelatedDomain"),
+        param("distance.groundUnknownTrait"),
+    ].join(",");
+    if (groundCostCache && groundCostCache.key === key)
+        return groundCostCache.matrix;
+    const d = COGNITIVE_TRAITS.length;
+    const matrix = Array.from({ length: d }, () => new Array(d).fill(0));
+    for (let i = 0; i < d; i++)
+        for (let j = i + 1; j < d; j++)
+            matrix[i][j] = matrix[j][i] = traitGroundDistance(COGNITIVE_TRAITS[i], COGNITIVE_TRAITS[j]);
+    groundCostCache = { key, matrix };
+    return matrix;
+}
+/** The 29 x 29 trait ground-cost matrix, exposed for tests (a copy). */
+export function traitGroundCostMatrix() {
+    return groundCostMatrix().map(row => row.slice());
+}
+/**
+ * Key of the slack bin's share in `CognitiveDistance.traitContributions`. Not a
+ * trait: it is the part of the distance spent creating or destroying trait mass,
+ * i.e. the difference in overall level between the two profiles.
+ */
+export const OVERALL_LEVEL_KEY = "overallLevel";
+/**
+ * The (d+1) x (d+1) cost matrix of the generalized distance: the trait ground
+ * costs, plus a slack bin (last index) at distance.slackCost from every trait
+ * and 0 from itself.
+ *
+ * Refuses to build if 2 * slackCost is below the largest ground cost. Below that
+ * the triangle inequality fails through the slack bin (trait -> slack -> trait
+ * would be cheaper than trait -> trait), the result is no longer a metric, and
+ * the slack-bin problem stops being equal to the Piccoli-Rossi distance (see
+ * cognitiveDistance). The registry values are frozen, so this can only fire on
+ * an edit to provenance/distance.ts, and that edit should fail loudly.
+ */
+let generalizedCostCache = null;
+function generalizedCostMatrix() {
+    // groundCostMatrix returns the same array until a registry value changes, so
+    // its identity plus the slack cost is a complete cache key.
+    const ground = groundCostMatrix();
+    const slack = param("distance.slackCost");
+    if (generalizedCostCache && generalizedCostCache.ground === ground && generalizedCostCache.slack === slack) {
+        return generalizedCostCache.matrix;
+    }
+    let maxGround = 0;
+    for (const row of ground)
+        for (const c of row)
+            if (c > maxGround)
+                maxGround = c;
+    if (2 * slack < maxGround) {
+        throw new Error(`distance.slackCost ${slack} is below half the largest ground cost ${maxGround}: the generalized distance would not be a metric`);
+    }
+    const d = ground.length;
+    const matrix = ground.map(row => [...row, slack]);
+    matrix.push([...new Array(d).fill(slack), 0]);
+    generalizedCostCache = { ground, slack, matrix };
+    return matrix;
+}
+/** The generalized (trait + slack bin) cost matrix, exposed for tests (a copy). */
+export function traitGeneralizedCostMatrix() {
+    return generalizedCostMatrix().map(row => row.slice());
+}
+/**
+ * A profile's trait measure for the generalized distance: d + 1 masses that sum
+ * to 1. Trait i carries t_i / d (t_i clamped to the schema range [0, 1], missing
+ * traits at distance.missingTraitDefault); the last entry is the slack bin,
+ * 1 - sum_i t_i / d, which holds the mass the traits do not.
+ *
+ * Unlike traitsToDistribution nothing is renormalised, so the absolute level
+ * survives: all traits 0.2 puts 0.2 on the traits and 0.8 in the slack bin, all
+ * traits 0.8 puts 0.8 and 0.2. No floor is applied either, because the solver
+ * accepts zero atoms (distance.simplexFloor belongs to the simplex encoding).
+ */
+export function traitsToLevelMeasure(traits) {
+    const d = COGNITIVE_TRAITS.length;
+    const missing = param("distance.missingTraitDefault");
+    const measure = new Float64Array(d + 1);
+    let traitMass = 0;
+    for (let i = 0; i < d; i++) {
+        const v = Math.min(1, Math.max(0, traits[COGNITIVE_TRAITS[i]] ?? missing));
+        measure[i] = v / d;
+        traitMass += measure[i];
+    }
+    // Max with 0: all traits at 1 can sum to 1 + 2e-16.
+    measure[d] = Math.max(0, 1 - traitMass);
+    return measure;
 }
 // ── Core: Trait Distribution Operations ──
 /**
@@ -132,13 +241,19 @@ function traitGroundDistance(a, b) {
  * This is the fundamental operation: traits → distribution.
  */
 export function traitsToDistribution(traits) {
-    // The 0.01 floor is load-bearing, not defensive: optimal transport needs a
-    // measure with no zero atoms. It is also the one place the mapping is LOSSY —
-    // a trait of exactly 0 (first-timer's siteFamiliarity is the only one across
-    // all built-in personas) round-trips back as 0.01, not 0. That bound is
-    // asserted in tests/cognitive-interpolate.test.ts rather than left for someone
-    // to rediscover as a mystery 0.01 discrepancy.
-    const values = COGNITIVE_TRAITS.map(t => Math.max(0.01, traits[t] ?? 0.5));
+    // The floor (distance.simplexFloor, 0.01) is a numerical encoding choice, not
+    // a requirement of the transport problem: the exact W1 solver handles zero
+    // atoms. It is kept because it is the one place the mapping is LOSSY and
+    // callers depend on the exact behaviour — a trait of exactly 0 (first-timer's
+    // siteFamiliarity is the only one across all built-in personas) round-trips
+    // back as 0.01, not 0. That bound is asserted in
+    // tests/cognitive-interpolate.test.ts rather than left for someone to
+    // rediscover as a mystery 0.01 discrepancy. The missing-trait default
+    // (distance.missingTraitDefault, 0.5) is a hypothesis: it claims an unmeasured
+    // trait sits at the midpoint.
+    const floor = param("distance.simplexFloor");
+    const missing = param("distance.missingTraitDefault");
+    const values = COGNITIVE_TRAITS.map(t => Math.max(floor, traits[t] ?? missing));
     const sum = values.reduce((a, b) => a + b, 0);
     return new Float64Array(values.map(v => v / sum));
 }
@@ -177,7 +292,9 @@ export function distributionToTraits(dist, traitScale) {
 export function buildOTCognitiveProfile(name, traits) {
     const distribution = traitsToDistribution(traits);
     // Same flooring traitsToDistribution applies, or the inverse would not be one.
-    const traitScale = COGNITIVE_TRAITS.reduce((sum, t) => sum + Math.max(0.01, traits[t] ?? 0.5), 0);
+    const floor = param("distance.simplexFloor");
+    const missing = param("distance.missingTraitDefault");
+    const traitScale = COGNITIVE_TRAITS.reduce((sum, t) => sum + Math.max(floor, traits[t] ?? missing), 0);
     // Build simple diagonal covariance (variance proportional to trait value uncertainty)
     const d = COGNITIVE_TRAITS.length;
     const covariance = [];
@@ -192,49 +309,158 @@ export function buildOTCognitiveProfile(name, traits) {
 }
 // ── Cognitive Distance ──
 /**
- * Compute the Wasserstein-1 distance between two cognitive profiles.
- * Uses the ground metric between traits to weight the transport.
- *
- * This is the "true cognitive distance" — how different two minds are.
+ * E|<x, theta>| / ||x|| for theta uniform on the unit sphere in `d`
+ * dimensions: Gamma(d/2) / (sqrt(pi) * Gamma((d + 1)/2)). The sliced
+ * Wasserstein-1 distance between two points is this times their Euclidean
+ * distance. Built from c_1 = 1, c_2 = 2/pi and c_(d+2) = c_d * d/(d + 1), so
+ * no gamma function is needed; for odd d it is a product of rationals.
+ * Exported for tests of the formula.
  */
+export function sphereMeanAbsProjection(d) {
+    if (!Number.isInteger(d) || d < 1)
+        throw new RangeError(`sphereMeanAbsProjection: d must be a positive integer, not ${d}`);
+    let c = d % 2 === 1 ? 1 : 2 / Math.PI;
+    for (let k = d % 2 === 1 ? 1 : 2; k < d; k += 2)
+        c *= k / (k + 1);
+    return c;
+}
 /**
- * Fixed seed for the sliced-Wasserstein projection set. Any constant works; what
- * matters is that it never changes, so the same pair of profiles always yields
- * the same sliced distance across processes and releases.
+ * Distance between two cognitive profiles.
+ *
+ * `w1` is the exact GENERALIZED Wasserstein-1 distance between the two trait
+ * vectors (Piccoli & Rossi 2014, "Generalized Wasserstein distance and its
+ * application to transport equations with source"; the unbalanced-OT form with
+ * a per-unit cost for creating or destroying mass). Each profile is the measure
+ * that puts t_i / 29 on trait i, so its total mass is its mean trait level and
+ * is NOT normalised away. The distance is the cheapest way to turn one measure
+ * into the other when moving a unit of mass from trait i to trait j costs
+ * d(trait_i, trait_j) (traitGroundDistance) and creating or destroying a unit
+ * costs c = distance.slackCost (0.4, a registered hypothesis).
+ *
+ * It is computed by the standard slack-bin reduction (traitsToLevelMeasure):
+ * each measure gets one extra bin holding 1 - its trait mass, so both sum to 1,
+ * the slack bin is at cost c from every trait and 0 from itself, and the exact
+ * balanced W1 is solved on the 30 bins by min-cost flow (successive shortest
+ * paths; see exact-w1.ts). Mass sent from a trait to the other side's slack bin
+ * is destroyed, mass sent from the slack bin to a trait is created. The
+ * reduction equals the Piccoli-Rossi distance (with a = c, b = 1) whenever
+ * 2c >= the largest ground cost (0.8): a plan that both destroys at i and
+ * creates at j can then be replaced by transporting i -> j at no greater cost,
+ * so some optimum only destroys (or only creates) |mass_A - mass_B|, which the
+ * slack bins always have room for since both trait masses are at most 1. The
+ * same condition makes the 30-bin cost a metric, so `w1` is a metric on trait
+ * vectors: 0 exactly when the 29 values agree (after the [0, 1] clamp and the
+ * missing-trait default). tests/cognitive-distance-w1.test.ts checks the
+ * reduction against the Piccoli-Rossi LP solved by an independent simplex.
+ *
+ * Bounds, with mean_i over the 29 traits:
+ *   c * |mean_i t_A,i - mean_i t_B,i|  <=  w1  <=  c * mean_i |t_A,i - t_B,i|  <=  c.
+ * The lower bound is the mass imbalance, which can only be created or
+ * destroyed; the upper bound routes every difference through the slack bin.
+ * Proportional profiles are no longer at distance 0: all traits 0.2 versus all
+ * traits 0.8 is exactly 0.6 * c = 0.24 (both bounds meet). History: until
+ * 2026-10-21 this field was a weighted L1 that was not optimal transport (see
+ * exact-w1.ts); its exact replacement, shipped the same day, normalised both
+ * profiles to the simplex, and that pair was at 0 on every metric.
+ *
+ * `w1` is also positively homogeneous in the trait difference: moving every
+ * trait of A toward B by the same fraction scales the distance by that
+ * fraction (Kantorovich-Rubinstein: W1 under a metric cost depends only on the
+ * signed difference of the measures). So pushing a persona's traits further
+ * from another's never brings it closer.
+ *
+ * `w2` and `sliced` are UNCHANGED and still computed on the simplex
+ * (traitsToDistribution), so they remain shape-only: proportional profiles are
+ * at 0 on both.
+ *
+ * `traitContributions[t]` is the cost attributed to trait t under the optimal
+ * plan: half the cost of mass shipped OUT of t plus half the cost of mass
+ * shipped INTO t, i.e. 0.5 * (sum_j P[t][j] C(t,j) + sum_i P[i][t] C(i,t)) over
+ * all 30 bins. The slack bin's share is reported under OVERALL_LEVEL_KEY: half
+ * of every creation or destruction is charged to the trait it happened at and
+ * half to the overall level. Each unit of cost is split between the two
+ * endpoints it connects, so the contributions sum to `w1` exactly and are
+ * symmetric in the two profiles (swapping A and B transposes P and leaves every
+ * contribution unchanged). Mass that stays put (P[t][t]) costs 0 and
+ * contributes nothing.
+ *
+ * The optimal plan is often not unique (ties are common under a three-level
+ * cost), and one tie matters for the attribution: destroying a unit at trait i
+ * and creating one at trait j costs 2c = 0.8, exactly what moving it i -> j
+ * costs between unrelated domains. Left to the solver, a pure shape difference
+ * can be booked as a level difference: with exactW1's earlier end-node rule
+ * (same optimal costs) 211 of the 300 roster pairs did, by up to 0.017. The
+ * current solver happens not to (0 of 300 roster pairs, 0 of 21,000 random
+ * pairs, 2026-10-21), but nothing guarantees which tied plan it returns, so
+ * the plan is UNCROSSED after solving: wherever it both destroys at i and
+ * creates at j, that mass is routed i -> j directly, which costs
+ * C(i, j) <= 2c, so the plan stays optimal. With the old end-node rule put
+ * back, uncrossing alone brings all 300 pairs back to the identity below.
+ * The uncrossed plan creates or destroys exactly |mass_A - mass_B|, which makes
+ * the attribution unique where it matters:
+ *   overallLevel = 0.5 * c * |mean_i t_A,i - mean_i t_B,i|,
+ * half of what the level difference forces (the other half is charged to the
+ * traits where the mass is created or destroyed). Remaining ties among trait
+ * pairs are settled by solving the pair in a canonical order, so the
+ * attribution is deterministic and the same for (A, B) and (B, A). `w1` itself
+ * is unique.
  */
-const SLICED_PROJECTION_SEED = 0x5f3759df;
-/** mulberry32 — small, fast, well-distributed 32-bit PRNG. */
-function seededRandom(seed) {
-    let a = seed >>> 0;
-    return () => {
-        a = (a + 0x6d2b79f5) >>> 0;
-        let t = a;
-        t = Math.imul(t ^ (t >>> 15), t | 1);
-        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    };
-}
 export function cognitiveDistance(profileA, profileB) {
     const d = COGNITIVE_TRAITS.length;
     const a = profileA.distribution;
     const b = profileB.distribution;
-    // W1 with ground metric: solve the discrete OT problem
-    // For d=25 with full ground metric, use the LP formulation
-    // Simplified: weighted L1 with ground metric as scaling
+    // Generalized W1: exact balanced W1 on the 30-bin slack measures.
+    //
+    // The pair is solved in a canonical order (lexicographically smaller
+    // measure as the source) and the plan transposed back when needed. The
+    // optimal COST is unique, but the optimal PLAN is not: with 30 bins and a
+    // three-level cost many plans tie, and the solver run on (b, a) does not in
+    // general find the transpose of its (a, b) plan. Fixing the order makes the
+    // per-trait attribution below identical for (A, B) and (B, A).
+    const ma = traitsToLevelMeasure(profileA.traits);
+    const mb = traitsToLevelMeasure(profileB.traits);
+    const cost = generalizedCostMatrix();
+    const bins = d + 1;
+    let swapped = false;
+    for (let i = 0; i < bins; i++) {
+        if (ma[i] === mb[i])
+            continue;
+        swapped = ma[i] > mb[i];
+        break;
+    }
+    const solved = swapped ? exactW1(mb, ma, cost) : exactW1(ma, mb, cost);
+    // Uncross (see the docstring): mass destroyed at i (i -> slack) and mass
+    // created at j (slack -> j) become i -> j plus slack -> slack. Row and column
+    // sums are unchanged, and the cost changes by m * (C(i, j) - 2c) <= 0, which is
+    // 0 at an optimum. Done on the canonical-order plan, before any transpose, so
+    // (A, B) and (B, A) still get the same plan.
+    const sp = solved.plan;
+    for (let i = 0; i < d; i++) {
+        for (let j = 0; j < d && sp[i][d] > 0; j++) {
+            const m = Math.min(sp[i][d], sp[d][j]);
+            if (m <= 0)
+                continue;
+            sp[i][d] -= m;
+            sp[d][j] -= m;
+            sp[i][j] += m;
+            sp[d][d] += m;
+        }
+    }
+    const plan = swapped ? sp.map((_, i) => sp.map(row => row[i])) : sp;
     let w1 = 0;
     const traitContributions = {};
-    for (let i = 0; i < d; i++) {
-        const diff = Math.abs(a[i] - b[i]);
-        // Weight by average ground distance to other traits (captures trait importance)
-        let avgDist = 0;
-        for (let j = 0; j < d; j++) {
-            if (i !== j)
-                avgDist += traitGroundDistance(COGNITIVE_TRAITS[i], COGNITIVE_TRAITS[j]);
+    for (let t = 0; t < bins; t++) {
+        let out = 0, into = 0;
+        const row = plan[t];
+        const costRow = cost[t];
+        for (let j = 0; j < bins; j++) {
+            if (row[j] > 0)
+                out += row[j] * costRow[j];
+            if (plan[j][t] > 0)
+                into += plan[j][t] * cost[j][t];
         }
-        avgDist /= (d - 1);
-        const weighted = diff * avgDist;
-        w1 += weighted;
-        traitContributions[COGNITIVE_TRAITS[i]] = weighted;
+        w1 += out;
+        traitContributions[t < d ? COGNITIVE_TRAITS[t] : OVERALL_LEVEL_KEY] = 0.5 * (out + into);
     }
     // W2: Bures-Wasserstein for Gaussians
     // BW²(N(m₁,Σ₁), N(m₂,Σ₂)) = ||m₁-m₂||² + Tr(Σ₁) + Tr(Σ₂) - 2Tr((Σ₁^½ Σ₂ Σ₁^½)^½)
@@ -247,37 +473,25 @@ export function cognitiveDistance(profileA, profileB) {
         w2sq += meanDiff * meanDiff + (sigA - sigB) * (sigA - sigB);
     }
     const w2 = Math.sqrt(Math.max(0, w2sq));
-    // Sliced Wasserstein (fast approximation for validation).
+    // Sliced Wasserstein-1 between the two profiles, as points on the simplex:
+    // the mean over directions theta, uniform on the unit sphere, of
+    // |<a - b, theta>|. For two points that mean has a closed form,
+    // sphereMeanAbsProjection(d) * ||a - b||_2, so it is computed exactly rather
+    // than estimated.
     //
-    // The projections are drawn from a SEEDED generator, not Math.random(). Two
-    // identical calls used to return different sliced values (measured: 0.031568
-    // vs 0.029943 for the same persona pair, a ~5% swing) while the MCP tool that
-    // exposes this declares idempotentHint: true. A metric a caller cannot
-    // reproduce is not a metric they can act on or diff against a baseline, so the
-    // projection set is now fixed. (2026-07-29)
-    const numProjections = 100;
-    let slicedSum = 0;
-    const rand = seededRandom(SLICED_PROJECTION_SEED);
-    for (let p = 0; p < numProjections; p++) {
-        // Deterministic pseudo-random projection
-        const dir = new Float64Array(d);
-        let norm = 0;
-        for (let i = 0; i < d; i++) {
-            dir[i] = rand() * 2 - 1;
-            norm += dir[i] * dir[i];
-        }
-        norm = Math.sqrt(norm);
-        for (let i = 0; i < d; i++)
-            dir[i] /= norm;
-        // Project and compute 1D W1
-        let projA = 0, projB = 0;
-        for (let i = 0; i < d; i++) {
-            projA += a[i] * dir[i];
-            projB += b[i] * dir[i];
-        }
-        slicedSum += Math.abs(projA - projB);
-    }
-    const sliced = slicedSum / numProjections;
+    // It was estimated from 100 directions: unseeded Math.random() until
+    // 2026-07-29 (the same pair gave 0.031568 and 0.029943), then seeded, but
+    // drawn uniform in the cube [-1, 1]^d and normalized, which is not uniform
+    // on the sphere. Against the exact value the roster's 300 pairs were off by
+    // -20% to +19% (measured 2026-10-23). Uniform directions would not have
+    // fixed that: 100 of them were off by -24% to +26%, the sampling error of
+    // the estimate, and drawing them in 29 dimensions needs Gaussian components
+    // whose Math.log and Math.cos differ in the last bits between Node and Bun.
+    // The closed form takes only arithmetic and Math.sqrt.
+    let diffSq = 0;
+    for (let i = 0; i < d; i++)
+        diffSq += (a[i] - b[i]) * (a[i] - b[i]);
+    const sliced = sphereMeanAbsProjection(d) * Math.sqrt(diffSq);
     return { w1, w2, traitContributions, sliced };
 }
 // ── Barycenter (Consensus Cognition) ──
@@ -476,7 +690,6 @@ export function generateAdversarialPersonas(knownPersonas, costFn, epsilon = 0.1
  *
  * The expectation distribution is derived from the persona's traits:
  * - High patience → expects slower information delivery (wider temporal spread)
- * - High comprehension → expects denser information
  * - attention / motor / text read the three BRIDGED capacities
  *   (sustainedAttention, motorCapacity, readingCapacity), so a caller must run
  *   bridgeCapacityTraits (visual/cognitive-models.ts) before building the
@@ -499,8 +712,11 @@ export function estimateCognitiveLoad(persona, pageMetrics) {
     // Per-dimension load: mismatch between persona capacity and page demand
     // Use power 1.5 on page metrics for sharper scaling at high demand
     const breakdown = {};
-    // Information processing load
-    breakdown.information = Math.pow(pageMetrics.informationDensity, 1.5) * (1 - p('comprehension') * 0.8);
+    // No information dimension since 21.0 (Stage C, decided 2026-10-23). It was
+    // informationDensity^1.5 x (1 - 0.8 x comprehension): text amount charged
+    // against grasp of UI conventions, which is not reading. Text is the `text`
+    // dimension below, against the bridged reading capacity. informationDensity
+    // stays in the signature as a reported page metric and is not read.
     // Visual processing load. PERSONA-INVARIANT, and reported as such.
     //
     // It read `visualProcessing`, which exists in no schema, so it was already a
@@ -536,7 +752,7 @@ export function estimateCognitiveLoad(persona, pageMetrics) {
     // Total: weighted sum (each dimension contributes)
     const total = Object.values(breakdown).reduce((a, b) => a + b, 0) / Object.keys(breakdown).length;
     // Find bottleneck
-    let maxLoad = 0, bottleneck = 'information';
+    let maxLoad = 0, bottleneck = Object.keys(breakdown)[0];
     for (const [key, val] of Object.entries(breakdown)) {
         if (val > maxLoad) {
             maxLoad = val;
@@ -556,8 +772,9 @@ export function estimateCognitiveLoad(persona, pageMetrics) {
 // ── Coverage Optimization ──
 /**
  * Given a set of personas, find the N most different ones for maximum
- * test coverage. Uses greedy farthest-point sampling in Wasserstein space,
- * seeded with the two farthest-apart profiles.
+ * test coverage. Uses greedy farthest-point sampling under the generalized W1
+ * of cognitiveDistance (so a difference in overall level counts as well as one
+ * in profile shape), seeded with the two farthest-apart profiles.
  *
  * The seed used to be `profiles[0]` — whichever persona happened to be first in
  * the caller's array. Farthest-point traversal is seed-sensitive, so the same
@@ -654,6 +871,7 @@ export async function extractPerScreenMetrics(page, maxScreens = 20, geometry) {
     // The caller's geometry when it has one, so the curve length and the caption come
     // from the SAME measurement rather than two reads of a page that can move between
     // them. Measuring here is the fallback for direct callers, not the normal path.
+    const choiceCap = param("pageMetrics.choiceCap");
     const geo = geometry ?? (await measurePageGeometry(page, maxScreens));
     const vh = geo.viewportHeight;
     const docHeight = geo.documentHeight;
@@ -699,21 +917,82 @@ export async function extractPerScreenMetrics(page, maxScreens = 20, geometry) {
             }
             return { newInteractive, newChoices };
         });
+        // The law times are re-charged for the same share: what this screen
+        // introduces, so a sticky nav or a header search box is not acquired, chosen
+        // from or filled in again on every screen (a definition; exact per-element
+        // times would need box identities across screens). Procedure takes the
+        // interactive share, not a count of new entry fields: KLM charges an entry
+        // step once per visit, so a header search box seen on every screen is one
+        // step, not one per screen. Scaling this screen's steps by the share of its
+        // controls that are new assumes a field is as likely to be new as any other
+        // control. Menu labels are read once per visit too (the first read the
+        // search law leaves out), so a screen charges its labels' first read by the
+        // share of its choices that are new, like choosing; its other prose is read
+        // per screen as before.
+        const share = (newOnes, all) => (all > 0 ? Math.min(1, newOnes / all) : 0);
+        const pointShare = share(fresh.newInteractive, metrics.interactiveElementCount);
+        const chooseShare = share(fresh.newChoices, metrics.choiceCountRaw);
         out.push({
             ...metrics,
             interactiveElementCount: fresh.newInteractive,
-            choiceCount: Math.min(fresh.newChoices, 100),
+            choiceCount: Math.min(fresh.newChoices, choiceCap),
             choiceCountRaw: fresh.newChoices,
-            choiceCountCapped: fresh.newChoices > 100,
+            choiceCountCapped: fresh.newChoices > choiceCap,
+            pointingSeconds: metrics.pointingSeconds * pointShare,
+            choosingSeconds: metrics.choosingSeconds * chooseShare,
+            choosingSecondsExpert: metrics.choosingSecondsExpert * chooseShare,
+            procedureSeconds: metrics.procedureSeconds * pointShare,
+            readingSeconds: metrics.readingSeconds - metrics.lawDiagnostics.labelSeconds * (1 - chooseShare),
+            lawDiagnostics: { ...metrics.lawDiagnostics, labelSeconds: metrics.lawDiagnostics.labelSeconds * chooseShare },
         });
     }
     await page.evaluate(() => window.scrollTo(0, 0));
     await page.waitForTimeout(200);
     return out;
 }
-export async function extractPageMetrics(page, scope = "viewport", 
+/** The layout measurePageRaw writes, and the only one the CTC reference loads. */
+export const RAW_PAGE_FORMAT = 2;
+function readMeasureParams() {
+    const P = (id) => param(`pageMetrics.${id}`);
+    return {
+        walkMaxSteps: P("walk.maxSteps"), walkSettleMs: P("walk.settleMs"),
+        colourSample: P("visual.colourSample"), proseLengthAbove: P("prose.lengthAbove"),
+        scriptMinChars: P("script.minChars"), scriptTextShare: P("script.textShare"), scriptKeyShare: P("script.keyShare"),
+        lengthBins: P("raw.lengthBins"), maxBoxes: P("raw.maxBoxes"),
+        maxTextBlocks: P("raw.maxTextBlocks"), maxChoiceGroups: P("raw.maxChoiceGroups"),
+    };
+}
+function readDeriveParams() {
+    const P = (id) => param(`pageMetrics.${id}`);
+    return {
+        textNestedShare: P("text.nestedShare"), informationMidpoint: P("informationDensity.midpoint"),
+        colourWeight: P("visual.colourWeight"), imageWeight: P("visual.imageWeight"),
+        elementWeight: P("visual.elementWeight"), visualMidpoint: P("visual.midpoint"),
+        areaUnit: P("textDensity.areaUnit"), textDensityMidpoint: P("textDensity.midpoint"),
+        carouselCount: P("animation.carouselCount"), animationSaturation: P("animation.saturation"),
+        choiceCap: P("choiceCap"),
+        abjadLengthScale: P("abjad.lengthScale"), abjadLongWordMin: P("abjad.longWordMin"),
+        abjadTechWordMin: P("abjad.techWordMin"), abjadSentenceLengthAbove: P("abjad.sentenceLengthAbove"),
+        latinLongWordMin: P("latin.longWordMin"), latinTechWordMin: P("latin.techWordMin"),
+        alphabeticSentenceLengthAbove: P("alphabetic.sentenceLengthAbove"),
+        cjkCharsPerWord: P("cjk.charsPerWord"), cjkLatinEquivalentLength: P("cjk.latinEquivalentLength"),
+        cjkLongRunMin: P("cjk.longRunMin"), cjkTechRunMin: P("cjk.techRunMin"),
+        cjkLatinTechWordMin: P("cjk.latinTechWordMin"), cjkSentenceLengthAbove: P("cjk.sentenceLengthAbove"),
+        wordLengthOffset: P("wordLength.offset"), wordLengthSpan: P("wordLength.span"),
+        sentenceSaturation: P("sentenceLength.saturation"), lexicalWindow: P("lexicalDiversity.window"),
+    };
+}
+/**
+ * Measure the page: counts and geometry, no normaliser (RawPageMeasurement).
+ * The scope decides which elements count; at full_page the page is walked
+ * first so lazy content exists to be counted.
+ */
+export async function measurePageRaw(page, scope = "viewport", 
 /** Geometry already measured by the caller, so both derivations share one read. */
 geometry) {
+    // Every constant the measurement uses, read here in Node (the page cannot call
+    // param()) and handed to the browser side with the scope and geometry.
+    const P = readMeasureParams();
     // Lazy content does not exist until it has been scrolled past, so a full-page
     // measurement that never scrolls measures a page the user would never see.
     // Same five-step walk empathy_audit does for scope:"full_page", including the
@@ -727,13 +1006,13 @@ geometry) {
             // lazy content) and it is exactly the kind that survives a fix aimed at the two
             // obvious ones.
             const walkGeo = geometry ?? (await measurePageGeometry(page));
-            const steps = Math.min(5, walkGeo.screenCount);
+            const steps = Math.min(P.walkMaxSteps, walkGeo.screenCount);
             for (let i = 1; i <= steps; i++) {
                 await page.evaluate((y) => window.scrollTo(0, y), i * walkGeo.viewportHeight);
-                await page.waitForTimeout(300);
+                await page.waitForTimeout(P.walkSettleMs);
             }
             await page.evaluate(() => window.scrollTo(0, 0));
-            await page.waitForTimeout(300);
+            await page.waitForTimeout(P.walkSettleMs);
         }
         catch { /* a page that will not scroll is still measurable */ }
     }
@@ -741,11 +1020,10 @@ geometry) {
     // the sequential path were two derivations of one quantity from two separate reads;
     // passing it in makes them one measurement rather than two that agree by luck.
     const geo = geometry ?? (await measurePageGeometry(page));
-    return page.evaluate(([measureScope, geoIn]) => {
+    return page.evaluate(([measureScope, geoIn, P]) => {
         const vw = window.innerWidth;
         const vh = geoIn.viewportHeight;
         const fullPage = measureScope === "full_page";
-        const docHeight = geoIn.documentHeight;
         // Viewport check — only count elements whose bounding box intersects the
         // viewport. At full_page scope every laid-out element counts, so the filter
         // becomes a zero-size check only.
@@ -758,6 +1036,26 @@ geometry) {
             return rect.bottom > 0 && rect.top < vh &&
                 rect.right > 0 && rect.left < vw;
         };
+        const scrollX = window.scrollX || 0;
+        const scrollY = window.scrollY || 0;
+        const kinds = [];
+        const kindIndex = new Map();
+        const kindOf = (k) => {
+            let i = kindIndex.get(k);
+            if (i === undefined) {
+                i = kinds.length;
+                kinds.push(k);
+                kindIndex.set(k, i);
+            }
+            return i;
+        };
+        const elementKind = (el) => {
+            const tag = el.tagName.toLowerCase();
+            const type = tag === 'input' ? (el.getAttribute('type') || 'text').toLowerCase() : '';
+            const role = el.getAttribute('role');
+            return `${tag}${type ? `:${type}` : ''}${role ? `[${role}]` : ''}`;
+        };
+        const half = (x) => (Number.isFinite(x) ? Math.round(x * 2) / 2 : 0);
         // Gather only viewport-visible text
         const textEls = Array.from(document.querySelectorAll('p, li, h1, h2, h3, h4, h5, h6, td, th, span, div, a, button, label'));
         let viewportTextLength = 0;
@@ -768,27 +1066,158 @@ geometry) {
                     viewportTextLength += text.length;
             }
         });
-        // Deduplicate: rough estimate — child text counted in parent. Use 40% factor.
-        const textLength = Math.round(viewportTextLength * 0.4);
-        // Area to normalise density against. Counting whole-page text and dividing
-        // by one screen would report a density the page does not have.
-        const viewportArea = vw * (fullPage ? docHeight : vh);
-        // Interactive elements — viewport only
+        // Interactive elements — viewport only, with their boxes
         const interactive = Array.from(document.querySelectorAll('a, button, input, select, textarea, [role="button"], [onclick], [tabindex]'));
         let interactiveCount = 0;
-        interactive.forEach(el => { if (inViewport(el))
-            interactiveCount++; });
+        const boxes = [];
+        interactive.forEach(el => {
+            if (!inViewport(el))
+                return;
+            if (interactiveCount < P.maxBoxes) {
+                const r = el.getBoundingClientRect();
+                boxes.push(kindOf(elementKind(el)), Math.round(r.left + scrollX), Math.round(r.top + scrollY), Math.round(r.width), Math.round(r.height));
+            }
+            interactiveCount++;
+        });
         // Links and choices — viewport only
         const links = Array.from(document.querySelectorAll('a[href]'));
         const selects = Array.from(document.querySelectorAll('select'));
-        let choiceCount = 0;
+        let linkCount = 0;
+        let optionCount = 0;
         links.forEach(el => { if (inViewport(el))
-            choiceCount++; });
+            linkCount++; });
+        selects.forEach(s => { if (inViewport(s))
+            optionCount += s.querySelectorAll('option').length; });
+        // Choice groups: what the choices are offered in.
+        const choiceGroups = [];
+        let choiceGroupCount = 0;
+        // Format 1's count, for comparison: every group, nested ones again.
+        let nestedGroups = 0, nestedItems = 0;
+        const addGroup = (kind, size, nestedSize = size) => {
+            if (nestedSize > 0) {
+                nestedGroups++;
+                nestedItems += nestedSize;
+            }
+            if (size <= 0)
+                return;
+            if (choiceGroupCount < P.maxChoiceGroups)
+                choiceGroups.push(kindOf(kind), size);
+            choiceGroupCount++;
+        };
+        // Each choice in one group only: the outermost that offers it. A nav's
+        // links are its visible a[href]; a menu, menubar, listbox, tablist or
+        // radiogroup's are its visible items, each read as the link inside it
+        // when it has one, so an item and its link are one choice. Groups are
+        // decided in document order, every ancestor before its descendants, so a
+        // menubar inside a nav (or a submenu inside the menubar, or a nav inside a
+        // navigation region) keeps only the choices no outer group took, and is
+        // no group at all when that is none.
+        const NAV = 'nav, [role="navigation"]';
+        const COMPOSITE = '[role="menu"], [role="menubar"], [role="listbox"], [role="tablist"], [role="radiogroup"]';
+        const ITEM = '[role^="menuitem"], [role="option"], [role="tab"], [role="radio"]';
+        const claimed = new Set();
+        // The groups in scope, kept for the prose pass: the prose inside them is
+        // menu labels, read as choices, and is reported apart (proseInNav).
+        const scopedGroups = new Set();
+        const navGroups = [];
+        const compositeGroups = [];
+        document.querySelectorAll(`${NAV}, ${COMPOSITE}`).forEach(g => {
+            if (!inViewport(g))
+                return;
+            scopedGroups.add(g);
+            const nav = g.matches(NAV);
+            const offered = nav
+                ? Array.from(g.querySelectorAll('a[href]')).filter(inViewport)
+                : Array.from(g.querySelectorAll(ITEM)).filter(inViewport).map(x => (x.matches('a[href]') ? x : x.querySelector('a[href]') || x));
+            let own = 0;
+            for (const c of new Set(offered)) {
+                if (claimed.has(c))
+                    continue;
+                claimed.add(c);
+                own++;
+            }
+            if (nav)
+                navGroups.push([own, offered.length]);
+            else
+                compositeGroups.push([g.getAttribute('role') || '', own, offered.length]);
+        });
+        // Uncapped, so links minus groupedLinks is the links in no group however
+        // many groups the page has (choiceGroups stores the first maxChoiceGroups).
+        const navGroupCount = navGroups.filter(([own]) => own > 0).length;
+        const navLinks = navGroups.reduce((n, [own]) => n + own, 0);
+        const groupedLinkList = Array.from(claimed).filter(c => c.matches('a[href]') && inViewport(c));
+        const groupedLinks = groupedLinkList.length;
+        // Of those, the links that show visible text: at least one letter or
+        // digit (any script, so an abjad word, a CJK character or a page number)
+        // in text that is drawn.
+        // aria-label, title and alt are attributes and never reach this; an svg
+        // <title> is not drawn, so it has no box. A link is in scope by the rule
+        // every count here uses (inViewport); its text must also be visible
+        // inside it: hidden, transparent or sub-pixel text does not count, nor
+        // text clipped away by a box inside the link (the visually-hidden
+        // pattern, a 1px clipped span, and the off-screen text indent), however
+        // innerText would report it.
+        const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+        const textDrawn = (node, link) => {
+            if (!LETTER_OR_DIGIT.test(node.nodeValue || ''))
+                return false;
+            const range = document.createRange();
+            range.selectNodeContents(node);
+            const rects = Array.from(range.getClientRects()).filter(r => r.width > 0 && r.height > 0);
+            if (!rects.length)
+                return false;
+            let left = Math.min(...rects.map(r => r.left)), top = Math.min(...rects.map(r => r.top));
+            let right = Math.max(...rects.map(r => r.right)), bottom = Math.max(...rects.map(r => r.bottom));
+            for (let el = node.parentElement; el; el = el.parentElement) {
+                const cs = getComputedStyle(el);
+                if (cs.visibility !== 'visible' || parseFloat(cs.opacity) === 0 || parseFloat(cs.fontSize) < 1)
+                    return false;
+                if (/inset\(\s*50%/.test(cs.clipPath) || /^rect\(0px,? 0px,? 0px,? 0px\)$/.test(cs.clip))
+                    return false;
+                if (cs.overflowX !== 'visible' || cs.overflowY !== 'visible' || cs.clip !== 'auto' || cs.clipPath !== 'none') {
+                    const r = el.getBoundingClientRect();
+                    left = Math.max(left, r.left);
+                    top = Math.max(top, r.top);
+                    right = Math.min(right, r.right);
+                    bottom = Math.min(bottom, r.bottom);
+                    if (right - left < 2 || bottom - top < 2)
+                        return false;
+                }
+                if (el === link)
+                    break;
+            }
+            return true;
+        };
+        const readable = (link) => {
+            const walker = document.createTreeWalker(link, NodeFilter.SHOW_TEXT);
+            for (let n = walker.nextNode(); n; n = walker.nextNode())
+                if (textDrawn(n, link))
+                    return true;
+            return false;
+        };
+        const groupedLinksWithText = groupedLinkList.filter(readable).length;
+        navGroups.forEach(([own, offered]) => addGroup('nav', own, offered));
         selects.forEach(s => { if (inViewport(s))
-            choiceCount += s.querySelectorAll('option').length; });
+            addGroup('select', s.querySelectorAll('option').length); });
+        const toggles = new Map();
+        let unnamed = 0;
+        document.querySelectorAll('input[type="radio"], input[type="checkbox"]').forEach(el => {
+            if (!inViewport(el))
+                return;
+            const kind = (el.getAttribute('type') || '').toLowerCase();
+            const name = el.getAttribute('name');
+            const key = name ? `${kind}\u0000${name}` : `${kind}\u0001${unnamed++}`;
+            const g = toggles.get(key);
+            if (g)
+                g.size++;
+            else
+                toggles.set(key, { kind, size: 1 });
+        });
+        toggles.forEach(g => addGroup(g.kind, g.size));
+        compositeGroups.forEach(([kind, own, offered]) => addGroup(kind, own, offered));
         // Animations — count only ACTUAL running animations, not CSS transition utilities
         // WCAG 2.3.3 cares about content that moves/blinks automatically, not hover transitions
-        let animCount = 0;
+        let runningAnimations = 0;
         document.querySelectorAll('*').forEach(el => {
             if (!inViewport(el))
                 return;
@@ -797,18 +1226,18 @@ geometry) {
             if (style.animationName && style.animationName !== 'none' &&
                 style.animationPlayState === 'running' &&
                 style.animationDuration !== '0s' && style.animationDuration !== '0.01ms') {
-                animCount++;
+                runningAnimations++;
             }
         });
         // Also count auto-playing media
+        let autoplayElements = 0;
         document.querySelectorAll('video[autoplay], [autoplay]').forEach(el => {
             if (inViewport(el))
-                animCount++;
+                autoplayElements++;
         });
         const hasCarousel = !!document.querySelector('[class*="carousel"], [class*="slider"], [class*="swiper"]');
         // Navigation depth (breadcrumbs — these are structural, keep full-page)
         const breadcrumbs = document.querySelectorAll('[class*="breadcrumb"] a, nav[aria-label*="breadcrumb"] a');
-        const navDepth = Math.max(1, breadcrumbs.length);
         // Visual complexity — sample viewport-visible elements only
         const all = document.querySelectorAll('*');
         const uniqueColors = new Set();
@@ -821,7 +1250,7 @@ geometry) {
             if (!inViewport(all[i]))
                 continue;
             visibleCount++;
-            if (visibleCount <= 50) {
+            if (visibleCount <= P.colourSample) {
                 const cs = getComputedStyle(all[i]);
                 uniqueColors.add(cs.backgroundColor);
                 uniqueColors.add(cs.color);
@@ -830,26 +1259,81 @@ geometry) {
             if (tag === 'IMG' || tag === 'SVG' || all[i].getAttribute('role') === 'img')
                 imageCount++;
         }
-        // Normalize to 0-1 using logarithmic scaling
-        const logScale = (value, midpoint) => {
-            if (value <= 0)
-                return 0;
-            return value / (value + midpoint);
-        };
-        const informationDensity = logScale(textLength, 5000); // Viewport text: 0.5 at 5K chars
-        const visualComplexity = logScale(uniqueColors.size * 3 + imageCount * 2 + visibleCount * 0.5, 200);
-        const textDensity = logScale(textLength / Math.max(1, viewportArea * 0.001), 3);
-        const animationLevel = Math.min(1, (animCount + (hasCarousel ? 3 : 0)) / 10);
         // ── Text Readability Analysis (v18.56) ──
         // Extract actual visible text for linguistic analysis
+        const cjkRegex = /[\u3000-\u9fff\uac00-\ud7af\uff00-\uffef]/;
+        const cjkCharRegex = /[\u3000-\u9fff\uac00-\ud7af\uff00-\uffef]/g;
         const visibleTextParts = [];
+        const textBlocks = [];
         const proseSelectors = 'p, li, h1, h2, h3, h4, h5, h6, td, th, blockquote, figcaption';
+        // Each visible character once: an element counts only when no element
+        // above it already counted, so a p inside an li (or an li inside a td) is
+        // read as part of its outermost container, never again on its own.
+        // querySelectorAll is in document order, so every ancestor is decided
+        // before its descendants. An ancestor that did not count (not laid out, or
+        // too short) leaves its descendants free to.
+        const counted = new Set();
+        const insideCounted = (el) => {
+            for (let a = el.parentElement?.closest(proseSelectors); a; a = a.parentElement?.closest(proseSelectors)) {
+                if (counted.has(a))
+                    return true;
+            }
+            return false;
+        };
+        const wordsIn = (t) => t.split(/\s+/).filter(w => w.length > 0).length;
+        // The part of each counted block that sits in a nav or composite group in
+        // scope (the groups choiceGroups counts): the whole block when a group
+        // holds it (a menu's li), or the text of the outermost groups it holds (a
+        // layout td around a nav). Kept as text, so it is tokenised below as the
+        // prose is.
+        const GROUP = `${NAV}, ${COMPOSITE}`;
+        const inScopedGroup = (el) => {
+            for (let a = el.closest(GROUP); a; a = a.parentElement?.closest(GROUP)) {
+                if (scopedGroups.has(a))
+                    return true;
+            }
+            return false;
+        };
+        const navParts = [];
+        let proseChars = 0, proseWords = 0;
+        let nestedElements = 0, nestedChars = 0, nestedWords = 0;
         document.querySelectorAll(proseSelectors).forEach(el => {
-            if (inViewport(el)) {
-                const t = el.innerText?.trim();
-                if (t && t.length > 5)
-                    visibleTextParts.push(t);
+            if (!inViewport(el))
+                return;
+            const t = el.innerText?.trim();
+            if (!t || t.length <= P.proseLengthAbove)
+                return;
+            const words = wordsIn(t);
+            // Format 1's count, for comparison: every matching element.
+            nestedElements++;
+            nestedChars += t.length;
+            nestedWords += words;
+            if (insideCounted(el))
+                return;
+            counted.add(el);
+            proseChars += t.length;
+            proseWords += words;
+            if (inScopedGroup(el)) {
+                navParts.push(t);
+            }
+            else {
+                const held = [];
+                el.querySelectorAll(GROUP).forEach(g => {
+                    if (scopedGroups.has(g) && !held.some(o => o.contains(g)))
+                        held.push(g);
+                });
+                for (const g of held) {
+                    const gt = g.innerText?.trim();
+                    if (gt)
+                        navParts.push(gt);
+                }
+            }
+            if (visibleTextParts.length < P.maxTextBlocks) {
+                const cs = getComputedStyle(el);
+                const r = el.getBoundingClientRect();
+                textBlocks.push(t.length, words, (t.match(cjkCharRegex) || []).length, t.split(/[.。؟！!?؛]+|\n{2,}/).filter(s => s.trim().length > 0).length, half(parseFloat(cs.fontSize)), half(parseFloat(cs.lineHeight)), Math.round(r.width), Math.round(r.height));
             }
+            visibleTextParts.push(t);
         });
         const visibleText = visibleTextParts.join(' ');
         // ── Script detection ──
@@ -857,17 +1341,65 @@ geometry) {
         // 1. CJK logographic (Chinese, Japanese, Korean) — no word boundaries, character = morpheme
         // 2. Abjad (Arabic, Hebrew, Persian, Urdu) — short stems, root-based morphology, RTL
         // 3. Alphabetic (Latin, Cyrillic, Greek, Devanagari) — space-delimited, variable word length
-        // CJK characters
-        const cjkRegex = /[\u3000-\u9fff\uac00-\ud7af\uff00-\uffef]/;
         // Arabic/Hebrew/Persian/Urdu characters
-        const abjadRegex = /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0590-\u05FF]/;
-        const abjadCharRegex = /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0590-\u05FF]/g;
-        const cjkCharRegex = /[\u3000-\u9fff\uac00-\ud7af\uff00-\uffef]/g;
+        const abjadRegex = /[\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff\ufb50-\ufdff\ufe70-\ufeff\u0590-\u05ff]/;
+        const abjadCharRegex = /[\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff\ufb50-\ufdff\ufe70-\ufeff\u0590-\u05ff]/g;
+        // What a word keeps before its letters are counted, per script; shared by the
+        // prose and its in-group part (proseInNav) so both count letters alike.
+        const ABJAD_CLEAN = /[^\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff\ufb50-\ufdff\ufe70-\ufeff\u0590-\u05ffa-zA-Z\u00c0-\u00ff]/g;
+        const LATIN_CLEAN = /[^a-zA-ZÀ-ÿÀ-ɏḀ-ỿ]/g;
         const cjkCharCount = (visibleText.match(cjkCharRegex) || []).length;
         const totalCharCount = visibleText.replace(/\s/g, '').length;
-        // Also check key page elements independently (Tolgee translations fire faster than GT)
-        const h1Text = document.querySelector('h1')?.textContent || '';
-        const navText = document.querySelector('nav')?.textContent || '';
+        // Also check key page elements independently (Tolgee translations fire
+        // faster than GT): the first h1 and the first nav. Neither may count text
+        // the page declares to be in ANOTHER language, and a language picker is
+        // not the nav: www.w3.org's first nav lists 日本語 and 简体中文 editions,
+        // and the rule read the whole page as CJK.
+        //
+        // A text's language is the nearest lang attribute above it, or, failing
+        // that, the hreflang of a link it sits in, or the page's own (html, then
+        // body). It is another language when its primary subtag differs.
+        const primary = (tag) => (tag || '').trim().toLowerCase().split(/[-_]/)[0];
+        const pageLang = primary(document.documentElement.getAttribute('lang') || document.body?.getAttribute('lang'));
+        const otherLanguage = (el) => {
+            for (let a = el; a; a = a.parentElement) {
+                if (a.hasAttribute('lang'))
+                    return primary(a.getAttribute('lang')) !== pageLang;
+                if (a.tagName === 'A' && a.hasAttribute('hreflang'))
+                    return primary(a.getAttribute('hreflang')) !== pageLang;
+            }
+            return false;
+        };
+        // The text of an element as textContent reads it (hidden text included,
+        // as before), less scripts, styles and other-language text.
+        const keyText = (root) => {
+            if (!root)
+                return '';
+            let out = '';
+            const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+            for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+                const parent = n.parentElement;
+                if (!parent || parent.closest('script, style, noscript, template') || otherLanguage(parent))
+                    continue;
+                out += n.nodeValue || '';
+            }
+            return out;
+        };
+        // A language picker: named so (aria-label, its labelling element, id,
+        // class, title), or most of its links lead to another-language edition.
+        const PICKER_NAME = /(^|[^a-z])(lang|langs|language|languages|locale|locales|i18n)([^a-z]|$)/i;
+        const isLanguagePicker = (nav) => {
+            const labelledBy = (nav.getAttribute('aria-labelledby') || '').split(/\s+/)
+                .map(id => (id ? document.getElementById(id)?.textContent || '' : '')).join(' ');
+            const name = [nav.getAttribute('aria-label'), labelledBy, nav.id, nav.getAttribute('class'), nav.getAttribute('title')].join(' ');
+            if (PICKER_NAME.test(name))
+                return true;
+            const links = Array.from(nav.querySelectorAll('a[href]'));
+            const elsewhere = links.filter(a => otherLanguage(a) || (a.hasAttribute('hreflang') && primary(a.getAttribute('hreflang')) !== pageLang));
+            return links.length > 0 && elsewhere.length * 2 >= links.length;
+        };
+        const h1Text = keyText(document.querySelector('h1'));
+        const navText = keyText(Array.from(document.querySelectorAll('nav')).find(nav => !isLanguagePicker(nav)));
         const keyElementsCJK = (h1Text.match(cjkCharRegex) || []).length + (navText.match(cjkCharRegex) || []).length;
         const keyElementsTotal = (h1Text + navText).replace(/\s/g, '').length;
         // Abjad detection (Arabic, Hebrew, etc.)
@@ -877,21 +1409,26 @@ geometry) {
         // - >30% of visible text is CJK, OR
         // - >20% of key elements (h1 + nav) are CJK (catches partial translation)
         // - AND at least 5 CJK characters present (avoid false positives on single emoji)
-        const isCJKDominant = cjkCharCount >= 5 && ((totalCharCount > 0 && cjkCharCount / totalCharCount > 0.3) ||
-            (keyElementsTotal > 0 && keyElementsCJK / keyElementsTotal > 0.2));
+        const isCJKDominant = cjkCharCount >= P.scriptMinChars && ((totalCharCount > 0 && cjkCharCount / totalCharCount > P.scriptTextShare) ||
+            (keyElementsTotal > 0 && keyElementsCJK / keyElementsTotal > P.scriptKeyShare));
         // Consider Abjad if:
         // - >30% of visible text is abjad, OR
         // - >20% of key elements are abjad
         // - AND at least 5 abjad characters present
-        const isAbjadDominant = !isCJKDominant && abjadCharCount >= 5 && ((totalCharCount > 0 && abjadCharCount / totalCharCount > 0.3) ||
-            (keyElementsTotal > 0 && keyElementsAbjad / keyElementsTotal > 0.2));
-        let wordCount;
-        let totalWordLength;
-        let longWords;
-        let techWords;
+        const isAbjadDominant = !isCJKDominant && abjadCharCount >= P.scriptMinChars && ((totalCharCount > 0 && abjadCharCount / totalCharCount > P.scriptTextShare) ||
+            (keyElementsTotal > 0 && keyElementsAbjad / keyElementsTotal > P.scriptKeyShare));
+        // Lengths are kept as histograms so every length threshold is applied in
+        // deriveMetrics. Word lengths exactly; run and fragment lengths, which only
+        // ever meet a threshold, share one bin from lengthBins up.
+        const tally = (m, len) => m.set(len, (m.get(len) || 0) + 1);
+        const binned = (len) => Math.min(len, P.lengthBins);
+        const pairs = (m) => Array.from(m.entries()).sort((a, b) => a[0] - b[0]);
+        const wordLengths = new Map();
+        const abjadWordLengths = new Map();
+        const cjkRunLengths = new Map();
+        const fragmentLengths = new Map();
         const uniqueWords = new Set();
-        let sentenceCount;
-        let avgWordsPerSentence;
+        let sentenceSplit;
         if (isAbjadDominant) {
             // ── Abjad text analysis (Arabic, Hebrew, Persian, Urdu) ──
             // Arabic/Hebrew use spaces between words but have:
@@ -899,138 +1436,441 @@ geometry) {
             // - Root-based morphology — complex words look short
             // - Technical terms are multi-word phrases, not compound words
             // - Diacritics (tashkeel) and ligatures affect visual complexity
-            const abjadWords = visibleText.split(/\s+/).filter(w => w.length > 0);
-            wordCount = abjadWords.length;
-            totalWordLength = 0;
-            longWords = 0;
-            techWords = 0;
-            for (const word of abjadWords) {
+            for (const word of visibleText.split(/\s+/).filter(w => w.length > 0)) {
                 // Count only abjad + Latin characters (strip punctuation, numbers)
-                const clean = word.replace(/[^\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF\u0590-\u05FFa-zA-ZÀ-ÿ]/g, '');
-                const len = clean.length;
-                // Arabic stems are 3-4 chars. Normalize: Arabic 3-char word → equivalent
-                // of 5 Latin chars for readability (higher information per character than Latin)
-                const isAbjadWord = abjadRegex.test(clean);
-                const normalizedLen = isAbjadWord ? Math.round(len * 1.6) : len;
-                totalWordLength += normalizedLen;
-                // "Long" in abjad: 5+ characters (stems with prefixes/suffixes)
-                // Equivalent to 8+ Latin chars
-                if (isAbjadWord ? len >= 5 : len >= 7)
-                    longWords++;
-                // "Technical" in abjad: 6+ character words or Latin technical terms
-                // Arabic technical vocab like المعرفية (7 chars) or الشخصيات (8 chars)
-                if (isAbjadWord ? len >= 6 : len >= 10)
-                    techWords++;
+                const clean = word.replace(ABJAD_CLEAN, '');
+                // An abjad word's length is mapped to a Latin equivalent in deriveMetrics
+                // (short root-based stems carry more per character); the rest count as Latin.
+                tally(abjadRegex.test(clean) ? abjadWordLengths : wordLengths, clean.length);
                 uniqueWords.add(clean);
             }
             // Sentence analysis: Arabic uses ، (comma) and . (period) and ؟ and ؛
-            const abjadSentences = visibleText.split(/[.。؟！!?؛]+|\n{2,}/).filter(s => s.trim().length > 5);
-            sentenceCount = Math.max(1, abjadSentences.length);
-            avgWordsPerSentence = wordCount / sentenceCount;
+            sentenceSplit = /[.。؟！!?؛]+|\n{2,}/;
         }
         else if (isCJKDominant) {
             // ── CJK text analysis ──
             // CJK languages don't use spaces between words. Each character is roughly
-            // one morpheme. We estimate word boundaries using bigram/trigram heuristics.
-            // Estimate word count: CJK averages ~1.5-2 characters per "word"
-            // (Chinese ~1.5, Japanese ~2 with particles, Korean ~2 with jamo)
-            const cjkWordEstimate = Math.round(cjkCharCount / 1.8);
-            // Latin words in CJK text (English loanwords, technical terms)
-            const latinWords = visibleText.split(/\s+/).filter(w => /^[a-zA-Z]/.test(w));
-            wordCount = cjkWordEstimate + latinWords.length;
-            // Average "word" length in CJK: 1.8 chars per word normalized to same scale
-            // CJK characters carry more meaning per character than Latin.
-            // A 2-character CJK word ≈ 5-7 character English word in information density.
-            // Normalize: CJK 2-char word → equivalent of ~6 Latin chars for readability
-            totalWordLength = cjkWordEstimate * 6 + latinWords.reduce((sum, w) => sum + w.length, 0);
-            // "Long words" in CJK: compound terms are 3-4+ characters (equivalent to 7+ Latin)
-            // Extract runs of CJK characters and count those ≥ 3 characters
-            const cjkRuns = visibleText.match(/[\u3000-\u9fff\uac00-\ud7af]{3,}/g) || [];
-            longWords = cjkRuns.filter(r => r.length >= 3).length;
-            // "Technical terms" in CJK: 4+ character compounds or Latin technical terms
-            const cjkTechRuns = cjkRuns.filter(r => r.length >= 4);
-            const latinTechWords = latinWords.filter(w => w.length >= 8);
-            techWords = cjkTechRuns.length + latinTechWords.length;
+            // one morpheme; deriveMetrics estimates the word count from the character
+            // count. Latin words in CJK text (English loanwords, technical terms) are
+            // counted as written.
+            for (const w of visibleText.split(/\s+/).filter(w => /^[a-zA-Z]/.test(w))) {
+                tally(wordLengths, w.length);
+                uniqueWords.add(w.toLowerCase());
+            }
+            // "Long words" and "technical terms" in CJK are compounds: maximal runs of
+            // CJK characters, kept by length.
+            for (const run of visibleText.match(/[\u3000-\u9fff\uac00-\ud7af]+/g) || [])
+                tally(cjkRunLengths, binned(run.length));
             // Lexical diversity: use unique CJK bigrams as proxy for vocabulary
             for (let i = 0; i < visibleText.length - 1; i++) {
                 if (cjkRegex.test(visibleText[i]) && cjkRegex.test(visibleText[i + 1])) {
                     uniqueWords.add(visibleText[i] + visibleText[i + 1]);
                 }
             }
-            for (const w of latinWords)
-                uniqueWords.add(w.toLowerCase());
             // Sentence analysis: CJK uses 。！？ as sentence enders
-            const cjkSentences = visibleText.split(/[。！？.!?]+|\n{2,}/).filter(s => s.trim().length > 3);
-            sentenceCount = Math.max(1, cjkSentences.length);
-            // CJK sentences tend to be shorter in word count but longer in information density
-            avgWordsPerSentence = wordCount / sentenceCount;
+            sentenceSplit = /[。！？.!?]+|\n{2,}/;
         }
         else {
             // ── Alphabetic text analysis ──
-            const words_arr = visibleText.split(/\s+/).filter(w => w.length > 0);
-            wordCount = words_arr.length;
-            totalWordLength = 0;
-            longWords = 0;
-            techWords = 0;
-            for (const word of words_arr) {
-                const clean = word.replace(/[^a-zA-ZÀ-ÿ\u00C0-\u024F\u1E00-\u1EFF]/g, '');
-                totalWordLength += clean.length;
-                if (clean.length >= 7)
-                    longWords++;
-                if (clean.length >= 10)
-                    techWords++;
+            for (const word of visibleText.split(/\s+/).filter(w => w.length > 0)) {
+                const clean = word.replace(LATIN_CLEAN, '');
+                tally(wordLengths, clean.length);
                 uniqueWords.add(clean.toLowerCase());
             }
-            const sentences_arr = visibleText.split(/[.!?]+|\n{2,}/).filter(s => s.trim().length > 10);
-            sentenceCount = Math.max(1, sentences_arr.length);
-            avgWordsPerSentence = wordCount / sentenceCount;
+            sentenceSplit = /[.!?]+|\n{2,}/;
+        }
+        for (const s of visibleText.split(sentenceSplit))
+            tally(fragmentLengths, binned(s.trim().length));
+        // The in-group part in the reading law's units, as the branches above count
+        // the prose: letters of the words they keep as Latin, abjad words, CJK
+        // characters (CJK only when the page reads as CJK).
+        const inGroupText = navParts.join(' ');
+        let navLetters = 0, navAbjadWords = 0, navCjkChars = 0;
+        const navWordList = inGroupText.split(/\s+/).filter(w => w.length > 0);
+        if (isAbjadDominant) {
+            for (const word of navWordList) {
+                const clean = word.replace(ABJAD_CLEAN, '');
+                if (abjadRegex.test(clean))
+                    navAbjadWords++;
+                else
+                    navLetters += clean.length;
+            }
         }
-        // ── Normalize to 0-1 (script-aware) ──
-        // Average word length: Latin 4→0.2, 6→0.5, 9→0.8
-        // CJK equivalent: normalized through the 6-char equivalence above
-        const rawAvgWordLen = wordCount > 0 ? totalWordLength / wordCount : 0;
-        const avgWordLength = Math.min(1, Math.max(0, (rawAvgWordLen - 3) / 7.5));
-        // Average sentence length: 10 words → 0.3, 20 → 0.6, 35+ → 0.9
-        const avgSentenceLength = Math.min(1, avgWordsPerSentence / 40);
-        // Lexical diversity: unique items / total (capped at 100)
-        const lexicalDiversity = wordCount > 0 ? Math.min(1, uniqueWords.size / Math.min(wordCount, 100)) : 0;
-        // Long word ratio
-        const longWordRatio = wordCount > 0 ? longWords / wordCount : 0;
-        // Technical density
-        const technicalDensity = wordCount > 0 ? techWords / wordCount : 0;
+        else if (isCJKDominant) {
+            for (const w of navWordList)
+                if (/^[a-zA-Z]/.test(w))
+                    navLetters += w.length;
+            navCjkChars = (inGroupText.match(cjkCharRegex) || []).length;
+        }
+        else {
+            for (const word of navWordList)
+                navLetters += word.replace(LATIN_CLEAN, '').length;
+        }
+        const proseInNav = {
+            chars: navParts.reduce((n, part) => n + part.length, 0),
+            words: navWordList.length,
+            letters: navLetters,
+            abjadWords: navAbjadWords,
+            cjkChars: navCjkChars,
+        };
         return {
-            informationDensity,
-            visualComplexity,
-            interactiveElementCount: interactiveCount,
-            textDensity,
-            animationLevel,
-            // Capped for the demand math, which saturates well before 100 anyway
-            // (choices/(choices+10) is 0.91 at 100 and 0.96 at 235). The raw count is
-            // emitted beside it because a silently truncated number is
-            // indistinguishable from a real one -- at viewport scope the cap was
-            // unreachable, and at full_page the CU Denver homepage hits it.
-            choiceCount: Math.min(choiceCount, 100),
-            choiceCountRaw: choiceCount,
-            choiceCountCapped: choiceCount > 100,
-            navigationDepth: navDepth,
-            avgWordLength,
-            avgSentenceLength,
-            lexicalDiversity,
-            longWordRatio,
-            technicalDensity,
-            scriptFamily: isCJKDominant ? 'cjk' : isAbjadDominant ? 'abjad' : 'alphabetic',
-            // Emitted so a caller can never again be unable to tell which of these
-            // two very different measurements it is holding.
+            format: 2,
             scope: measureScope,
+            viewportWidth: vw,
+            viewportHeight: vh,
+            documentHeight: geoIn.documentHeight,
             // From the shared measurement, so it can never disagree with the screenCount
             // the sequential curve was scored over.
             pageScreens: geoIn.pageScreens,
+            scrollY,
+            textChars: viewportTextLength,
+            interactiveElements: interactiveCount,
+            links: linkCount,
+            selectOptions: optionCount,
+            runningAnimations,
+            autoplayElements,
+            carousel: hasCarousel,
+            breadcrumbLinks: breadcrumbs.length,
+            colours: uniqueColors.size,
+            visibleElements: visibleCount,
+            images: imageCount,
+            text: {
+                script: isCJKDominant ? 'cjk' : isAbjadDominant ? 'abjad' : 'alphabetic',
+                wordLengths: pairs(wordLengths),
+                abjadWordLengths: pairs(abjadWordLengths),
+                cjkChars: isCJKDominant ? cjkCharCount : 0,
+                cjkRunLengths: pairs(cjkRunLengths),
+                uniqueWords: uniqueWords.size,
+                fragmentLengths: pairs(fragmentLengths),
+                lengthBins: P.lengthBins,
+            },
+            prose: { chars: proseChars, words: proseWords },
+            proseInNav,
+            proseNested: { elements: nestedElements, chars: nestedChars, words: nestedWords },
+            kinds,
+            boxes,
+            choiceGroups,
+            choiceGroupCount,
+            navGroupCount,
+            navLinks,
+            groupedLinks,
+            groupedLinksWithText,
+            choiceNested: { groups: nestedGroups, items: nestedItems },
+            textBlocks,
+            textBlockCount: visibleTextParts.length,
         };
-    }, [scope, geo]);
+    }, [scope, geo, P]);
+}
+/**
+ * Turn a RawPageMeasurement into PageMetrics with the registered normalisers:
+ * exactly what extractPageMetrics returned when it did both in the page. Pure
+ * and synchronous, so a stored measurement can be re-derived under other
+ * constants (the CTC reference set is). A length threshold at or above the
+ * record's lengthBins cannot be re-derived from it and throws.
+ *
+ * Both layouts derive: format 2, and format 1 (RawPageMeasurementV1), whose
+ * fields this reads are the same but for groupedLinks and which derives as it
+ * did, its nested-prose counts included; its ungrouped links come from the
+ * stored nav sizes. A format-2 record without groupedLinks (measured before
+ * the nav totals) and any other format are refused rather than guessed at.
+ */
+/** Numbers per entry in RawPageMeasurement.boxes and .choiceGroups (the record's layout, not model constants). */
+const RAW_BOX_FIELDS = 5;
+const RAW_GROUP_FIELDS = 2;
+/**
+ * Input types whose field takes typed or picked entry: one KLM mental
+ * preparation each, with textarea and select (a definition; KLM places M by
+ * rules on a task method, which a page does not give).
+ */
+const ENTRY_INPUT_TYPES = new Set(["text", "email", "password", "search", "tel", "url", "number", "date", "datetime-local", "month", "week", "time", "color", "file", "range"]);
+function isEntryKind(kind) {
+    const m = /^([a-z0-9-]+)(?::([a-z0-9-]+))?/.exec(kind ?? "");
+    if (!m)
+        return false;
+    if (m[1] === "textarea" || m[1] === "select")
+        return true;
+    return m[1] === "input" && ENTRY_INPUT_TYPES.has(m[2] ?? "text");
+}
+/**
+ * Stage B's four law times for a raw page measurement, in seconds for the
+ * reference user, with what they rest on. Everything in scope, once
+ * (research/stage-b-design.md, decision 1):
+ *
+ *   pointing   every interactive box acquired once: Fitts, SMALLER-OF width,
+ *              from the centre of the screen it is seen on; the stored boxes'
+ *              sum scaled to interactiveElements when the box list is capped.
+ *   choosing   every choice group resolved once by novice linear search
+ *              (Cockburn et al. 2007); a checkbox group is one yes/no per box;
+ *              links in no group form one more set. Groups beyond the stored
+ *              ones are scaled to choiceGroupCount. choosingSecondsExpert is
+ *              the same groups by Hick-Hyman, the menu model's expert limit
+ *              (Stage C: cognitiveLoad's demand interpolates the two by the
+ *              run's siteFamiliarity, Cockburn et al.'s Eq. 4).
+ *   reading    the prose outside every group read once at Brysbaert's rate
+ *              (letters of the alphabetic words, abjad words, CJK
+ *              characters; format 2 counts each character once), plus a
+ *              first read per menu label: law.reading.labelFirstRead per
+ *              grouped link with visible text (an icon-only link has nothing
+ *              to read), which the novice search above leaves out
+ *              (Cockburn et al. fitted it without that one-off cost). Format
+ *              1 has no in-group prose, so it reads all of its prose and
+ *              charges no label.
+ *   procedure  KLM's M per entry step: an entry field (ENTRY_INPUT_TYPES,
+ *              textarea, select) or a radio or checkbox group.
+ */
+export function lawSecondsOf(raw) {
+    const view = { viewportWidth: raw.viewportWidth, viewportHeight: raw.viewportHeight, scrollY: raw.scrollY };
+    const targets = [];
+    let idSum = 0;
+    let entryBoxes = 0;
+    for (let i = 0; i + RAW_BOX_FIELDS <= raw.boxes.length; i += RAW_BOX_FIELDS) {
+        const [kind, x, y, width, height] = raw.boxes.slice(i, i + RAW_BOX_FIELDS);
+        const distance = distanceToScreenCentre({ x, y, width, height }, view, raw.scope);
+        targets.push({ distance, width, height });
+        idSum += fittsIndexOfDifficulty(distance, smallerOfWidth(width, height));
+        if (isEntryKind(raw.kinds[kind]))
+            entryBoxes++;
+    }
+    const storedTargets = targets.length;
+    const totalTargets = Math.max(raw.interactiveElements, storedTargets);
+    const groups = [];
+    let storedNavLinks = 0;
+    let toggleGroups = 0;
+    for (let i = 0; i + RAW_GROUP_FIELDS <= raw.choiceGroups.length; i += RAW_GROUP_FIELDS) {
+        const kind = raw.kinds[raw.choiceGroups[i]];
+        const size = raw.choiceGroups[i + 1];
+        groups.push({ size, each: kind === "checkbox" });
+        if (kind === "nav")
+            storedNavLinks += size;
+        if (kind === "radio" || kind === "checkbox")
+            toggleGroups++;
+    }
+    const totalGroups = Math.max(raw.choiceGroupCount, groups.length);
+    // Format 2 counts every grouped link once. Format 1 has no such count, so its
+    // grouped links are the stored nav groups' sizes. A format-2 record without
+    // the count, or without the in-group prose, predates them and is refused
+    // rather than read as format 1.
+    if (raw.format !== 1) {
+        const missing = [
+            typeof raw.groupedLinks !== "number" && "groupedLinks",
+            !raw.proseInNav && "proseInNav",
+            typeof raw.groupedLinksWithText !== "number" && "groupedLinksWithText",
+        ].filter(Boolean);
+        if (missing.length)
+            throw new Error(`lawSecondsOf: raw format 2 record without ${missing.join(", ")} (measured before the nav totals and the in-group prose existed); re-measure the page`);
+    }
+    const ungroupedLinksFrom = raw.format === 1 ? "navGroupSizes" : "groupedLinks";
+    const ungroupedLinks = Math.max(0, raw.links - (raw.format === 1 ? storedNavLinks : raw.groupedLinks));
+    const choose = (law) => choosingSeconds(groups, law, totalGroups)
+        + (law === "novice" ? noviceSearchSeconds(ungroupedLinks) : hickHymanSeconds(ungroupedLinks));
+    let letters = 0;
+    for (const [len, c] of raw.text.wordLengths)
+        letters += len * c;
+    let abjadWords = 0;
+    for (const [, c] of raw.text.abjadWordLengths)
+        abjadWords += c;
+    // Menu labels (ISC-76): the prose inside a nav or composite group is read as
+    // labels, one first read per grouped link, not at the prose rate.
+    const inGroup = raw.format === 1 ? { letters: 0, abjadWords: 0, cjkChars: 0 } : raw.proseInNav;
+    const labels = raw.format === 1 ? 0 : raw.groupedLinksWithText;
+    const labelSeconds = labelReadingSeconds(labels);
+    // Entry boxes scale with the box cap like targets; toggle groups with the group cap.
+    const entrySteps = (storedTargets > 0 ? entryBoxes * (totalTargets / storedTargets) : 0)
+        + (groups.length > 0 ? toggleGroups * (totalGroups / groups.length) : 0);
+    return {
+        pointingSeconds: pointingSeconds(targets, totalTargets),
+        choosingSeconds: choose("novice"),
+        choosingSecondsExpert: choose("expert"),
+        readingSeconds: readingSeconds({
+            letters: Math.max(0, letters - inGroup.letters),
+            abjadWords: Math.max(0, abjadWords - inGroup.abjadWords),
+            cjkChars: Math.max(0, raw.text.cjkChars - inGroup.cjkChars),
+        }) + labelSeconds,
+        procedureSeconds: klmSeconds(entrySteps),
+        lawDiagnostics: {
+            meanFittsID: storedTargets > 0 ? idSum / storedTargets : 0,
+            targets: totalTargets,
+            entrySteps,
+            choiceGroups: totalGroups + (ungroupedLinks > 0 ? 1 : 0),
+            ungroupedLinks,
+            ungroupedLinksFrom,
+            labels,
+            labelSeconds,
+        },
+    };
+}
+export function deriveMetrics(raw) {
+    if (raw.format !== RAW_PAGE_FORMAT && raw.format !== 1) {
+        throw new Error(`deriveMetrics: raw page format ${String(raw.format)} is not one this build reads (1 or ${RAW_PAGE_FORMAT})`);
+    }
+    const P = readDeriveParams();
+    const fullPage = raw.scope === "full_page";
+    const vw = raw.viewportWidth;
+    const vh = raw.viewportHeight;
+    const docHeight = raw.documentHeight;
+    // Deduplicate: rough estimate — child text counted in parent. Use 40% factor.
+    const textLength = Math.round(raw.textChars * P.textNestedShare);
+    // Area to normalise density against. Counting whole-page text and dividing
+    // by one screen would report a density the page does not have.
+    const viewportArea = vw * (fullPage ? docHeight : vh);
+    const choiceCount = raw.links + raw.selectOptions;
+    const animCount = raw.runningAnimations + raw.autoplayElements;
+    const navDepth = Math.max(1, raw.breadcrumbLinks);
+    // Normalize to 0-1 using logarithmic scaling
+    const logScale = (value, midpoint) => {
+        if (value <= 0)
+            return 0;
+        return value / (value + midpoint);
+    };
+    const informationDensity = logScale(textLength, P.informationMidpoint); // Viewport text: 0.5 at 5K chars
+    const visualComplexity = logScale(raw.colours * P.colourWeight + raw.images * P.imageWeight + raw.visibleElements * P.elementWeight, P.visualMidpoint);
+    const textDensity = logScale(textLength / Math.max(1, viewportArea * P.areaUnit), P.textDensityMidpoint);
+    const animationLevel = Math.min(1, (animCount + (raw.carousel ? P.carouselCount : 0)) / P.animationSaturation);
+    // ── Readability, from the length histograms ──
+    const t = raw.text;
+    const resolved = (threshold, id) => {
+        if (threshold >= t.lengthBins) {
+            throw new Error(`pageMetrics.${id} = ${threshold} cannot be re-derived from a measurement whose lengths share one bin from ${t.lengthBins}`);
+        }
+        return threshold;
+    };
+    const countAtLeast = (hist, min) => {
+        let n = 0;
+        for (const [len, c] of hist)
+            if (len >= min)
+                n += c;
+        return n;
+    };
+    const countAbove = (hist, above) => {
+        let n = 0;
+        for (const [len, c] of hist)
+            if (len > above)
+                n += c;
+        return n;
+    };
+    let wordCount = 0;
+    let totalWordLength = 0;
+    let longWords = 0;
+    let techWords = 0;
+    let sentenceLengthAbove;
+    if (t.script === 'abjad') {
+        // Arabic stems are 3-4 chars. Normalize: Arabic 3-char word → equivalent
+        // of 5 Latin chars for readability (higher information per character than Latin)
+        for (const [len, c] of t.abjadWordLengths) {
+            wordCount += c;
+            totalWordLength += Math.round(len * P.abjadLengthScale) * c;
+            // "Long" in abjad: 5+ characters (stems with prefixes/suffixes), read as 8+ Latin
+            if (len >= P.abjadLongWordMin)
+                longWords += c;
+            // "Technical" in abjad: 6+ character words, e.g. المعرفية (7 chars) or الشخصيات (8 chars)
+            if (len >= P.abjadTechWordMin)
+                techWords += c;
+        }
+        for (const [len, c] of t.wordLengths) {
+            wordCount += c;
+            totalWordLength += len * c;
+            if (len >= P.latinLongWordMin)
+                longWords += c;
+            if (len >= P.latinTechWordMin)
+                techWords += c;
+        }
+        sentenceLengthAbove = resolved(P.abjadSentenceLengthAbove, "abjad.sentenceLengthAbove");
+    }
+    else if (t.script === 'cjk') {
+        // Estimate word count: CJK averages ~1.5-2 characters per "word"
+        // (Chinese ~1.5, Japanese ~2 with particles, Korean ~2 with jamo)
+        const cjkWordEstimate = Math.round(t.cjkChars / P.cjkCharsPerWord);
+        let latinWords = 0;
+        let latinLength = 0;
+        for (const [len, c] of t.wordLengths) {
+            latinWords += c;
+            latinLength += len * c;
+            if (len >= P.cjkLatinTechWordMin)
+                techWords += c;
+        }
+        wordCount = cjkWordEstimate + latinWords;
+        // A 2-character CJK word ≈ 5-7 character English word in information density.
+        // Normalize: each estimated CJK word → the equivalent of ~6 Latin chars for readability
+        totalWordLength = cjkWordEstimate * P.cjkLatinEquivalentLength + latinLength;
+        // "Long words" in CJK: compound runs of 3+ characters (equivalent to 7+ Latin);
+        // "technical terms": runs of 4+, among those.
+        const longRunMin = resolved(P.cjkLongRunMin, "cjk.longRunMin");
+        longWords = countAtLeast(t.cjkRunLengths, longRunMin);
+        techWords += countAtLeast(t.cjkRunLengths, Math.max(longRunMin, resolved(P.cjkTechRunMin, "cjk.techRunMin")));
+        sentenceLengthAbove = resolved(P.cjkSentenceLengthAbove, "cjk.sentenceLengthAbove");
+    }
+    else {
+        for (const [len, c] of t.wordLengths) {
+            wordCount += c;
+            totalWordLength += len * c;
+            if (len >= P.latinLongWordMin)
+                longWords += c;
+            if (len >= P.latinTechWordMin)
+                techWords += c;
+        }
+        sentenceLengthAbove = resolved(P.alphabeticSentenceLengthAbove, "alphabetic.sentenceLengthAbove");
+    }
+    // A fragment is a sentence when its trimmed length exceeds the threshold.
+    const sentenceCount = Math.max(1, countAbove(t.fragmentLengths, sentenceLengthAbove));
+    const avgWordsPerSentence = wordCount / sentenceCount;
+    // ── Normalize to 0-1 (script-aware) ──
+    // Average word length: (length - 3) / 7.5, so Latin 4→0.13, 6→0.4, 10.5+→1.
+    // (This comment read 4→0.2, 6→0.5, 9→0.8, which the formula never produced.)
+    // CJK equivalent: normalized through the 6-char equivalence above
+    const rawAvgWordLen = wordCount > 0 ? totalWordLength / wordCount : 0;
+    const avgWordLength = Math.min(1, Math.max(0, (rawAvgWordLen - P.wordLengthOffset) / P.wordLengthSpan));
+    // Average sentence length: words / 40, so 10 words → 0.25, 20 → 0.5, 40+ → 1
+    // (it read 10 → 0.3, 20 → 0.6, 35+ → 0.9).
+    const avgSentenceLength = Math.min(1, avgWordsPerSentence / P.sentenceSaturation);
+    // Lexical diversity: unique items / total (capped at 100)
+    const lexicalDiversity = wordCount > 0 ? Math.min(1, t.uniqueWords / Math.min(wordCount, P.lexicalWindow)) : 0;
+    // Long word ratio
+    const longWordRatio = wordCount > 0 ? longWords / wordCount : 0;
+    // Technical density
+    const technicalDensity = wordCount > 0 ? techWords / wordCount : 0;
+    return {
+        informationDensity,
+        visualComplexity,
+        interactiveElementCount: raw.interactiveElements,
+        textDensity,
+        animationLevel,
+        // Capped for the demand math, which saturates well before 100 anyway
+        // (choices/(choices+10) is 0.91 at 100 and 0.96 at 235). The raw count is
+        // emitted beside it because a silently truncated number is
+        // indistinguishable from a real one -- at viewport scope the cap was
+        // unreachable, and at full_page the CU Denver homepage hits it.
+        choiceCount: Math.min(choiceCount, P.choiceCap),
+        choiceCountRaw: choiceCount,
+        choiceCountCapped: choiceCount > P.choiceCap,
+        navigationDepth: navDepth,
+        avgWordLength,
+        avgSentenceLength,
+        lexicalDiversity,
+        longWordRatio,
+        technicalDensity,
+        scriptFamily: t.script,
+        // Emitted so a caller can never again be unable to tell which of these
+        // two very different measurements it is holding.
+        scope: raw.scope,
+        // From the shared measurement, so it can never disagree with the screenCount
+        // the sequential curve was scored over.
+        pageScreens: raw.pageScreens,
+        ...lawSecondsOf(raw),
+    };
+}
+/**
+ * Page metrics of a live page: measurePageRaw, then deriveMetrics. Callers
+ * that keep the measurement (the CTC reference crawl) call the two halves.
+ */
+export async function extractPageMetrics(page, scope = "viewport", 
+/** Geometry already measured by the caller, so both derivations share one read. */
+geometry) {
+    return deriveMetrics(await measurePageRaw(page, scope, geometry));
 }
 /**
  * Compute the full pairwise distance matrix between personas.
- * Returns a symmetric matrix where entry [i][j] = W₁(persona_i, persona_j).
+ * Returns a symmetric matrix where entry [i][j] = cognitiveDistance(persona_i,
+ * persona_j).w1, the generalized W₁ (shape and level; see cognitiveDistance).
  */
 export function cognitiveDistanceMatrix(profiles) {
     const n = profiles.length;