@lapxo/obligations 0.3.4 → 0.4.0

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/docs/measures.md

@@ -0,0 +1,149 @@
+# Measures beside the states
+
+The pure API @lapxo/obligations/measures does not change FREE, REQUIRED, FORBIDDEN or CONFLICT. Observed association never establishes independence.
+
+## Descriptive contract
+errorMatrix takes explicit binary event/origin/error rows and minCells >= 2. Identical redelivery is idempotent; conflicting observations refuse; incomplete shared events are unmeasured. covariance is population covariance of the handed rows, divided by their event count. participationRatio describes effective rank; zero variation is unmeasured.
+
+spectrum requires absolute, relative and maxRotations. Asymmetric or materially non-PSD matrices refuse. commonMass is the largest observed variance fraction, not a probability of false agreement. loadings require an isolated top eigenvalue; repeated eigenspaces have no unique top loading. commonMassOf requires an explicit cutoff and whole eigenspaces. The unanimity no-sample prints observed commonMass >= 0.5 beside FREE, without claiming strength.
+
+descentCount counts distinct proper descendants in a declared restsOn graph. Identical edges add nothing. Missing declarations remain unmeasured; duplicate node declarations and cycles refuse. Declared descent is not observed activity or independence.
+
+## Controlled procedures
+unanimityFloor and unanimityThreshold implement the declared T1 special case. With P_k=(1-c)p^k(n-1)^(1-k), F_k=(c+P_k)/(c+P_k+(1-c)(1-p)^k). For nondegenerate parameters, F_(k+1) >= F_k iff p*c >= (1-p-p/(n-1))*P_k. The c=.01,p=.1,n=2 no-sample decreases before k=3; its threshold is 3. dissentExperiment and interestExperiment report conditional counts under explicitly handed generators: xorshift32, nonzero seed and trial count. Their denominators are events and falseEvents, and zero events are unmeasured. Interest is an explicitly handed bias toward one wrong value, not inferred from a missing observation. E3: a school answers truth with probability q, otherwise its own wrong value. These are controlled procedures, never laws or state changes.
+
+## Native publication evidence
+observations, spectrum, unanimity and descent each have yes/no cases in samples/measures/<group>.json and installed-instrument captures in vectors/measures/<group>.cli.json. M/3 has samples/measures/m3.json and vectors/measures/m3.cli.json. Each vector ran on two independent places, repeated the positive reading byte-for-byte and refused its negative by name. State-preservation tests compare all four actual algebraic states before and after measurements.
+
+## Model boundary
+M/3 below is the only reference model. The older descriptive D/commonMass and independence claims are superseded. modelRequired returns unmeasured for an absent model; no measurement silently supplies a causal model. Factor attribution, dissent and probe results are conditional on M/3's handed parameters, not empirical independence certificates.
+
+# obligations 0.4.0 — model M/3 (authoritative contract)
+
+M/3 is the reference conditional model shipped beside the descriptive measures. Every M/3
+result carries `model=M/3`, its handed parameters and its conditions. The descriptive
+measures are independent of M/3. Nothing changes a state. This document supersedes all
+earlier M/1, M/2 and amendment texts.
+
+## 1. Definition
+Witnesses W (unique identifiers); cells with truth t and integer cardinality n ≥ 2;
+factors F, each with unique identifier, sharing set a_f ⊆ W, firing probability c_f and a
+unique declared index (total order); private error probability p_w for every witness
+involved. Per cell, independently:
+1. each factor fires independently with probability c_f;
+2. a witness is governed by the fired factor containing it with the lowest index, if
+   any; otherwise its private error fires with probability p_w;
+3. labels: each fired governing factor is a factor label; each privately erring witness
+   is a private label (namespaces are distinct: a factor label and a private label can
+   never merge even with identical identifier strings); every label draws one wrong
+   value uniformly from the n−1 wrong values; draws of distinct labels are mutually
+   independent and independent of all firing and private indicators; everyone else says t.
+Singleton factors (|a_f| = 1) are retained in declared order; the generator is never
+normalized.
+
+## 2. Validation (refuse by name)
+S ⊆ W and S nonempty; every a_f ⊆ W; unique witness and factor identifiers; unique factor
+indices; c_f, p_w ∈ [0,1]; n integer ≥ 2; an explicitly handed p_w for every witness in
+S and in every sharing set touching S; a sharing set with duplicate members is refused.
+
+## 3. Exact evaluator
+Enumerate fired subsets of the factors touching S (2^|touching|) and private patterns of
+ungoverned members of S (2^|free|). In each configuration, erring witnesses are grouped by
+label; L = number of labels; weights = witnesses per label. Collisions of wrong values
+follow set partitions π of the labels with
+P(π) = (n−1)^{↓|π|} / (n−1)^L (falling factorial), and P(π) = 0 when |π| > n−1.
+Each partition yields block totals; unanimity ⇔ no correct witness and one block;
+majority = strictly more than |S|/2 witnesses on one value; ties and pluralities ≤ half
+are "no majority".
+Exactness: all c_f, p_w are handed as rationals (or decimal strings converted exactly);
+accumulation is in rational arithmetic; displayed decimals are rounded half-even to a
+declared number of digits. Budget: before any work, compute
+work = Σ_configurations Bell(L) ≤ `evaluator/budget` (declared); if exceeded, return
+`unmeasured` with cause `evaluator/budget` and no partial accumulation.
+Outputs per (S, x): P_true, P_false (false unanimity), P_fired (false unanimity with some
+touching factor fired), P_dissent = 1 − P_true − P_false (identity, asserted),
+maj_true∧dissent, maj_false∧dissent, maj_none∧dissent (exclusive, sum = P_dissent).
+Closed form admitted only for P_true = Π_{f touches S}(1−c_f) · Π_{w∈S}(1−p_w).
+
+## 4. Quantities and denominators
+```
+Φ   = P_false / (P_true + P_false)        false-unanimity share
+D   = P_fired / (P_true + P_false)        factor-attribution share
+reliability = 1 − Φ, labelled "P(correct | unanimous) under M/3 with handed parameters"
+P(false maj | dissent)            = maj_false∧dissent / P_dissent
+P(false maj | any maj ∧ dissent)  = maj_false∧dissent / (maj_true∧dissent + maj_false∧dissent)
+```
+A ratio with zero denominator is `unmeasured` with cause; a zero numerator over a positive
+denominator is a measured 0. Φ − D is private coincidence; 1 − D is never reliability.
+
+## 5. Dissent
+Theorem: if a factor covering S fires and no fired factor of lower index touches S
+partially, S is unanimous; disagreement inside S certifies this configuration did not
+occur — nothing more. False majorities under dissent remain possible through partial
+factors and are reported through the two conditionals above. T1 and T5 stay controlled
+experiments with declared PRNG, seed, trials and denominators (T5 uses the second
+conditional).
+
+## 6. Probe update
+For a witness u private-only and independent of every factor touching S (or, with its
+total marginal error probability, labelled so):
+```
+a = Φ · p_u/(n−1);  b = (1−Φ)·(1−p_u);  Φ′ = a/(a+b);  unmeasured iff a+b = 0
+```
+Strict improvement Φ′ < Φ holds for 0 < Φ < 1 iff p_u < (n−1)/n; boundary cases are
+valid (Φ=0, p_u=0.2 → 0; Φ=1, p_u=0.2 → 1; p_u=1 → 1).
+
+## 7. Identification and fitting
+Let, for each witness w,
+```
+r_w = (1−p_w) · Π_{singleton f ∋ w} (1−c_f)        unresolved singleton/private survival
+s_w = r_w · Π_{shared f ∋ w} (1−c_f)                total correctness probability
+s_uv = P(e_u = 0 ∧ e_v = 0)
+```
+Population identification (declared sharing sets, s_u > 0 for every involved witness):
+log(s_uv/(s_u·s_v)) = Σ_{shared f ∋ u,v} −log(1−c_f) is linear in −log(1−c_f); if the
+pair × shared-factor system has full column rank, every shared c_f is identified, and then
+r_w from s_w; r_w's decomposition into p_w and singleton c_f is unresolved by error data.
+Structure is never discovered by a measure. Finite-data fitting is a separate declared
+procedure: constrained least squares on the log system, declared budget, residual
+diagnostics against a declared tolerance, bootstrap uncertainty with declared B/seed/PRNG,
+pooling only under declared parameter compatibility; no pseudocounts, no clamping, no
+promotion of fitted structure; zero joint-correct counts or incompatible moments →
+`model/M misfit`, no c_f reported. Φ and D are reported only with handed parameters and
+labelled `handed`, never `fitted`.
+
+## 8. Time, stake, commonMass
+Freshness and interest enter only as hypothetical factors with declared firing
+probabilities; otherwise annotations and `unmeasured`. Descriptive commonMass is read as
+excess over 1/|S| only as deviation from the equal-variance independent reference; it
+never identifies dependence.
+
+## 9. Captured vectors (exact; rational reference; decimals rounded half-even, 8 digits)
+- two witnesses, covering c=1/20, p=1/5, n=64: P_true 0.608, P_false 0.05060317,
+  P_fired 0.05, P_dissent 0.34139683, Φ 0.07683409, D 0.07591825.
+- impossible conditioning (no factors, p_A=0, p_B=1): P_true = P_false = 0, P_dissent 1,
+  Φ, D unmeasured (cause: no unanimity mass).
+- three witnesses, covering {A,B,C} c=1/5 idx 0, partial {A,B} c=3/10 idx 1, p=0:
+  P_true 0.56, P_false 0.2, P_dissent 0.24, maj_false∧dissent 0.24, Φ = D = 0.26315789,
+  P(false maj | dissent) = 1, P(false maj | any maj ∧ dissent) = 1.
+- earlier singleton {A} c=3/10 idx 0, covering {A,B} c=1/5 idx 1, p=1/5: Φ 0.28387293,
+  D 0.28316249, P_dissent 0.49953016; merged-singleton no-sample Φ 0.35944805.
+- four witnesses, factors {0,1} and {2,3} each c=1/2, p=0: P_dissent 47/63 = 0.74603175,
+  maj_none∧dissent 47/63, P(false maj | dissent) = 0 (measured), P(false maj | any maj ∧
+  dissent) unmeasured (no majority mass), Φ = D = 1/64.
+- probe (Φ 0.07683409, n=64): p_u=0.2 → 0.00033; 0.98 → 0.06080; 0.99 → 0.11566; 1 → 1;
+  Φ=0,p_u=0.2 → 0; Φ=1,p_u=0.2 → 1.
+- identification: c=1/5, p_A=1/2, p_B=3/8 → c recovered exactly 1/5; (c=1/5,p_A=1,
+  p_B=3/8) vs (c=2/5,p_A=1,p_B=1/6) have identical moments → s_A = 0 → unidentified.
+- identity 1 − P_true − P_false = P_dissent holds in every case.
+
+## 10. Open, by name
+Partial value sharing (a factor firing without forcing one value) — a future model;
+probe usefulness beyond the private-only case; discovery of sharing structure (never by a
+measure); adequacy policies (min cells, interval widths, budgets) as declared lines.
+
+## 11. Acceptance
+TypeScript implementation reproduces every captured vector exactly in rational
+arithmetic; validation refuses by name; budget is computed before work; every result
+carries model, handed parameters and conditions; states identical before and after;
+the descriptive 0.4.0 measures and all algebra hashes unchanged.

package/package.json

@@ -1,93 +1 @@
-{
-  "name": "@lapxo/obligations",
-  "version": "0.3.4",
-  "description": "The algebra of a cell: two poles, origins with phase, eight acts.",
-  "type": "module",
-  "license": "MIT",
-  "author": "Lapxo",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Lapxo/obligations.git"
-  },
-  "keywords": [
-    "obligations",
-    "lattice",
-    "provenance"
-  ],
-  "sideEffects": false,
-  "engines": {
-    "node": ">=22.12"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/lattice/index.d.ts",
-      "default": "./dist/lattice/index.js"
-    },
-    "./debit": {
-      "types": "./dist/debit/debit.d.ts",
-      "default": "./dist/debit/debit.js"
-    },
-    "./encounter": {
-      "types": "./dist/field/encounter.d.ts",
-      "default": "./dist/field/encounter.js"
-    },
-    "./field": {
-      "types": "./dist/field/field.d.ts",
-      "default": "./dist/field/field.js"
-    },
-    "./forms": {
-      "types": "./dist/lattice/forms.d.ts",
-      "default": "./dist/lattice/forms.js"
-    },
-    "./lattice": {
-      "types": "./dist/lattice/lattice.d.ts",
-      "default": "./dist/lattice/lattice.js"
-    },
-    "./packed": {
-      "types": "./dist/debit/packed.d.ts",
-      "default": "./dist/debit/packed.js"
-    },
-    "./present": {
-      "types": "./dist/field/present.d.ts",
-      "default": "./dist/field/present.js"
-    },
-    "./price": {
-      "types": "./dist/lattice/price/index.d.ts",
-      "default": "./dist/lattice/price/index.js"
-    },
-    "./replay": {
-      "types": "./dist/replay.d.ts",
-      "default": "./dist/replay.js"
-    },
-    "./shuffle": {
-      "types": "./dist/debit/shuffle.d.ts",
-      "default": "./dist/debit/shuffle.js"
-    },
-    "./signatures": {
-      "types": "./dist/field/signatures.d.ts",
-      "default": "./dist/field/signatures.js"
-    },
-    "./views/field": {
-      "types": "./dist/views/field.d.ts",
-      "default": "./dist/views/field.js"
-    },
-    "./views/product": {
-      "types": "./dist/views/product.d.ts",
-      "default": "./dist/views/product.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "TARGET.bound"
-  ],
-  "scripts": {
-    "build": "tsc --build"
-  },
-  "devDependencies": {
-    "@types/node": "^22",
-    "typescript": "^5.9.3"
-  }
-}
+{"name":"@lapxo/obligations","version":"0.4.0","description":"The algebra of a cell: two poles, origins with phase, eight acts.","type":"module","license":"MIT","author":"Lapxo","repository":{"type":"git","url":"git+https://github.com/Lapxo/obligations.git"},"keywords":["obligations","lattice","provenance"],"sideEffects":false,"engines":{"node":">=22.12"},"exports":{".":{"types":"./dist/lattice/index.d.ts","default":"./dist/lattice/index.js"},"./debit":{"types":"./dist/debit/debit.d.ts","default":"./dist/debit/debit.js"},"./encounter":{"types":"./dist/field/encounter.d.ts","default":"./dist/field/encounter.js"},"./field":{"types":"./dist/field/field.d.ts","default":"./dist/field/field.js"},"./forms":{"types":"./dist/lattice/forms.d.ts","default":"./dist/lattice/forms.js"},"./lattice":{"types":"./dist/lattice/lattice.d.ts","default":"./dist/lattice/lattice.js"},"./measures":{"types":"./dist/measures/index.d.ts","default":"./dist/measures/index.js"},"./packed":{"types":"./dist/debit/packed.d.ts","default":"./dist/debit/packed.js"},"./present":{"types":"./dist/field/present.d.ts","default":"./dist/field/present.js"},"./price":{"types":"./dist/lattice/price/index.d.ts","default":"./dist/lattice/price/index.js"},"./replay":{"types":"./dist/replay.d.ts","default":"./dist/replay.js"},"./shuffle":{"types":"./dist/debit/shuffle.d.ts","default":"./dist/debit/shuffle.js"},"./signatures":{"types":"./dist/field/signatures.d.ts","default":"./dist/field/signatures.js"},"./views/field":{"types":"./dist/views/field.d.ts","default":"./dist/views/field.js"},"./views/product":{"types":"./dist/views/product.d.ts","default":"./dist/views/product.js"},"./package.json":"./package.json"},"files":["dist","README.md","LICENSE","TARGET.bound","receipts.bound","docs/measures.md","samples/measures","vectors/measures","samples/yes/algebra-is-closed.json","samples/yes/field-uses-price-and-debit.json","samples/yes/three-theories-one-algebra.json","src/lattice/index.ts","src/field/motion.ts","samples/yes/installed-artifact.json","samples/no/installed-artifact.json","vectors/measures/installed-artifact.cli.json"],"scripts":{"build":"tsc --build","test":"node --import ./test/setup.ts --test --test-concurrency=2 test/*.test.ts test/measures/*.test.ts"},"devDependencies":{"@types/node":"^22","typescript":"^5.9.3"}}