@lapxo/obligations 0.4.0 → 0.4.2

package/dist/measures/coincidence.js

@@ -0,0 +1,81 @@
+import { add, sub, mul, div, pow, q, zero, one, pack, probability } from "./rational.js";
+const refuse = (cause) => { throw new Error('REFUSE·coincidence ' + cause); };
+const named = (value) => typeof value === 'string' && value.length > 0;
+export function coincidenceExcess(rows, truth, selection, reference, policy) {
+    if (!Array.isArray(rows) || !Array.isArray(truth) || !Array.isArray(selection) || !selection.length ||
+        selection.some(id => !named(id)) || new Set(selection).size !== selection.length)
+        refuse('invalid selection or rows');
+    if (!reference || reference.model !== 'independent-uniform-wrong@1' || !Array.isArray(reference.values) ||
+        reference.values.length < 2 || reference.values.some(value => !named(value)) || new Set(reference.values).size !== reference.values.length)
+        refuse('invalid declared reference');
+    if (!policy || !Number.isSafeInteger(policy.minEvents) || policy.minEvents < 1 ||
+        !Number.isSafeInteger(policy.minEventsPerTruth) || policy.minEventsPerTruth < 1 || typeof policy.budget !== 'string' || !/^\d+$/.test(policy.budget))
+        refuse('invalid observation policy');
+    const required = BigInt(rows.length) * (BigInt(selection.length) + 1n) + BigInt(truth.length) + BigInt(reference.values.length) + BigInt(selection.length);
+    const metadata = { reference, policy, selection: [...selection].sort(), order: selection.length,
+        interpretation: 'coincidence relative to the declared reference; not causal identification' };
+    if (required > BigInt(policy.budget))
+        return { ...metadata, status: 'unmeasured', cause: 'coincidence/budget', required: String(required) };
+    const selected = new Set(selection), alphabet = new Set(reference.values), truthByEvent = new Map();
+    for (const row of truth) {
+        if (!row || row.kind !== 'truth' || !named(row.event) || !alphabet.has(row.value))
+            refuse('invalid truth; probes require a separate declared contract');
+        if (truthByEvent.has(row.event) && truthByEvent.get(row.event) !== row.value)
+            refuse('conflicting truth ' + row.event);
+        truthByEvent.set(row.event, row.value);
+    }
+    const events = new Map();
+    for (const row of rows) {
+        if (!row || !named(row.event) || !named(row.origin) || !alphabet.has(row.value))
+            refuse('invalid value reading');
+        if (!selected.has(row.origin))
+            continue;
+        const values = events.get(row.event) ?? new Map();
+        if (values.has(row.origin) && values.get(row.origin) !== row.value)
+            refuse('conflicting value ' + row.event + '/' + row.origin);
+        values.set(row.origin, row.value);
+        events.set(row.event, values);
+    }
+    const ordered = [...events.keys()].sort();
+    if (ordered.length < policy.minEvents)
+        return { ...metadata, status: 'unmeasured', cause: 'insufficient observed events', events: ordered.length };
+    if (ordered.some(event => events.get(event).size !== selection.length || !truthByEvent.has(event)))
+        return { ...metadata, status: 'unmeasured', cause: 'incomplete shared events or truth', events: ordered.length };
+    const origins = [...selection].sort(), groups = new Map();
+    let falseCoincidences = 0;
+    for (const event of ordered) {
+        const t = truthByEvent.get(event), values = origins.map(id => events.get(event).get(id));
+        if (values.every(value => value === values[0]) && values[0] !== t)
+            falseCoincidences++;
+        const group = groups.get(t) ?? { events: 0, errors: origins.map(() => 0) };
+        group.events++;
+        values.forEach((value, i) => { if (value !== t)
+            group.errors[i]++; });
+        groups.set(t, group);
+    }
+    let handed = [];
+    if (reference.marginals === 'handed') {
+        if (!Array.isArray(reference.errors) || reference.errors.length !== origins.length || reference.errors.some(row => !row) ||
+            new Set(reference.errors.map(row => row.origin)).size !== origins.length ||
+            reference.errors.some(row => !row || !selected.has(row.origin)))
+            refuse('marginals must name exactly the selection');
+        handed = origins.map(id => probability(reference.errors.find(row => row.origin === id).probability));
+    }
+    else if (reference.marginals !== 'estimated-by-truth')
+        refuse('unknown marginal procedure');
+    if (reference.marginals === 'estimated-by-truth' && [...groups.values()].some(group => group.events < policy.minEventsPerTruth))
+        return { ...metadata, status: 'unmeasured', cause: 'insufficient events per observed truth', events: ordered.length };
+    let expected = zero;
+    const strata = [...groups].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([value, group]) => {
+        const errors = reference.marginals === 'handed' ? handed : group.errors.map(count => q(BigInt(count), BigInt(group.events)));
+        const baseline = div(errors.reduce(mul, one), pow(q(BigInt(reference.values.length - 1)), origins.length - 1));
+        expected = add(expected, mul(q(BigInt(group.events), BigInt(ordered.length)), baseline));
+        return { truth: value, events: group.events, marginals: origins.map((origin, i) => ({ origin, error: pack(errors[i]) })), reference: pack(baseline) };
+    });
+    const observed = q(BigInt(falseCoincidences), BigInt(ordered.length));
+    return { ...metadata, status: 'measured', events: ordered.length, falseCoincidences, observed: pack(observed),
+        expected: pack(expected), delta: pack(sub(observed, expected)),
+        ratio: expected[0] === 0n ? { status: 'unmeasured', cause: 'zero reference mass' } :
+            { status: 'measured', value: pack(div(observed, expected)) }, strata,
+        uncertainty: { status: 'unmeasured', cause: 'descriptive population only; no sampling design handed' } };
+}

package/dist/measures/confidence.d.ts

@@ -0,0 +1,73 @@
+import { type RationalInput } from './rational.ts';
+export type DeclaredFailure = Readonly<{
+    id: string;
+    p: RationalInput;
+    justification: string;
+}>;
+export declare function unionBoundConfidence(failures: readonly DeclaredFailure[]): {
+    model: "declared-failure-union-bound@1";
+    status: "conditional-bound";
+    unit: "probability";
+    conditions: readonly ["common-probability-space", "each-failure-probability-justified"];
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    failureSum: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+    meaning: "lower bound for all declared events succeeding; references are not verified";
+};
+export declare function tolerantCountConfidence(failures: readonly DeclaredFailure[], k: number): {
+    model: "declared-failure-count-bound@1";
+    allowedFailures: number;
+    totalDeclarations: number;
+    exclusionOrder: string[];
+    candidates: {
+        excludedCount: number;
+        threshold: number;
+        remainingFailureSum: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        failureUpperBound: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+    }[];
+    failureUpperBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+    meaning: "lower bound for at most k declared failures; references are not verified";
+    status: "conditional-bound";
+    unit: "probability";
+    conditions: readonly ["common-probability-space", "each-failure-probability-justified"];
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    failureSum: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+};

package/dist/measures/confidence.js

@@ -0,0 +1,52 @@
+import { add, sub, div, q, rational, zero, one, pack, probability } from "./rational.js";
+const refuse = (cause) => { throw new Error('REFUSE·confidence ' + cause); };
+export function unionBoundConfidence(failures) {
+    if (!Array.isArray(failures))
+        refuse('declared failures required');
+    let sum = zero;
+    const names = new Set();
+    const declarations = Array.from(failures, failure => {
+        if (!failure || typeof failure.id !== 'string' || failure.id.trim() === '')
+            refuse('failure identity required');
+        if (names.has(failure.id))
+            refuse('duplicate failure identity');
+        names.add(failure.id);
+        if (typeof failure.justification !== 'string' || failure.justification.trim() === '')
+            refuse('justification reference required');
+        if (failure.p === undefined || failure.p === null)
+            refuse('declared failure probability required');
+        const p = probability(failure.p);
+        sum = add(sum, p);
+        return { id: failure.id, p: pack(p), justification: failure.justification };
+    });
+    const trivial = sum[0] >= sum[1];
+    return { model: 'declared-failure-union-bound@1', status: 'conditional-bound',
+        unit: 'probability', conditions: ['common-probability-space', 'each-failure-probability-justified'],
+        declarations, failureSum: pack(sum), value: pack(trivial ? zero : sub(one, sum)), trivial,
+        meaning: 'lower bound for all declared events succeeding; references are not verified' };
+}
+export function tolerantCountConfidence(failures, k) {
+    const base = unionBoundConfidence(failures), m = base.declarations.length;
+    if (!Number.isSafeInteger(k) || k < 0 || k > m)
+        refuse('allowed failure count must be an integer in 0..m');
+    const ordered = base.declarations.map(entry => ({ entry, p: probability(entry.p) })).sort((a, b) => {
+        const difference = a.p[0] * b.p[1] - b.p[0] * a.p[1];
+        return difference > 0n ? -1 : difference < 0n ? 1 : 0;
+    });
+    let remaining = rational(base.failureSum), upper = k === m ? zero : one;
+    const candidates = [];
+    if (k < m)
+        for (let j = 0; j <= k; j++) {
+            const threshold = k + 1 - j, ratio = div(remaining, q(BigInt(threshold)));
+            const capped = ratio[0] >= ratio[1] ? one : ratio;
+            if (capped[0] * upper[1] < upper[0] * capped[1])
+                upper = capped;
+            candidates.push({ excludedCount: j, threshold, remainingFailureSum: pack(remaining), failureUpperBound: pack(capped) });
+            if (j < k)
+                remaining = sub(remaining, ordered[j].p);
+        }
+    return { ...base, model: 'declared-failure-count-bound@1', allowedFailures: k,
+        totalDeclarations: m, exclusionOrder: ordered.map(({ entry }) => entry.id), candidates,
+        failureUpperBound: pack(upper), value: pack(sub(one, upper)), trivial: upper[0] === upper[1],
+        meaning: 'lower bound for at most k declared failures; references are not verified' };
+}

package/dist/measures/error-events.js

@@ -1,9 +1,11 @@
 export function errorMatrix(rows, policy, requested) {
-    if (!Number.isSafeInteger(policy.minCells) || policy.minCells < 2)
+    if (!policy || !Number.isSafeInteger(policy.minCells) || policy.minCells < 2)
         throw new Error('REFUSE·measure invalid minimum cells');
+    if (!Array.isArray(rows) || (requested !== undefined && !Array.isArray(requested)))
+        throw new Error('REFUSE·measure invalid event population');
     const cells = new Map();
     for (const row of rows) {
-        if (!row.event || !row.origin || (row.error !== 0 && row.error !== 1))
+        if (!row || typeof row.event !== 'string' || !row.event || typeof row.origin !== 'string' || !row.origin || (row.error !== 0 && row.error !== 1))
             throw new Error('REFUSE·measure invalid error event');
         const at = cells.get(row.event) ?? new Map();
         if (at.has(row.origin) && at.get(row.origin) !== row.error)
@@ -12,7 +14,7 @@ export function errorMatrix(rows, policy, requested) {
         cells.set(row.event, at);
     }
     const origins = [...new Set(requested ?? rows.map(row => row.origin))].sort();
-    if (origins.some(origin => !origin))
+    if (origins.some(origin => typeof origin !== 'string' || !origin))
         throw new Error('REFUSE·measure invalid origin');
     const events = [...cells.keys()].filter(event => origins.some(origin => cells.get(event).has(origin))).sort();
     if (events.length < policy.minCells || !origins.length)
@@ -22,10 +24,15 @@ export function errorMatrix(rows, policy, requested) {
     return { status: 'measured', origins, events, matrix: events.map(event => origins.map(origin => cells.get(event).get(origin))) };
 }
 export function covariance(reading) {
+    if (!reading || (reading.status !== 'measured' && reading.status !== 'unmeasured'))
+        throw new Error('REFUSE·measure invalid error matrix reading');
     if (reading.status === 'unmeasured')
         return reading;
+    if (!Array.isArray(reading.events) || !Array.isArray(reading.origins) || !Array.isArray(reading.matrix))
+        throw new Error('REFUSE·measure invalid error matrix');
     const n = reading.events.length, m = reading.origins.length;
-    if (!n || !m || reading.matrix.length !== n || reading.matrix.some(row => row.length !== m || row.some(x => x !== 0 && x !== 1)) || new Set(reading.events).size !== n || new Set(reading.origins).size !== m)
+    if (!n || !m || reading.events.some(event => typeof event !== 'string' || !event) || reading.origins.some(origin => typeof origin !== 'string' || !origin) ||
+        reading.matrix.length !== n || reading.matrix.some(row => !Array.isArray(row) || row.length !== m || row.some(x => x !== 0 && x !== 1)) || new Set(reading.events).size !== n || new Set(reading.origins).size !== m)
         throw new Error('REFUSE·measure invalid error matrix');
     const mean = reading.origins.map((_, i) => reading.matrix.reduce((sum, row) => sum + row[i], 0) / n);
     const matrix = Array.from({ length: m }, (_, i) => Array.from({ length: m }, (_, j) => reading.matrix.reduce((sum, row) => sum + (row[i] - mean[i]) * (row[j] - mean[j]), 0) / n));
@@ -33,8 +40,20 @@ export function covariance(reading) {
 }
 export const errorCovariance = (rows, policy) => covariance(errorMatrix(rows, policy));
 export function participationRatio(reading) {
+    if (!reading || (reading.status !== 'measured' && reading.status !== 'unmeasured'))
+        throw new Error('REFUSE·measure invalid covariance reading');
     if (reading.status === 'unmeasured')
         return reading;
+    const n = reading.origins?.length;
+    if (!n || !Array.isArray(reading.matrix) || reading.matrix.length !== n || reading.matrix.some(row => !Array.isArray(row) || row.length !== n || row.some(value => !Number.isFinite(value))))
+        throw new Error('REFUSE·measure invalid covariance matrix');
+    for (let i = 0; i < n; i++) {
+        if (reading.matrix[i][i] < 0)
+            throw new Error('REFUSE·measure negative covariance diagonal');
+        for (let j = 0; j < n; j++)
+            if (reading.matrix[i][j] !== reading.matrix[j][i])
+                throw new Error('REFUSE·measure nonsymmetric covariance');
+    }
     const trace = reading.matrix.reduce((sum, row, i) => sum + row[i], 0);
     const square = reading.matrix.reduce((sum, row) => sum + row.reduce((n, value) => n + value * value, 0), 0);
     if (square === 0)

package/dist/measures/fitting.d.ts

@@ -165,7 +165,7 @@ export declare function fitM3(rows: readonly ErrorEvent[], structure: FitStructu
     procedure: "constrained-log-least-squares/active-set@1";
 } | {
     bootstrap: {
-        status: "unmeasured" | "measured";
+        status: "measured" | "unmeasured";
         cause: string | undefined;
         words: number;
         replicates: ({

package/dist/measures/index.d.ts

@@ -16,3 +16,11 @@ export { experimentM3 } from './m3-experiment.ts';
 export type { M3ExperimentPolicy } from './m3-experiment.ts';
 export { fitM3 } from './fitting.ts';
 export type { FitStructure, FitPolicy } from './fitting.ts';
+export { commonCauseCapacityBound, capacityBound, capacityP0, mutualInformation, unanimityNoFactor, decisionInformation } from './capacity.ts';
+export type { CapacityModel, LogarithmPolicy, CapacityPolicy, DecisionRule } from './capacity.ts';
+export { fitUnanimityModel } from './unanimity-fit.ts';
+export type { UnanimityCount, UnanimityGroup, UnanimityCurve, UnanimityFitPolicy } from './unanimity-fit.ts';
+export { coincidenceExcess } from './coincidence.ts';
+export type { ValueReading, TruthReading, CoincidenceReference, CoincidencePolicy } from './coincidence.ts';
+export { unionBoundConfidence, tolerantCountConfidence } from './confidence.ts';
+export type { DeclaredFailure } from './confidence.ts';

package/dist/measures/index.js

@@ -7,3 +7,7 @@ export { roundHalfEven } from "./rational.js";
 export { identifyM3 } from "./identification.js";
 export { experimentM3 } from "./m3-experiment.js";
 export { fitM3 } from "./fitting.js";
+export { commonCauseCapacityBound, capacityBound, capacityP0, mutualInformation, unanimityNoFactor, decisionInformation } from "./capacity.js";
+export { fitUnanimityModel } from "./unanimity-fit.js";
+export { coincidenceExcess } from "./coincidence.js";
+export { unionBoundConfidence, tolerantCountConfidence } from "./confidence.js";

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>