@lapxo/obligations 0.3.5 → 0.4.1

package/dist/measures/model.js

@@ -0,0 +1,67 @@
+function valid({ c, p, n }) {
+    if (!Number.isFinite(c) || c < 0 || c > 1 || !Number.isFinite(p) || p < 0 || p > 1 || !Number.isSafeInteger(n) || n < 2)
+        throw new Error('REFUSE·measure invalid unanimity model');
+}
+function logSum(a, b) { const high = Math.max(a, b); return high === -Infinity ? high : high + Math.log(Math.exp(a - high) + Math.exp(b - high)); }
+export function unanimityFloor(model, k) {
+    valid(model);
+    if (!Number.isSafeInteger(k) || k < 1)
+        throw new Error('REFUSE·measure invalid witness count');
+    const { c, p, n } = model;
+    if (c === 1 || p === 1)
+        return { status: 'measured', value: 1 };
+    if (p === 0)
+        return { status: 'measured', value: c };
+    const logPrivate = Math.log1p(-c) + k * Math.log(p) + (1 - k) * Math.log(n - 1);
+    const logA = logSum(c === 0 ? -Infinity : Math.log(c), logPrivate), logB = Math.log1p(-c) + k * Math.log1p(-p);
+    const odds = logA - logB;
+    const value = odds >= 0 ? 1 / (1 + Math.exp(-odds)) : Math.exp(odds) / (1 + Math.exp(odds));
+    return { status: 'measured', value };
+}
+export function unanimityThreshold(model, searchLimit) {
+    valid(model);
+    if (!Number.isSafeInteger(searchLimit) || searchLimit < 1)
+        throw new Error('REFUSE·measure invalid search budget');
+    const { c, p, n } = model, q = p / (n - 1), coefficient = 1 - p - q;
+    if (c === 1 || p === 0 || p === 1 || coefficient <= 0)
+        return { status: 'measured', value: 1 };
+    if (c === 0)
+        return { status: 'unmeasured', cause: 'no finite nondecreasing threshold for this model' };
+    const right = Math.log(p) + Math.log(c), base = Math.log(coefficient) + Math.log1p(-c) + Math.log(n - 1);
+    for (let k = 1; k <= searchLimit; k++)
+        if (base + k * Math.log(q) <= right)
+            return { status: 'measured', value: k };
+    return { status: 'unmeasured', cause: 'threshold outside declared search budget' };
+}
+export function descentCount(graph, cell) {
+    const nodes = new Map();
+    for (const node of graph) {
+        if (!node.scope || nodes.has(node.scope))
+            throw new Error('REFUSE·measure duplicate or absent graph scope');
+        nodes.set(node.scope, [...new Set(node.restsOn)]);
+    }
+    if (!nodes.has(cell) || [...nodes.values()].some(parents => parents.some(parent => !nodes.has(parent))))
+        return { status: 'unmeasured', cause: 'incomplete declared descent graph' };
+    const seen = new Map(), visiting = new Set();
+    function reaches(scope) {
+        if (visiting.has(scope))
+            throw new Error('REFUSE·measure cyclic descent at ' + scope);
+        if (seen.has(scope))
+            return seen.get(scope);
+        visiting.add(scope);
+        let result = false;
+        for (const parent of nodes.get(scope)) {
+            const nested = reaches(parent);
+            result = result || parent === cell || nested;
+        }
+        visiting.delete(scope);
+        seen.set(scope, result);
+        return result;
+    }
+    let count = 0;
+    for (const scope of nodes.keys())
+        if (reaches(scope) && scope !== cell)
+            count++;
+    return { status: 'measured', value: count };
+}
+export const modelRequired = (measure) => ({ status: 'unmeasured', cause: 'declared model required for ' + measure });

package/dist/measures/rational.d.ts

@@ -0,0 +1,19 @@
+export type Rational = Readonly<{
+    numerator: string;
+    denominator: string;
+}>;
+export type RationalInput = string | Rational;
+export type Q = readonly [bigint, bigint];
+export declare const zero: Q, one: Q;
+export declare const refuse: (cause: string) => never;
+export declare function q(a: bigint, b?: bigint): Q;
+export declare function rational(input: RationalInput): Q;
+export declare const add: (a: Q, b: Q) => Q;
+export declare const sub: (a: Q, b: Q) => Q;
+export declare const mul: (a: Q, b: Q) => Q;
+export declare const div: (a: Q, b: Q) => Q;
+export declare const pow: (a: Q, n: number) => Q;
+export declare const equal: (a: Q, b: Q) => boolean;
+export declare const pack: (a: Q) => Rational;
+export declare function probability(input: RationalInput): Q;
+export declare function roundHalfEven(input: RationalInput, digits: number): string;

package/dist/measures/rational.js

@@ -0,0 +1,53 @@
+export const zero = [0n, 1n], one = [1n, 1n];
+export const refuse = (cause) => { throw new Error('REFUSE·model/M3 ' + cause); };
+const gcd = (a, b) => { a = a < 0n ? -a : a; while (b) {
+    const r = a % b;
+    a = b;
+    b = r;
+} return a; };
+export function q(a, b = 1n) {
+    if (b === 0n)
+        refuse('zero rational denominator');
+    if (b < 0n) {
+        a = -a;
+        b = -b;
+    }
+    const d = gcd(a, b);
+    return [a / d, b / d];
+}
+export function rational(input) {
+    if (typeof input === 'string') {
+        if (/^-?\d+\/\d+$/.test(input)) {
+            const [a, b] = input.split('/');
+            return q(BigInt(a), BigInt(b));
+        }
+        if (!/^-?\d+(\.\d+)?$/.test(input))
+            refuse('invalid exact probability');
+        const sign = input.startsWith('-') ? -1n : 1n, text = input.replace(/^-/, '');
+        const [whole, part = ''] = text.split('.');
+        return q(sign * BigInt(whole + part), 10n ** BigInt(part.length));
+    }
+    if (!input || typeof input.numerator !== 'string' || typeof input.denominator !== 'string' || !/^[-]?\d+$/.test(input.numerator) || !/^\d+$/.test(input.denominator))
+        refuse('invalid rational');
+    return q(BigInt(input.numerator), BigInt(input.denominator));
+}
+export const add = (a, b) => q(a[0] * b[1] + b[0] * a[1], a[1] * b[1]);
+export const sub = (a, b) => q(a[0] * b[1] - b[0] * a[1], a[1] * b[1]);
+export const mul = (a, b) => q(a[0] * b[0], a[1] * b[1]);
+export const div = (a, b) => q(a[0] * b[1], a[1] * b[0]);
+export const pow = (a, n) => q(a[0] ** BigInt(n), a[1] ** BigInt(n));
+export const equal = (a, b) => a[0] === b[0] && a[1] === b[1];
+export const pack = (a) => ({ numerator: String(a[0]), denominator: String(a[1]) });
+export function probability(input) { const a = rational(input); if (a[0] < 0n || a[0] > a[1])
+    refuse('probability outside 0..1'); return a; }
+export function roundHalfEven(input, digits) {
+    if (!Number.isSafeInteger(digits) || digits < 0)
+        refuse('invalid decimal digits');
+    const [a, b] = rational(input), scale = 10n ** BigInt(digits), absolute = a < 0n ? -a : a;
+    let integer = absolute * scale / b;
+    const remainder = absolute * scale % b;
+    if (2n * remainder > b || (2n * remainder === b && integer % 2n === 1n))
+        integer++;
+    const text = String(integer).padStart(digits + 1, '0'), prefix = a < 0n && integer !== 0n ? '-' : '';
+    return prefix + (digits ? text.slice(0, -digits) + '.' + text.slice(-digits) : text);
+}

package/dist/measures/spectrum.d.ts

@@ -0,0 +1,22 @@
+import type { Covariance, Scalar, Unmeasured } from './error-events.ts';
+export type NumericalPolicy = Readonly<{
+    absolute: number;
+    relative: number;
+    maxRotations: number;
+}>;
+export type Spectrum = Readonly<{
+    status: 'measured';
+    origins: readonly string[];
+    values: readonly number[];
+    vectors: readonly (readonly number[])[];
+    tolerance: number;
+    residual: number;
+}>;
+export declare function spectrum(reading: Covariance | Unmeasured, policy: NumericalPolicy): Spectrum | Unmeasured;
+export declare function commonMass(reading: Spectrum | Unmeasured): Scalar;
+export declare function loadings(reading: Spectrum | Unmeasured): Readonly<{
+    status: 'measured';
+    origins: readonly string[];
+    values: readonly number[];
+}> | Unmeasured;
+export declare function commonMassOf(reading: Spectrum | Unmeasured, origins: readonly string[], tau: number): Scalar;

package/dist/measures/spectrum.js

@@ -0,0 +1,84 @@
+const refuse = (cause) => { throw new Error('REFUSE·measure ' + cause); };
+export function spectrum(reading, policy) {
+    if (reading.status === 'unmeasured')
+        return reading;
+    if (!Number.isFinite(policy.absolute) || policy.absolute <= 0 || !Number.isFinite(policy.relative) || policy.relative < 0 || !Number.isSafeInteger(policy.maxRotations) || policy.maxRotations < 1)
+        refuse('invalid numerical policy');
+    const n = reading.origins.length, original = reading.matrix;
+    if (!n || original.length !== n || original.some(row => row.length !== n || row.some(x => !Number.isFinite(x))))
+        refuse('invalid covariance matrix');
+    const scale = Math.max(...original.flat().map(Math.abs)), tolerance = policy.absolute + policy.relative * scale;
+    for (let i = 0; i < n; i++)
+        for (let j = 0; j < n; j++)
+            if (original[i][j] !== original[j][i])
+                refuse('nonsymmetric covariance');
+    const a = original.map(row => [...row]), v = Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_, j) => i === j ? 1 : 0));
+    for (let step = 0; step < policy.maxRotations; step++) {
+        let p = 0, q = 0, largest = 0;
+        for (let i = 0; i < n; i++)
+            for (let j = i + 1; j < n; j++)
+                if (Math.abs(a[i][j]) > largest) {
+                    largest = Math.abs(a[i][j]);
+                    p = i;
+                    q = j;
+                }
+        if (largest <= tolerance)
+            break;
+        const theta = .5 * Math.atan2(2 * a[p][q], a[q][q] - a[p][p]), c = Math.cos(theta), s = Math.sin(theta);
+        const pp = a[p][p], qq = a[q][q], pq = a[p][q];
+        for (let k = 0; k < n; k++)
+            if (k !== p && k !== q) {
+                const x = a[k][p], y = a[k][q];
+                a[k][p] = a[p][k] = c * x - s * y;
+                a[k][q] = a[q][k] = s * x + c * y;
+            }
+        a[p][p] = c * c * pp - 2 * s * c * pq + s * s * qq;
+        a[q][q] = s * s * pp + 2 * s * c * pq + c * c * qq;
+        a[p][q] = a[q][p] = 0;
+        for (let k = 0; k < n; k++) {
+            const x = v[k][p], y = v[k][q];
+            v[k][p] = c * x - s * y;
+            v[k][q] = s * x + c * y;
+        }
+    }
+    const order = Array.from({ length: n }, (_, i) => i).sort((i, j) => a[j][j] - a[i][i] || i - j);
+    const raw = order.map(i => a[i][i]);
+    if (raw.some(x => x < -tolerance))
+        refuse('covariance is not positive semidefinite');
+    const values = raw.map(x => Math.max(0, x)), vectors = order.map(i => v.map(row => row[i]));
+    const residual = Math.max(...vectors.map((vector, i) => Math.hypot(...original.map((row, j) => row.reduce((sum, x, k) => sum + x * vector[k], 0) - values[i] * vector[j]))));
+    if (residual > n * tolerance)
+        return { status: 'unmeasured', cause: 'eigensolver did not converge within declared budget' };
+    return { status: 'measured', origins: reading.origins, values, vectors, tolerance, residual };
+}
+export function commonMass(reading) {
+    if (reading.status === 'unmeasured')
+        return reading;
+    const total = reading.values.reduce((sum, x) => sum + x, 0);
+    return total <= reading.tolerance ? { status: 'unmeasured', cause: 'no resolved variation' } : { status: 'measured', value: reading.values[0] / total };
+}
+export function loadings(reading) {
+    if (reading.status === 'unmeasured')
+        return reading;
+    if (reading.values[0] <= reading.tolerance || (reading.values.length > 1 && reading.values[0] - reading.values[1] <= 2 * reading.tolerance))
+        return { status: 'unmeasured', cause: 'top eigenspace is unresolved or repeated' };
+    return { status: 'measured', origins: reading.origins, values: reading.vectors[0].map(Math.abs) };
+}
+export function commonMassOf(reading, origins, tau) {
+    if (reading.status === 'unmeasured')
+        return reading;
+    if (!Number.isFinite(tau) || tau <= 0 || tau > 1)
+        refuse('invalid spectral threshold');
+    const selected = [...new Set(origins)].map(origin => reading.origins.indexOf(origin));
+    if (!selected.length || selected.some(i => i < 0))
+        return { status: 'unmeasured', cause: 'subset not observed' };
+    const energy = reading.values.map((value, k) => value * selected.reduce((sum, i) => sum + reading.vectors[k][i] ** 2, 0));
+    const total = energy.reduce((sum, x) => sum + x, 0);
+    if (total <= reading.tolerance)
+        return { status: 'unmeasured', cause: 'no resolved subset variation' };
+    const cutoff = tau * reading.values[0];
+    if (reading.values.some(value => Math.abs(value - cutoff) <= 2 * reading.tolerance) && tau !== 1)
+        return { status: 'unmeasured', cause: 'spectral threshold unresolved at tolerance' };
+    const common = energy.reduce((sum, x, k) => sum + (reading.values[k] >= cutoff - 2 * reading.tolerance ? x : 0), 0);
+    return { status: 'measured', value: common / total };
+}

package/dist/measures/unanimity-fit.d.ts

@@ -0,0 +1,156 @@
+import { type RationalInput } from './rational.ts';
+export type UnanimityCount = Readonly<{
+    k: number;
+    unanimous: number;
+    trials: number;
+}>;
+export type UnanimityGroup = Readonly<{
+    id: string;
+    outcomes: readonly Readonly<{
+        k: number;
+        unanimous: boolean;
+    }>[];
+}>;
+export type UnanimityCurve = Readonly<{
+    n: number;
+    lineage: string;
+    counts: readonly UnanimityCount[];
+    groups?: readonly UnanimityGroup[];
+}>;
+export type UnanimityFitPolicy = Readonly<{
+    procedure: 'exact-c-slices-on-declared-p-grid@1';
+    p: readonly RationalInput[];
+    tolerance: RationalInput;
+    budget: string;
+    bootstrap: Readonly<{
+        B: number;
+        seed: number;
+        prng: 'xorshift32';
+        randomWords: number;
+    }>;
+}>;
+export declare function fitUnanimityModel(curve: UnanimityCurve, policy: UnanimityFitPolicy): {
+    status: "unmeasured";
+    cause: string;
+    required: string;
+    model: "single-dominant-factor@1";
+    lineage: string;
+    cardinality: number;
+    policy: Readonly<{
+        procedure: "exact-c-slices-on-declared-p-grid@1";
+        p: readonly RationalInput[];
+        tolerance: RationalInput;
+        budget: string;
+        bootstrap: Readonly<{
+            B: number;
+            seed: number;
+            prng: "xorshift32";
+            randomWords: number;
+        }>;
+    }>;
+    meaning: "compatible with (c,p) under the declared model, on the declared p slices only";
+    workUnit: "rational-bit-and-group-bound";
+} | {
+    compatible: {
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        c: {
+            lo: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+            hi: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        };
+        residuals: {
+            k: number;
+            at: "slice-midpoint";
+            predicted: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+            observed: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+            residual: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+    }[];
+    identification: {
+        status: "unmeasured";
+        cause: string;
+        diagnostics: string[];
+    };
+    uncertainty: {
+        status: "unmeasured";
+        cause: string;
+        words: number;
+        procedure?: undefined;
+        replicas?: undefined;
+        interpretation?: undefined;
+    } | {
+        status: "measured";
+        procedure: "paired-group-bootstrap-regions@1";
+        replicas: {
+            p: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+            c: {
+                lo: Readonly<{
+                    numerator: string;
+                    denominator: string;
+                }>;
+                hi: Readonly<{
+                    numerator: string;
+                    denominator: string;
+                }>;
+            };
+            residuals: {
+                k: number;
+                at: "slice-midpoint";
+                predicted: Readonly<{
+                    numerator: string;
+                    denominator: string;
+                }>;
+                observed: Readonly<{
+                    numerator: string;
+                    denominator: string;
+                }>;
+                residual: Readonly<{
+                    numerator: string;
+                    denominator: string;
+                }>;
+            }[];
+        }[][];
+        words: number;
+        interpretation: "empirical replicate regions; not a guaranteed confidence set";
+        cause?: undefined;
+    };
+    cause?: string | undefined;
+    status: "measured" | "unmeasured";
+    model: "single-dominant-factor@1";
+    lineage: string;
+    cardinality: number;
+    policy: Readonly<{
+        procedure: "exact-c-slices-on-declared-p-grid@1";
+        p: readonly RationalInput[];
+        tolerance: RationalInput;
+        budget: string;
+        bootstrap: Readonly<{
+            B: number;
+            seed: number;
+            prng: "xorshift32";
+            randomWords: number;
+        }>;
+    }>;
+    meaning: "compatible with (c,p) under the declared model, on the declared p slices only";
+    workUnit: "rational-bit-and-group-bound";
+};

package/dist/measures/unanimity-fit.js

@@ -0,0 +1,133 @@
+import { add, sub, mul, div, q, pow, zero, one, pack, probability } from "./rational.js";
+const refuse = (cause) => { throw new Error('REFUSE·unanimity-fit ' + cause); };
+const compare = (a, b) => a[0] * b[1] < b[0] * a[1] ? -1 : a[0] * b[1] > b[0] * a[1] ? 1 : 0;
+function privateRate(k, n, p) {
+    return add(pow(sub(one, p), k), div(pow(p, k), pow(q(BigInt(n - 1)), k - 1)));
+}
+function slices(counts, n, grid, tolerance) {
+    return grid.flatMap(p => {
+        let lo = zero, hi = one;
+        for (const row of counts) {
+            const observed = q(BigInt(row.unanimous), BigInt(row.trials)), a = privateRate(row.k, n, p), b = sub(one, a);
+            if (b[0] === 0n) {
+                if (compare(observed, sub(one, tolerance)) < 0)
+                    return [];
+                continue;
+            }
+            const lower = div(sub(sub(observed, tolerance), a), b), upper = div(sub(add(observed, tolerance), a), b);
+            if (compare(lower, lo) > 0)
+                lo = lower;
+            if (compare(upper, hi) < 0)
+                hi = upper;
+            if (compare(lo, hi) > 0)
+                return [];
+        }
+        const midpoint = div(add(lo, hi), q(2n));
+        return [{ p: pack(p), c: { lo: pack(lo), hi: pack(hi) }, residuals: counts.map(row => {
+                    const predicted = add(midpoint, mul(sub(one, midpoint), privateRate(row.k, n, p)));
+                    return { k: row.k, at: 'slice-midpoint', predicted: pack(predicted),
+                        observed: pack(q(BigInt(row.unanimous), BigInt(row.trials))),
+                        residual: pack(sub(q(BigInt(row.unanimous), BigInt(row.trials)), predicted)) };
+                }) }];
+    });
+}
+export function fitUnanimityModel(curve, policy) {
+    if (!curve || !Number.isSafeInteger(curve.n) || curve.n < 2 || typeof curve.lineage !== 'string' || !curve.lineage ||
+        !Array.isArray(curve.counts) || !curve.counts.length)
+        refuse('one declared lineage, cardinality and counts required');
+    if (curve.counts.some(row => !row || !Number.isSafeInteger(row.k) || row.k < 1 || !Number.isSafeInteger(row.trials) || row.trials < 1 ||
+        !Number.isSafeInteger(row.unanimous) || row.unanimous < 0 || row.unanimous > row.trials))
+        refuse('invalid size counts');
+    const counts = [...curve.counts].sort((a, b) => a.k - b.k);
+    if (new Set(counts.map(row => row.k)).size !== counts.length)
+        refuse('invalid or duplicate size counts');
+    if (!policy || policy.procedure !== 'exact-c-slices-on-declared-p-grid@1' || !Array.isArray(policy.p) || !policy.p.length ||
+        typeof policy.budget !== 'string' || !/^\d+$/.test(policy.budget))
+        refuse('declared fitting procedure and budget required');
+    const grid = policy.p.map(probability).sort(compare), tolerance = probability(policy.tolerance), bootstrap = policy.bootstrap;
+    if (new Set(grid.map(p => p.join('/'))).size !== grid.length)
+        refuse('duplicate p slice');
+    if (!bootstrap || bootstrap.prng !== 'xorshift32' || !Number.isInteger(bootstrap.seed) || bootstrap.seed < 1 || bootstrap.seed > 0xffffffff ||
+        !Number.isSafeInteger(bootstrap.B) || bootstrap.B < 0 || !Number.isSafeInteger(bootstrap.randomWords) || bootstrap.randomWords < 0)
+        refuse('invalid bootstrap declaration');
+    const work = grid.reduce((sum, p) => sum + counts.reduce((total, row) => total + BigInt(row.k) *
+        (BigInt(p[1].toString(2).length) + BigInt(BigInt(curve.n - 1).toString(2).length) + 2n), 0n), 0n) * (BigInt(bootstrap.B) + 1n) +
+        BigInt(curve.groups?.length ?? 0) * (BigInt(counts.length) + 1n) * (BigInt(bootstrap.B) + 1n);
+    const metadata = { model: 'single-dominant-factor@1', lineage: curve.lineage, cardinality: curve.n, policy,
+        meaning: 'compatible with (c,p) under the declared model, on the declared p slices only',
+        workUnit: 'rational-bit-and-group-bound' };
+    if (work > BigInt(policy.budget))
+        return { ...metadata, status: 'unmeasured', cause: 'unanimity-fit/budget', required: String(work) };
+    const compatible = slices(counts, curve.n, grid, tolerance);
+    let groups;
+    if (curve.groups !== undefined) {
+        if (!Array.isArray(curve.groups) || !curve.groups.length || curve.groups.some(group => !group) || new Set(curve.groups.map(group => group.id)).size !== curve.groups.length)
+            refuse('invalid or duplicate sampling groups');
+        for (const group of curve.groups) {
+            if (!group || typeof group.id !== 'string' || !group.id || !Array.isArray(group.outcomes) || group.outcomes.length !== counts.length ||
+                group.outcomes.some((item) => !item || typeof item.unanimous !== 'boolean' || !counts.some(row => row.k === item.k)) ||
+                new Set(group.outcomes.map((item) => item.k)).size !== counts.length)
+                refuse('complete paired size outcomes required');
+        }
+        groups = [...curve.groups].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+        for (const row of counts)
+            if (row.trials !== groups.length || row.unanimous !== groups.filter(group => group.outcomes.find(item => item.k === row.k).unanimous).length)
+                refuse('group outcomes do not reproduce counts');
+    }
+    const causes = [];
+    if (counts.filter(row => row.k > 1).length < 2)
+        causes.push('too few informative sizes');
+    if (counts.every(row => row.unanimous === row.trials))
+        causes.push('perfect unanimity cannot distinguish p=0 from c=1');
+    if (curve.n === 2 && compatible.some(slice => compatible.some(other => compare(add([BigInt(slice.p.numerator), BigInt(slice.p.denominator)], [BigInt(other.p.numerator), BigInt(other.p.denominator)]), one) === 0 &&
+        slice.p.numerator + '/' + slice.p.denominator !== other.p.numerator + '/' + other.p.denominator)))
+        causes.push('binary p versus 1-p ambiguity');
+    if (!compatible.length)
+        causes.push('no compatible parameter slice under the declared tolerance');
+    const replicas = [], wordsLimit = bootstrap.randomWords;
+    let x = bootstrap.seed >>> 0, words = 0;
+    const exhausted = Symbol('unanimity-fit/random-words');
+    function index(N) {
+        const limit = Math.floor(4294967296 / N) * N;
+        for (;;) {
+            if (words >= wordsLimit)
+                throw exhausted;
+            words++;
+            x ^= x << 13;
+            x ^= x >>> 17;
+            x ^= x << 5;
+            const value = x >>> 0;
+            if (value < limit)
+                return value % N;
+        }
+    }
+    let uncertaintyCause;
+    if (!groups || bootstrap.B === 0)
+        uncertaintyCause = groups ? 'bootstrap not requested' : 'sampling groups not handed; size dependence unknown';
+    else {
+        if (groups.length > 4294967296)
+            refuse('sampling population exceeds declared PRNG index range');
+        try {
+            for (let b = 0; b < bootstrap.B; b++) {
+                const hits = counts.map(() => 0);
+                for (let i = 0; i < groups.length; i++) {
+                    const group = groups[index(groups.length)];
+                    counts.forEach((row, j) => { if (group.outcomes.find(item => item.k === row.k).unanimous)
+                        hits[j]++; });
+                }
+                replicas.push(slices(counts.map((row, i) => ({ ...row, unanimous: hits[i] })), curve.n, grid, tolerance));
+            }
+        }
+        catch (error) {
+            if (error !== exhausted)
+                throw error;
+            uncertaintyCause = 'unanimity-fit/random-words';
+        }
+    }
+    return { ...metadata, status: causes.length ? 'unmeasured' : 'measured',
+        ...(causes.length ? { cause: causes.join('; ') } : {}), compatible,
+        identification: { status: 'unmeasured', cause: 'finite slices do not certify continuous parameter identification', diagnostics: causes },
+        uncertainty: uncertaintyCause ? { status: 'unmeasured', cause: uncertaintyCause, words } :
+            { status: 'measured', procedure: 'paired-group-bootstrap-regions@1', replicas, words,
+                interpretation: 'empirical replicate regions; not a guaranteed confidence set' } };
+}

package/docs/img/cell.svg

@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 178" width="640" height="178" role="img" aria-labelledby="title desc">
+<title id="title">A cell</title>
+<desc id="desc">Two origins on one scale: a claims 2 to 9 and b claims 5 to 12; what they hold together runs from a floor of 5 to a ceiling of 9.</desc>
+<style>
+text{font:14px ui-sans-serif,-apple-system,"Segoe UI",Helvetica,Arial,sans-serif;fill:#59636e}
+.claim{fill:#8c959f}.held{fill:#2da44e}.pole{fill:#2da44e;font-weight:600}.axis,.tick{stroke:#8c959f;stroke-width:1}.touch{stroke:#2da44e;stroke-width:1;stroke-dasharray:3 3}
+@media (prefers-color-scheme:dark){text{fill:#9198a1}}
+</style>
+<line class="touch" x1="269.3" y1="12" x2="269.3" y2="126"/>
+<line class="touch" x1="442.7" y1="12" x2="442.7" y2="126"/>
+<text x="82" y="32" text-anchor="end">a</text>
+<rect class="claim" x="139.3" y="18" width="303.4" height="18" rx="4"/>
+<text x="82" y="66" text-anchor="end">b</text>
+<rect class="claim" x="269.3" y="52" width="303.4" height="18" rx="4"/>
+<text x="82" y="100" text-anchor="end">held</text>
+<rect class="held" x="269.3" y="86" width="173.4" height="18" rx="4"/>
+<line class="axis" x1="96" y1="126" x2="616" y2="126"/>
+<line class="tick" x1="139.3" y1="126" x2="139.3" y2="131"/>
+<text x="139.3" y="148" text-anchor="middle">2</text>
+<line class="tick" x1="269.3" y1="126" x2="269.3" y2="131"/>
+<text x="269.3" y="148" text-anchor="middle">5</text>
+<line class="tick" x1="442.7" y1="126" x2="442.7" y2="131"/>
+<text x="442.7" y="148" text-anchor="middle">9</text>
+<line class="tick" x1="572.7" y1="126" x2="572.7" y2="131"/>
+<text x="572.7" y="148" text-anchor="middle">12</text>
+<text class="pole" x="269.3" y="168" text-anchor="middle">floor</text>
+<text class="pole" x="442.7" y="168" text-anchor="middle">ceiling</text>
+</svg>

package/docs/img/logo-fork.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-labelledby="title">
+<title id="title">2 origins and the bond where they touch</title>
+<path d="M32 17.58 A17 17 0 0 1 32 46.42 A17 17 0 0 1 32 17.58 Z" fill="#cf222e"/>
+<path d="M32 17.58 A17 17 0 1 0 32 46.42" fill="none" stroke="#8c959f" stroke-width="4" stroke-linecap="round"/>
+<path d="M32 17.58 A17 17 0 1 1 32 46.42" fill="none" stroke="#8c959f" stroke-width="4" stroke-linecap="round"/>
+</svg>

package/docs/img/logo.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-labelledby="title">
+<title id="title">2 origins and the bond where they touch</title>
+<path d="M32 17.58 A17 17 0 0 1 32 46.42 A17 17 0 0 1 32 17.58 Z" fill="#2da44e"/>
+<path d="M32 17.58 A17 17 0 1 0 32 46.42" fill="none" stroke="#8c959f" stroke-width="4" stroke-linecap="round"/>
+<path d="M32 17.58 A17 17 0 1 1 32 46.42" fill="none" stroke="#8c959f" stroke-width="4" stroke-linecap="round"/>
+</svg>

package/docs/img/price.svg

@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 178" width="640" height="178" role="img" aria-labelledby="title desc">
+<title id="title">A cell</title>
+<desc id="desc">Two origins on one scale: seller claims 2 to 9 and buyer claims 5 to 12; what they hold together runs from a floor of 5 to a ceiling of 9.</desc>
+<style>
+text{font:14px ui-sans-serif,-apple-system,"Segoe UI",Helvetica,Arial,sans-serif;fill:#59636e}
+.claim{fill:#8c959f}.held{fill:#2da44e}.pole{fill:#2da44e;font-weight:600}.axis,.tick{stroke:#8c959f;stroke-width:1}.touch{stroke:#2da44e;stroke-width:1;stroke-dasharray:3 3}
+@media (prefers-color-scheme:dark){text{fill:#9198a1}}
+</style>
+<line class="touch" x1="269.3" y1="12" x2="269.3" y2="126"/>
+<line class="touch" x1="442.7" y1="12" x2="442.7" y2="126"/>
+<text x="82" y="32" text-anchor="end">seller</text>
+<rect class="claim" x="139.3" y="18" width="303.4" height="18" rx="4"/>
+<text x="82" y="66" text-anchor="end">buyer</text>
+<rect class="claim" x="269.3" y="52" width="303.4" height="18" rx="4"/>
+<text x="82" y="100" text-anchor="end">held</text>
+<rect class="held" x="269.3" y="86" width="173.4" height="18" rx="4"/>
+<line class="axis" x1="96" y1="126" x2="616" y2="126"/>
+<line class="tick" x1="139.3" y1="126" x2="139.3" y2="131"/>
+<text x="139.3" y="148" text-anchor="middle">2</text>
+<line class="tick" x1="269.3" y1="126" x2="269.3" y2="131"/>
+<text x="269.3" y="148" text-anchor="middle">5</text>
+<line class="tick" x1="442.7" y1="126" x2="442.7" y2="131"/>
+<text x="442.7" y="148" text-anchor="middle">9</text>
+<line class="tick" x1="572.7" y1="126" x2="572.7" y2="131"/>
+<text x="572.7" y="148" text-anchor="middle">12</text>
+<text class="pole" x="269.3" y="168" text-anchor="middle">floor</text>
+<text class="pole" x="442.7" y="168" text-anchor="middle">ceiling</text>
+</svg>

package/docs/img/thermometer.svg

@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 228" width="640" height="228" role="img" aria-labelledby="title desc">
+<title id="title">A cell</title>
+<desc id="desc">Four origins on one scale: a claims 19.8 to 20.2, b claims 19.9 to 20.3, c claims 19.7 to 20.1 and d claims 24 to 24.4; their claims do not meet.</desc>
+<style>
+text{font:14px ui-sans-serif,-apple-system,"Segoe UI",Helvetica,Arial,sans-serif;fill:#59636e}
+.claim{fill:#8c959f}.held{fill:#2da44e}.pole{fill:#2da44e;font-weight:600}.axis,.tick{stroke:#8c959f;stroke-width:1}.touch{stroke:#2da44e;stroke-width:1;stroke-dasharray:3 3}
+@media (prefers-color-scheme:dark){text{fill:#9198a1}}
+</style>
+<text x="82" y="32" text-anchor="end">a</text>
+<rect class="claim" x="181.4" y="18" width="31" height="18" rx="4"/>
+<text x="82" y="66" text-anchor="end">b</text>
+<rect class="claim" x="189.1" y="52" width="31.1" height="18" rx="4"/>
+<text x="82" y="100" text-anchor="end">c</text>
+<rect class="claim" x="173.6" y="86" width="31.1" height="18" rx="4"/>
+<text x="82" y="134" text-anchor="end">d</text>
+<rect class="claim" x="507.3" y="120" width="31.1" height="18" rx="4"/>
+<text x="82" y="168" text-anchor="end">held</text>
+<text x="96" y="168">their claims do not meet</text>
+<line class="axis" x1="96" y1="194" x2="616" y2="194"/>
+<line class="tick" x1="173.6" y1="194" x2="173.6" y2="199"/>
+<text x="173.6" y="216" text-anchor="middle">19.7</text>
+<line class="tick" x1="204.7" y1="194" x2="204.7" y2="199"/>
+<text x="204.7" y="216" text-anchor="middle">20.1</text>
+<line class="tick" x1="507.3" y1="194" x2="507.3" y2="199"/>
+<text x="507.3" y="216" text-anchor="middle">24</text>
+<line class="tick" x1="538.4" y1="194" x2="538.4" y2="199"/>
+<text x="538.4" y="216" text-anchor="middle">24.4</text>
+</svg>