@lapxo/obligations 0.4.2 → 0.4.3

package/dist/measures/mix-loss.d.ts

@@ -0,0 +1,187 @@
+import { type RationalInput } from './rational.ts';
+export type NamedConfiguration = Readonly<{
+    id: string;
+    values: readonly string[];
+}>;
+export type ConfigurationPrior = Readonly<{
+    kind: 'uniform';
+}> | Readonly<{
+    kind: 'explicit';
+    probabilities: readonly Readonly<{
+        configuration: string;
+        p: RationalInput;
+    }>[];
+}>;
+export type MixLossModel = Readonly<{
+    factors: readonly Readonly<{
+        id: string;
+        weight: RationalInput;
+    }>[];
+    alphabet: readonly string[];
+    configurations: readonly NamedConfiguration[];
+    prior?: ConfigurationPrior;
+}>;
+export type MixLossPolicy = Readonly<{
+    logarithm: 'binary64-log2';
+    budget: string;
+}>;
+export declare function mixProjectionLoss(model: MixLossModel, policy: MixLossPolicy): {
+    status: "unmeasured";
+    cause: "mix-loss/prior-required";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    required?: undefined;
+    workUnit?: undefined;
+    model?: undefined;
+    prior?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    configurationBits?: undefined;
+    mixBits?: undefined;
+    lossBits?: undefined;
+    entropyDifferenceBits?: undefined;
+    forkLossBits?: undefined;
+    mixInjectiveOnConfigurations?: undefined;
+    mixInjectiveOnPositiveSupport?: undefined;
+    configurations?: undefined;
+    outputs?: undefined;
+    meaning?: undefined;
+} | {
+    status: "unmeasured";
+    cause: "mix-loss/work-budget";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    required: string;
+    workUnit: "declared-configurations";
+    model?: undefined;
+    prior?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    configurationBits?: undefined;
+    mixBits?: undefined;
+    lossBits?: undefined;
+    entropyDifferenceBits?: undefined;
+    forkLossBits?: undefined;
+    mixInjectiveOnConfigurations?: undefined;
+    mixInjectiveOnPositiveSupport?: undefined;
+    configurations?: undefined;
+    outputs?: undefined;
+    meaning?: undefined;
+} | {
+    status: "measured";
+    model: "declared-weighted-mix-projection@1";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    prior: {
+        kind: "uniform" | "explicit";
+        probabilities: {
+            configuration: string;
+            p: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    unit: "bits";
+    approximation: "binary64-log2";
+    configurationBits: number;
+    mixBits: number;
+    lossBits: number;
+    entropyDifferenceBits: number;
+    forkLossBits: number;
+    mixInjectiveOnConfigurations: boolean;
+    mixInjectiveOnPositiveSupport: boolean;
+    configurations: {
+        id: string;
+        probability: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        mix: Readonly<{
+            kind: "value";
+            value: string;
+        }> | {
+            kind: "tie";
+        };
+        fork: {
+            factor: string;
+            value: string;
+        }[];
+    }[];
+    outputs: {
+        output: Readonly<{
+            kind: "value";
+            value: string;
+        }> | {
+            kind: "tie";
+        };
+        probability: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        configurations: string[];
+        posterior: {
+            configuration: string;
+            p: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        conditionalBits: number | null;
+    }[];
+    meaning: "conditional entropy of the declared configuration given its deterministic mix output; named fork is injective";
+    cause?: undefined;
+    required?: undefined;
+    workUnit?: undefined;
+};

package/dist/measures/mix-loss.js

@@ -0,0 +1,101 @@
+import { add, div, one, pack, probability, rational, zero } from "./rational.js";
+const refuse = (why) => { throw Error('REFUSE·mix-loss ' + why); };
+const exact = (input, asProbability = false) => {
+    try {
+        return asProbability ? probability(input) : rational(input);
+    }
+    catch {
+        return refuse('invalid ' + (asProbability ? 'prior probability' : 'factor weight'));
+    }
+};
+const logInteger = (n) => { const shift = Math.max(0, n.toString(2).length - 53); return Math.log2(Number(n >> BigInt(shift))) + shift; };
+const logQ = (p) => logInteger(p[0]) - logInteger(p[1]);
+const numeric = (p) => p[0] === 0n ? 0 : 2 ** logQ(p);
+const entropy = (ps) => ps.reduce((sum, p) => p[0] === 0n ? sum : sum - numeric(p) * logQ(p), 0);
+const uniqueNames = (names, what) => {
+    if (!Array.isArray(names) || !names.length || names.some(n => typeof n !== 'string' || !n.trim()) || new Set(names).size !== names.length)
+        refuse('distinct nonempty ' + what + ' required');
+};
+export function mixProjectionLoss(model, policy) {
+    if (!policy || policy.logarithm !== 'binary64-log2' || typeof policy.budget !== 'string' || !/^\d+$/.test(policy.budget))
+        refuse('logarithm and work budget required');
+    if (!model || !Array.isArray(model.factors) || !Array.isArray(model.alphabet) || !Array.isArray(model.configurations))
+        refuse('declared factors, alphabet and configuration support required');
+    uniqueNames(model.factors.map(f => f?.id), 'factor IDs');
+    uniqueNames(model.alphabet, 'alphabet values');
+    uniqueNames(model.configurations.map(c => c?.id), 'configuration IDs');
+    const alphabet = new Set(model.alphabet);
+    const patterns = new Set();
+    for (const c of model.configurations) {
+        if (!Array.isArray(c.values) || c.values.length !== model.factors.length || c.values.some(v => !alphabet.has(v)))
+            refuse('configuration outside declared factor/alphabet domain');
+        const pattern = JSON.stringify(c.values);
+        if (patterns.has(pattern))
+            refuse('duplicate named-factor configuration');
+        patterns.add(pattern);
+    }
+    const weights = model.factors.map(f => exact(f.weight));
+    if (weights.some(w => w[0] < 0n) || weights.every(w => w[0] === 0n))
+        refuse('nonnegative weights with positive total required');
+    const parameters = { m: model.factors.length, factors: model.factors.map((f, i) => ({ id: f.id, weight: pack(weights[i]) })),
+        alphabet: [...model.alphabet], configurations: model.configurations.map(c => ({ id: c.id, values: [...c.values] })) };
+    if (!model.prior)
+        return { status: 'unmeasured', cause: 'mix-loss/prior-required', parameters, policy };
+    const required = BigInt(model.configurations.length);
+    if (required > BigInt(policy.budget))
+        return { status: 'unmeasured', cause: 'mix-loss/work-budget',
+            parameters, policy, required: String(required), workUnit: 'declared-configurations' };
+    let prior;
+    if (model.prior.kind === 'uniform')
+        prior = model.configurations.map(() => div(one, [BigInt(model.configurations.length), 1n]));
+    else if (model.prior.kind === 'explicit') {
+        const entries = model.prior.probabilities;
+        if (!Array.isArray(entries) || entries.length !== model.configurations.length || entries.some(e => !e || typeof e.configuration !== 'string') ||
+            new Set(entries.map(e => e.configuration)).size !== entries.length)
+            refuse('one prior probability per configuration required');
+        const byId = new Map(entries.map(e => [e.configuration, exact(e.p, true)]));
+        if (model.configurations.some(c => !byId.has(c.id)))
+            refuse('prior support differs from declared configurations');
+        prior = model.configurations.map(c => byId.get(c.id));
+        const total = prior.reduce(add, zero);
+        if (total[0] !== total[1])
+            refuse('prior probabilities must sum exactly to one');
+    }
+    else
+        return refuse('declared prior kind required');
+    const fibers = new Map();
+    const configurations = model.configurations.map((c, i) => {
+        const totals = new Map(model.alphabet.map(v => [v, zero]));
+        c.values.forEach((v, j) => totals.set(v, add(totals.get(v), weights[j])));
+        let best = zero;
+        for (const total of totals.values())
+            if (total[0] * best[1] > best[0] * total[1])
+                best = total;
+        const winners = model.alphabet.filter(v => { const t = totals.get(v); return t[0] * best[1] === best[0] * t[1]; });
+        const output = winners.length === 1 ? { kind: 'value', value: winners[0] } : { kind: 'tie', values: winners };
+        const key = output.kind === 'tie' ? 'tie' : JSON.stringify(['value', output.value]);
+        const fiber = fibers.get(key) ?? { output: output.kind === 'tie' ? { kind: 'tie', values: [] } : output, indices: [] };
+        fiber.indices.push(i);
+        fibers.set(key, fiber);
+        return { id: c.id, probability: pack(prior[i]), mix: output.kind === 'tie' ? { kind: 'tie' } : output,
+            fork: model.factors.map((f, j) => ({ factor: f.id, value: c.values[j] })) };
+    });
+    const outputs = [...fibers.values()].map(f => {
+        const mass = f.indices.map(i => prior[i]).reduce(add, zero);
+        const posterior = mass[0] === 0n ? [] : f.indices.map(i => ({ configuration: model.configurations[i].id, p: div(prior[i], mass) }));
+        return { output: f.output.kind === 'tie' ? { kind: 'tie' } : f.output, probability: pack(mass),
+            configurations: f.indices.map(i => model.configurations[i].id),
+            posterior: posterior.map(p => ({ configuration: p.configuration, p: pack(p.p) })),
+            conditionalBits: mass[0] === 0n ? null : entropy(posterior.map(p => p.p)), mass };
+    });
+    const configurationBits = entropy(prior), mixBits = entropy(outputs.map(o => o.mass));
+    const lossBits = outputs.reduce((sum, o) => sum + (o.conditionalBits === null ? 0 : numeric(o.mass) * o.conditionalBits), 0);
+    return { status: 'measured', model: 'declared-weighted-mix-projection@1', parameters,
+        prior: { kind: model.prior.kind, probabilities: model.configurations.map((c, i) => ({ configuration: c.id, p: pack(prior[i]) })) },
+        policy, unit: 'bits', approximation: 'binary64-log2', configurationBits, mixBits, lossBits,
+        entropyDifferenceBits: configurationBits - mixBits, forkLossBits: 0,
+        mixInjectiveOnConfigurations: [...fibers.values()].every(f => f.indices.length === 1),
+        mixInjectiveOnPositiveSupport: [...fibers.values()].every(f => f.indices.filter(i => prior[i][0] > 0n).length <= 1),
+        configurations, outputs: outputs.map(({ mass, ...o }) => o),
+        meaning: 'conditional entropy of the declared configuration given its deterministic mix output; named fork is injective' };
+}

package/dist/measures/phase-defect.d.ts

@@ -0,0 +1,40 @@
+import type { LogarithmPolicy } from './capacity.ts';
+export type PhaseDefectInterpretation = 'phase-defect' | 'information';
+export declare function phaseDefect(n: number, p: number, s: number, policy: LogarithmPolicy, interpretation?: PhaseDefectInterpretation): {
+    model: "F4-integer-phase-defect@1";
+    parameters: {
+        n: number;
+        p: number;
+        s: number;
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+    }>;
+    status: "measured";
+    meaning: "phase defect; information interpretation open";
+    regime: "nonnegative" | "may-be-negative";
+    value: number;
+};
+export declare function phaseDefectExtrema(n: number, p: number, policy: LogarithmPolicy): {
+    model: "F4-integer-phase-defect@1";
+    parameters: {
+        n: number;
+        p: number;
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+    }>;
+    status: "measured";
+    minimum: {
+        value: number;
+        shifts: number[];
+    };
+    maximum: {
+        value: number;
+        shifts: number[];
+    };
+    nonzeroMaximum: {
+        value: number;
+        shifts: number[];
+    } | null;
+};

package/dist/measures/phase-defect.js

@@ -0,0 +1,33 @@
+const refuse = (cause) => { throw new Error('REFUSE·phase-defect ' + cause); };
+function domain(n, p, policy) {
+    if (!Number.isSafeInteger(n) || n < 1 || !Number.isSafeInteger(p) || p < 1 || n % p !== 0)
+        refuse('positive integer divisor domain required');
+    if (!policy || policy.logarithm !== 'binary64-log2')
+        refuse('logarithm policy required');
+}
+function shift(p, s) {
+    if (!Number.isSafeInteger(s) || s < 0 || s >= p)
+        refuse('integer shift domain required');
+}
+function binaryEntropy(t) {
+    return t === 0 || t === 1 ? 0 : -t * Math.log2(t) - (1 - t) * Math.log2(1 - t);
+}
+export function phaseDefect(n, p, s, policy, interpretation = 'phase-defect') {
+    domain(n, p, policy);
+    shift(p, s);
+    if (interpretation !== 'phase-defect')
+        refuse('information interpretation unsupported');
+    return { model: 'F4-integer-phase-defect@1', parameters: { n, p, s }, policy,
+        status: 'measured', meaning: 'phase defect; information interpretation open',
+        regime: n / p >= 2 ? 'nonnegative' : 'may-be-negative',
+        value: Math.log2(n / p) - binaryEntropy(s / p) };
+}
+export function phaseDefectExtrema(n, p, policy) {
+    domain(n, p, policy);
+    const middle = Math.floor(p / 2), minimumShifts = p === 1 ? [0] : p % 2 === 0 ? [middle] : [middle, middle + 1];
+    return { model: 'F4-integer-phase-defect@1', parameters: { n, p }, policy,
+        status: 'measured',
+        minimum: { value: Math.log2(n / p) - binaryEntropy(middle / p), shifts: minimumShifts },
+        maximum: { value: Math.log2(n / p), shifts: [0] },
+        nonzeroMaximum: p === 1 ? null : { value: Math.log2(n / p) - binaryEntropy(1 / p), shifts: p === 2 ? [1] : [1, p - 1] } };
+}

package/dist/measures/tolerant-subsets.d.ts

@@ -0,0 +1,79 @@
+import { type DeclaredFailure } from './confidence.ts';
+export declare function tolerantSubsetConfidence(failures: readonly DeclaredFailure[], k: number, probabilitySpace: string): {
+    model: "declared-failure-subset-bound@1";
+    status: "conditional-bound";
+    unit: "probability";
+    probabilitySpace: string;
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    allowedFailures: number;
+    totalDeclarations: number;
+    conditions: readonly ["common-probability-space", "declared-marginal-upper-bounds"];
+    referencesVerified: false;
+    terms: {
+        id: string;
+        subsets: string;
+        contribution: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+    }[];
+    uncappedFailureBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    failureUpperBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+};
+export type JointIndependenceDeclaration = Readonly<{
+    probabilitySpace: string;
+    jointIndependence: true;
+    justification: string;
+}>;
+export declare function independentCountConfidence(failures: readonly DeclaredFailure[], k: number, declaration: JointIndependenceDeclaration): {
+    model: "declared-joint-independent-count-bound@1";
+    status: "conditional-bound";
+    unit: "probability";
+    probabilitySpace: string;
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    allowedFailures: number;
+    totalDeclarations: number;
+    jointIndependence: {
+        declared: true;
+        justification: string;
+    };
+    referencesVerified: false;
+    bernoulliEnvelope: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>[];
+    failureUpperBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+};

package/dist/measures/tolerant-subsets.js

@@ -0,0 +1,60 @@
+import { unionBoundConfidence } from "./confidence.js";
+import { add, sub, mul, q, rational, zero, one, pack } from "./rational.js";
+const refuse = (cause) => { throw new Error('REFUSE·L7 ' + cause); };
+function inputs(failures, k, probabilitySpace) {
+    if (typeof probabilitySpace !== 'string' || probabilitySpace.trim() === '')
+        refuse('common-probability-space-required');
+    const base = unionBoundConfidence(failures), m = base.declarations.length;
+    if (!Number.isSafeInteger(k) || k < 0 || k > m)
+        refuse('allowed-failure-count-outside-0..m');
+    return { base, m };
+}
+function choose(n, k) {
+    if (k > n)
+        return 0n;
+    let c = 1n;
+    for (let j = 1; j <= Math.min(k, n - k); j++)
+        c = c * BigInt(n - j + 1) / BigInt(j);
+    return c;
+}
+export function tolerantSubsetConfidence(failures, k, probabilitySpace) {
+    const { base, m } = inputs(failures, k, probabilitySpace);
+    const ordered = base.declarations.map(entry => ({ entry, p: rational(entry.p) })).sort((a, b) => {
+        const d = a.p[0] * b.p[1] - b.p[0] * a.p[1];
+        return d < 0n ? -1 : d > 0n ? 1 : 0;
+    });
+    let sum = zero;
+    const terms = k === m ? [] : ordered.slice(0, m - k).map(({ entry, p }, j) => {
+        const coefficient = choose(m - j - 1, k), contribution = mul(p, q(coefficient));
+        sum = add(sum, contribution);
+        return { id: entry.id, subsets: String(coefficient), contribution: pack(contribution) };
+    });
+    const trivial = sum[0] >= sum[1], upper = trivial ? one : sum;
+    return { model: 'declared-failure-subset-bound@1', status: 'conditional-bound',
+        unit: 'probability', probabilitySpace, declarations: base.declarations,
+        allowedFailures: k, totalDeclarations: m, conditions: ['common-probability-space', 'declared-marginal-upper-bounds'],
+        referencesVerified: false, terms, uncappedFailureBound: pack(sum), failureUpperBound: pack(upper),
+        value: pack(sub(one, upper)), trivial };
+}
+export function independentCountConfidence(failures, k, declaration) {
+    if (!declaration || declaration.jointIndependence !== true)
+        refuse('joint-independence-required');
+    if (typeof declaration.justification !== 'string' || declaration.justification.trim() === '')
+        refuse('joint-independence-justification-required');
+    const { base, m } = inputs(failures, k, declaration.probabilitySpace);
+    let distribution = [one];
+    for (const entry of base.declarations) {
+        const p = rational(entry.p), next = Array.from({ length: distribution.length + 1 }, () => zero);
+        for (let j = 0; j < distribution.length; j++) {
+            next[j] = add(next[j], mul(distribution[j], sub(one, p)));
+            next[j + 1] = add(next[j + 1], mul(distribution[j], p));
+        }
+        distribution = next;
+    }
+    const upper = distribution.slice(k + 1).reduce(add, zero);
+    return { model: 'declared-joint-independent-count-bound@1', status: 'conditional-bound',
+        unit: 'probability', probabilitySpace: declaration.probabilitySpace, declarations: base.declarations,
+        allowedFailures: k, totalDeclarations: m, jointIndependence: { declared: true, justification: declaration.justification },
+        referencesVerified: false, bernoulliEnvelope: distribution.map(pack), failureUpperBound: pack(upper),
+        value: pack(sub(one, upper)), trivial: upper[0] === upper[1] };
+}

package/docs/measures.md

@@ -211,3 +211,11 @@ These operations compute conditional probability bounds. They select neither a g
 At n=4,c=1,q=1/4 the bound is exactly zero; q=0 gives log2(4/3), and q=1 gives two bits. Missing q refuses. The operational declaration or detection of activation remains open in identification.model. Unconditioned coincidence does not identify q.
 
 M/3 and M/4 retain their existing definitions. Partial-factor governance proposals do not supply a conditional joint observation and selection law. The information carried by dissent, including a bottom symbol, is open for those unspecified proposals.
+
+## Obligations 0.4.3 — proposed conditional measures
+
+L7: conditional bound on one declared common probability space: P(N>k)<=min(1,sum over |S|=k+1 of min p_i), with rational declared marginal failure upper bounds and 0<=k<=m. Trivial iff computed upper bound is one. Counterexamples refute the former top-k+1 success guarantee. Joint-independent Bernoulli convolution is a separate declared hypothesis; rho=0 and pairwise independence do not supply it. Existing stronger 0.4.2 count bound is unchanged and needs no joint independence.
+
+L8: law by enumeration only for 3<=n<=64, positive integer divisors p|n and integer 0<=s<p. D=log2(n/p)-h(s/p), explicit binary64-log2 approximation. Odd-period minimum uses h(floor(p/2)/p), even-period minimum uses one. Complete maximum at zero; nonzero domain has endpoints 1,p-1, empty when p=1. No information or worst-case interpretation follows from nonnegativity. T87 retains its separate wrapped-phase amplitude identity.
+
+L9: law by counterexample of existence of noninjective weighted mix, and measure with a declared prior on a finite explicitly supplied set of named-factor configurations. Equal-weight ab and ba give the same bottom tie and different named forks. Loss is H(configuration | mix)=H(configuration)-H(mix); a uniform prior must be explicitly selected, absent prior is unmeasured. The four-state uniform example has mean loss 0.5 bits and one bit conditioned on tie; the injective named fork has zero loss. Defines no new algebraic act, governance selection, M/3 or M/4 law, or destroyed field.

package/package.json

@@ -1 +1 @@
-{"name":"@lapxo/obligations","version":"0.4.2","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","docs/img","docs/paper.md","docs/reference.md","docs/learn/in-phase.md","docs/learn/price.md","docs/learn/signature.md","docs/learn/thermometer.md","docs/learn/withdrawal.md"],"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"}}
+{"name":"@lapxo/obligations","version":"0.4.3","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","docs/img","docs/paper.md","docs/reference.md","docs/learn/in-phase.md","docs/learn/price.md","docs/learn/signature.md","docs/learn/thermometer.md","docs/learn/withdrawal.md","vectors/laws/policy.json","vectors/laws/l7-tolerant-k.json","vectors/laws/l8-phase-defect.json","vectors/laws/l9-mix-loss.json","vectors/laws/implementation-043.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"}}