@lapxo/obligations 0.2.0

package/dist/lattice/lattice.js

@@ -0,0 +1,14 @@
+export function eq(L, a, b) {
+    return L.leq(a, b) && L.leq(b, a);
+}
+export function relate(L, a, b) {
+    const ab = L.leq(a, b);
+    const ba = L.leq(b, a);
+    if (ab && ba)
+        return 'equal';
+    if (ab)
+        return 'narrower';
+    if (ba)
+        return 'wider';
+    return 'incomparable';
+}

package/dist/lattice/obligatory.d.ts

@@ -0,0 +1,27 @@
+import type { Lattice } from './lattice.ts';
+export interface Claim<T> {
+    readonly origin: string;
+    readonly span: T;
+    readonly id?: string;
+    readonly at?: number;
+    readonly takes?: string;
+}
+export interface Obligatory<T> {
+    readonly at: readonly string[];
+    readonly epoch: number;
+    readonly seen: readonly Claim<T>[];
+    readonly restsOn: readonly string[];
+    readonly ceiling?: T;
+    readonly witnesses?: readonly string[];
+}
+export declare function cell<T>(at: string, epoch?: number, seen?: readonly Claim<T>[], restsOn?: readonly string[]): Obligatory<T>;
+export declare function meet<T>(lattice: Lattice<T>, one: Obligatory<T>, bounds?: ReadonlyMap<string, T>): T;
+export declare function encounter<T>(lattice: Lattice<T>, one: Obligatory<T>, bounds?: ReadonlyMap<string, T>): {
+    readonly origins: number;
+    readonly held: T;
+};
+export declare function observe<T>(one: Obligatory<T>, claim: Claim<T>): Obligatory<T>;
+export declare function sign<T>(lattice: Lattice<T>, bounds: ReadonlyMap<string, T>, name: string, span: T): ReadonlyMap<string, T>;
+export declare function sign<T>(lattice: Lattice<T>, world: readonly Obligatory<T>[], name: string, span: T): readonly Obligatory<T>[];
+export declare function join<T>(lattice: Lattice<T>, one: Obligatory<T>, span: T, witness: string): Obligatory<T>;
+export declare function refine<T>(one: Obligatory<T>, steps: number): Obligatory<T>;

package/dist/lattice/obligatory.js

@@ -0,0 +1,33 @@
+import { coordinate } from "../field/field.js";
+export function cell(at, epoch = 0, seen = [], restsOn = []) {
+    return { at: coordinate(at), epoch, seen, restsOn };
+}
+const standing = (one) => {
+    const taken = new Set(one.seen.flatMap((claim) => (claim.takes === undefined ? [] : [claim.takes])));
+    return one.seen.filter((claim) => claim.takes === undefined && (claim.id === undefined || !taken.has(claim.id)));
+};
+export function meet(lattice, one, bounds = new Map()) {
+    const rested = one.restsOn.flatMap((name) => (bounds.has(name) ? [bounds.get(name)] : []));
+    const own = one.ceiling === undefined ? [] : [one.ceiling];
+    return [...standing(one).map((claim) => claim.span), ...rested, ...own].reduce((held, span) => lattice.meet(held, span), lattice.top);
+}
+export function encounter(lattice, one, bounds) {
+    return { origins: new Set(standing(one).map((claim) => claim.origin)).size, held: meet(lattice, one, bounds) };
+}
+export function observe(one, claim) {
+    return { ...one, epoch: Math.max(one.epoch, claim.at ?? one.epoch), seen: [...one.seen, claim] };
+}
+export function sign(lattice, held, name, span) {
+    if (!(held instanceof Map)) {
+        return held.map((one) => (one.restsOn.includes(name) ? { ...one, ceiling: lattice.meet(one.ceiling ?? lattice.top, span) } : one));
+    }
+    return new Map([...held, [name, lattice.meet(held.get(name) ?? lattice.top, span)]]);
+}
+export function join(lattice, one, span, witness) {
+    if (witness === '')
+        throw new Error('REFUSE·join a widening lands only with a witness or the signatures of whoever rests on the old bound');
+    return { ...one, ceiling: lattice.join(one.ceiling ?? lattice.top, span), witnesses: [...(one.witnesses ?? []), witness] };
+}
+export function refine(one, steps) {
+    return { ...one, at: steps >= one.at.length ? one.at : one.at.slice(0, Math.max(1, steps)) };
+}

package/dist/lattice/order.d.ts

@@ -0,0 +1,6 @@
+import type { Scale, Level } from './types.ts';
+export declare function chain(levels: readonly string[]): Scale;
+export declare function height(c: Scale, level: Level): number;
+export declare function isDistributive(c: Scale): boolean;
+export declare function order(levels: readonly string[], leq: readonly boolean[][]): Scale;
+export declare const BOOLEAN: () => Scale;

package/dist/lattice/order.js

@@ -0,0 +1,150 @@
+import { UnitError } from "./errors.js";
+function build(levels, join, meet) {
+    const n = levels.length;
+    for (let i = 0; i < n; i++) {
+        if (levels.indexOf(levels[i]) !== i) {
+            throw new UnitError('DUPLICATE_LEVEL', `the level \`${levels[i]}\` is declared twice`, {
+                level: levels[i],
+            });
+        }
+    }
+    const index = new Map(levels.map((l, i) => [l, i]));
+    const leq = (a, b) => join[a][b] === b;
+    const total = levels.every((_, i) => levels.every((__, j) => join[i][j] === i || join[i][j] === j));
+    let simple = true;
+    for (let x = 0; x < n && simple; x++) {
+        for (let y = 0; y < n && simple; y++) {
+            for (let z = 0; z < n; z++) {
+                if (meet[x][join[y][z]] !== join[meet[x][y]][meet[x][z]]) {
+                    simple = false;
+                    break;
+                }
+            }
+        }
+    }
+    const all = [...levels.keys()];
+    const bottomIx = all.find((i) => all.every((j) => leq(i, j))) ?? 0;
+    const topIx = all.find((i) => all.every((j) => leq(j, i))) ?? n - 1;
+    const joinIrr = all.filter((j) => j !== bottomIx &&
+        all.filter((x) => x !== j && leq(x, j)).reduce((acc, x) => join[acc][x], bottomIx) !== j);
+    const meetIrr = all.filter((m) => m !== topIx &&
+        all.filter((x) => x !== m && leq(m, x)).reduce((acc, x) => meet[acc][x], topIx) !== m);
+    const seen = new Set();
+    const allDebits = [];
+    for (const x of [...joinIrr, ...meetIrr]) {
+        if (!seen.has(x)) {
+            seen.add(x);
+            allDebits.push(x);
+        }
+    }
+    return {
+        levels,
+        isLadder: total,
+        isSimple: simple,
+        bottomIx,
+        topIx,
+        bottom: levels[bottomIx],
+        top: levels[topIx],
+        leq,
+        higher: (a, b) => join[a][b],
+        lower: (a, b) => meet[a][b],
+        rank(level) {
+            const r = index.get(level);
+            if (r === undefined) {
+                throw new UnitError('UNKNOWN_LEVEL', `no level \`${level}\` in this scale`, {
+                    level,
+                    levels,
+                });
+            }
+            return r;
+        },
+        stateOf(floor, ceiling) {
+            if (!leq(floor, ceiling))
+                return 'CONFLICT';
+            if (floor !== bottomIx)
+                return 'REQUIRED';
+            if (ceiling !== topIx)
+                return 'FORBIDDEN';
+            return 'FREE';
+        },
+        joins: () => joinIrr.slice(),
+        limits: () => meetIrr.slice(),
+        debits: () => allDebits.slice(),
+        intervalHeight(lo, hi) {
+            if (!leq(lo, hi))
+                return null;
+            const inside = all.filter((x) => leq(lo, x) && leq(x, hi));
+            const covers = (x) => inside.filter((y) => y !== x &&
+                leq(x, y) &&
+                !inside.some((z) => z !== x && z !== y && leq(x, z) && leq(z, y)));
+            const long = new Map([[lo, 0]]);
+            const short = new Map([[lo, 0]]);
+            const walk = [...inside].sort((a, b) => inside.filter((z) => leq(z, a)).length - inside.filter((z) => leq(z, b)).length);
+            for (const x of walk) {
+                const lx = long.get(x);
+                const sx = short.get(x);
+                if (lx === undefined || sx === undefined)
+                    continue;
+                for (const y of covers(x)) {
+                    long.set(y, Math.max(long.get(y) ?? lx + 1, lx + 1));
+                    short.set(y, Math.min(short.get(y) ?? sx + 1, sx + 1));
+                }
+            }
+            const l = long.get(hi);
+            return l !== undefined && l === short.get(hi) ? l : null;
+        },
+    };
+}
+export function chain(levels) {
+    if (!Array.isArray(levels) || levels.length === 0) {
+        throw new UnitError('EMPTY_CHAIN', 'a chain needs at least one level');
+    }
+    const n = levels.length;
+    const grid = (f) => [...Array(n)].map((_, i) => [...Array(n)].map((__, j) => f(i, j)));
+    return build(levels, grid(Math.max), grid(Math.min));
+}
+export function height(c, level) {
+    const r = level;
+    const depth = (x) => {
+        let d = 0;
+        for (let y = 0; y < c.levels.length; y++)
+            if (y !== x && c.leq(y, x))
+                d++;
+        return d;
+    };
+    let h = 0;
+    for (let x = 0; x < c.levels.length; x++)
+        if (x !== r && c.leq(x, r))
+            h = Math.max(h, depth(x) + 1);
+    return h;
+}
+export function isDistributive(c) {
+    const n = c.levels.length;
+    for (let x = 0; x < n; x++)
+        for (let y = 0; y < n; y++)
+            for (let z = 0; z < n; z++) {
+                const left = c.higher(x, c.lower(y, z));
+                const right = c.lower(c.higher(x, y), c.higher(x, z));
+                if (left !== right)
+                    return false;
+            }
+    return true;
+}
+export function order(levels, leq) {
+    if (!Array.isArray(levels) || levels.length === 0) {
+        throw new UnitError('EMPTY_CHAIN', 'an order needs at least one level');
+    }
+    const n = levels.length;
+    const bound = (a, b, up) => {
+        const bs = [...Array(n).keys()].filter((x) => up ? leq[a][x] && leq[b][x] : leq[x][a] && leq[x][b]);
+        const least = bs.filter((x) => bs.every((y) => (up ? leq[x][y] : leq[y][x])));
+        if (least.length !== 1) {
+            throw new UnitError('MALFORMED', `\`${levels[a]}\` and \`${levels[b]}\` have ${least.length} ` +
+                `${up ? 'lowest common' : 'highest common'} bounds, so this is not a usable scale`, { levels: [levels[a], levels[b]] });
+        }
+        return least[0];
+    };
+    const grid = (up) => [...Array(n)].map((_, i) => [...Array(n)].map((__, j) => bound(i, j, up)));
+    return build(levels, grid(true), grid(false));
+}
+export const BOOLEAN = () => chain(['no', 'yes']);

package/dist/lattice/price/attainable.d.ts

@@ -0,0 +1,22 @@
+import type { Scale } from '../types.ts';
+export type Attainability = {
+    readonly kind: 'attainable';
+    readonly value: string;
+} | {
+    readonly kind: 'hole';
+    readonly value: string;
+    readonly after: string;
+    readonly before: string;
+} | {
+    readonly kind: 'unknown';
+    readonly value: string;
+};
+export declare function attainable(c: Scale): {
+    readonly values: readonly string[];
+    readonly holes: readonly {
+        readonly value: string;
+        readonly after: string;
+        readonly before: string;
+    }[];
+};
+export declare function classifyValue(c: Scale, value: string): Attainability;

package/dist/lattice/price/attainable.js

@@ -0,0 +1,37 @@
+const trailing = (name) => {
+    const m = name.match(/^(.*?)(\d+)$/);
+    if (!m)
+        return null;
+    return { stem: m[1], n: Number(m[2]) };
+};
+export function attainable(c) {
+    const holes = [];
+    const byStem = new Map();
+    for (const name of c.levels) {
+        const t = trailing(name);
+        if (!t)
+            continue;
+        const list = byStem.get(t.stem) ?? [];
+        list.push({ name, n: t.n });
+        byStem.set(t.stem, list);
+    }
+    for (const [stem, list] of byStem) {
+        list.sort((a, b) => a.n - b.n);
+        for (let i = 0; i < list.length - 1; i++) {
+            const a = list[i];
+            const b = list[i + 1];
+            for (let n = a.n + 1; n < b.n; n++) {
+                holes.push({ value: `${stem}${n}`, after: a.name, before: b.name });
+            }
+        }
+    }
+    return { values: c.levels, holes };
+}
+export function classifyValue(c, value) {
+    if (c.levels.includes(value))
+        return { kind: 'attainable', value };
+    const found = attainable(c).holes.find((h) => h.value === value);
+    if (found)
+        return { kind: 'hole', value, after: found.after, before: found.before };
+    return { kind: 'unknown', value };
+}

package/dist/lattice/price/blocks.d.ts

@@ -0,0 +1,2 @@
+import type { Level, Scale } from '../types.ts';
+export declare function meetBlocks(c: Scale, u: Level, w: Level): Level[][];

package/dist/lattice/price/blocks.js

@@ -0,0 +1,26 @@
+export function meetBlocks(c, u, w) {
+    const lo = c.lower(u, w);
+    const hi = c.higher(u, w);
+    const jis = c.joins().filter((j) => c.leq(lo, j) && c.leq(j, hi));
+    if (jis.length === 0)
+        return [];
+    const parent = jis.map((_, i) => i);
+    const find = (x) => (parent[x] === x ? x : (parent[x] = find(parent[x])));
+    const union = (a, b) => {
+        parent[find(a)] = find(b);
+    };
+    for (let i = 0; i < jis.length; i++) {
+        for (let j = i + 1; j < jis.length; j++) {
+            if (c.leq(jis[i], jis[j]) || c.leq(jis[j], jis[i]))
+                union(i, j);
+        }
+    }
+    const groups = new Map();
+    jis.forEach((j, i) => {
+        const r = find(i);
+        const g = groups.get(r) ?? [];
+        g.push(j);
+        groups.set(r, g);
+    });
+    return [...groups.values()];
+}

package/dist/lattice/price/index.d.ts

@@ -0,0 +1,7 @@
+export { defect, dropTo, price, slack, spectrum } from './quote.ts';
+export type { Price, SpectrumQuantity } from './quote.ts';
+export { best, c_n, collapses, costOfState, gap, isSupermodular, premium, pricesAnything, } from './premium.ts';
+export { meetBlocks } from './blocks.ts';
+export { attainable, classifyValue } from './attainable.ts';
+export type { Attainability } from './attainable.ts';
+export { complexity } from '../../debit/unit.ts';

package/dist/lattice/price/index.js

@@ -0,0 +1,5 @@
+export { defect, dropTo, price, slack, spectrum } from "./quote.js";
+export { best, c_n, collapses, costOfState, gap, isSupermodular, premium, pricesAnything, } from "./premium.js";
+export { meetBlocks } from "./blocks.js";
+export { attainable, classifyValue } from "./attainable.js";
+export { complexity } from "../../debit/unit.js";

package/dist/lattice/price/premium.d.ts

@@ -0,0 +1,18 @@
+import type { Level, Scale } from '../types.ts';
+type Valuation = (level: Level) => number;
+export declare function c_n(n: number): number;
+export declare function costOfState(c: Scale, value: Valuation, u: Level, w: Level, s: Level): {
+    shortfall: number;
+    overshoot: number;
+};
+type Search = (c: Scale, value: Valuation, u: Level, w: Level) => {
+    cost: number;
+    at: Level;
+};
+export declare const best: Search;
+export declare function gap(c: Scale, value: Valuation, u: Level, w: Level): number;
+export declare function premium(c: Scale, value: Valuation, u: Level, w: Level): number;
+export declare function isSupermodular(c: Scale, value: Valuation): boolean;
+export declare function pricesAnything(c: Scale, worth: Valuation): boolean;
+export declare function collapses(c: Scale, value: Valuation, u: Level, w: Level, tol?: number): boolean;
+export {};

package/dist/lattice/price/premium.js

@@ -0,0 +1,80 @@
+const SLACK = 1e-12;
+export function c_n(n) {
+    return Math.log2(n) - 2 + 2 / n;
+}
+export function costOfState(c, value, u, w, s) {
+    return {
+        shortfall: value(u) - value(c.lower(u, s)),
+        overshoot: value(s) - value(c.lower(s, w)),
+    };
+}
+const costAt = (c, value, u, w, s) => {
+    const { shortfall, overshoot } = costOfState(c, value, u, w, s);
+    return shortfall + overshoot;
+};
+function cheapest(c, value, u, w, visit) {
+    let cost;
+    let at = c.bottomIx;
+    visit((s) => {
+        const cs = costAt(c, value, u, w, s);
+        if (cost === undefined || cs < cost) {
+            cost = cs;
+            at = s;
+        }
+    });
+    return { cost: cost ?? costAt(c, value, u, w, at), at };
+}
+function eachPair(c, u, w, fn) {
+    for (let p = 0; p < c.levels.length; p++) {
+        if (!c.leq(p, u))
+            continue;
+        for (let q = 0; q < c.levels.length; q++) {
+            if (!c.leq(q, w))
+                continue;
+            fn(p, q);
+        }
+    }
+}
+export const best = (c, value, u, w) => cheapest(c, value, u, w, (take) => {
+    for (let s = 0; s < c.levels.length; s++)
+        take(s);
+});
+export function gap(c, value, u, w) {
+    const m = c.lower(u, w);
+    let mx = value(m);
+    eachPair(c, u, w, (p, q) => {
+        const v = value(p) + value(q) - value(c.higher(p, q));
+        if (v > mx)
+            mx = v;
+    });
+    return mx - value(m);
+}
+export function premium(c, value, u, w) {
+    return value(u) - value(c.lower(u, w)) - best(c, value, u, w).cost;
+}
+export function isSupermodular(c, value) {
+    for (let x = 0; x < c.levels.length; x++) {
+        for (let y = 0; y < c.levels.length; y++) {
+            const ri = value(x) + value(y) - value(c.higher(x, y)) - value(c.lower(x, y));
+            if (ri > SLACK)
+                return false;
+        }
+    }
+    return true;
+}
+function gapVanishes(c, value) {
+    for (let a = 0; a < c.levels.length; a++) {
+        for (let b = 0; b < c.levels.length; b++) {
+            if (c.leq(a, b) && value(a) > value(b) + SLACK)
+                return false;
+        }
+    }
+    return isSupermodular(c, value);
+}
+export function pricesAnything(c, worth) {
+    return !gapVanishes(c, worth);
+}
+export function collapses(c, value, u, w, tol = 1e-9) {
+    const ri = value(u) + value(w) - value(c.higher(u, w)) - value(c.lower(u, w));
+    return Math.abs(premium(c, value, u, w) - ri) <= tol;
+}

package/dist/lattice/price/quote.d.ts

@@ -0,0 +1,30 @@
+import type { Level, Scale } from '../types.ts';
+type Valuation = (level: Level) => number;
+export declare const dropTo: (value: Valuation, u: Level, m: Level) => number;
+export declare function defect(c: Scale, value: Valuation, a: Level, b: Level): number;
+export interface Price {
+    readonly coarse: number;
+    readonly gain: number;
+    readonly gated: number;
+    readonly derived: readonly ['gated'];
+    readonly best: number;
+    readonly at: Level;
+    readonly premium: number;
+    readonly licensed: boolean;
+}
+export declare function price(c: Scale, value: Valuation, u: Level, w: Level): Price;
+export declare function slack(c: Scale, a: Level, b: Level): {
+    up: number;
+    down: number;
+} | null;
+export type SpectrumQuantity = 'premium' | 'defect';
+export declare function spectrum(c: Scale, worth: Valuation, places?: number, quantity?: SpectrumQuantity): {
+    values: number[];
+    pairs: number;
+    band: {
+        low: number;
+        high: number;
+    };
+    degeneracy: number;
+};
+export {};

package/dist/lattice/price/quote.js

@@ -0,0 +1,53 @@
+import { UnitError } from "../errors.js";
+import { best, premium as premiumOf } from "./premium.js";
+export const dropTo = (value, u, m) => value(u) - value(m);
+export function defect(c, value, a, b) {
+    return value(a) + value(b) - value(c.higher(a, b)) - value(c.lower(a, b));
+}
+export function price(c, value, u, w) {
+    const coarse = dropTo(value, u, c.lower(u, w));
+    const gain = defect(c, value, u, w);
+    const found = best(c, value, u, w);
+    const prem = coarse - found.cost;
+    const gated = coarse - gain;
+    return {
+        coarse,
+        gain,
+        gated,
+        derived: ['gated'],
+        best: found.cost,
+        at: found.at,
+        premium: prem,
+        licensed: Math.abs(gated - found.cost) <= 1e-9,
+    };
+}
+export function slack(c, a, b) {
+    const bottom = c.bottomIx;
+    const height = (x) => c.intervalHeight(bottom, x);
+    const [ha, hb, hj, hm] = [height(a), height(b), height(c.higher(a, b)), height(c.lower(a, b))];
+    if (ha === null || hb === null || hj === null || hm === null)
+        return null;
+    return { up: hj - Math.max(ha, hb), down: Math.min(ha, hb) - hm };
+}
+export function spectrum(c, worth, places = 9, quantity = 'premium') {
+    const seen = new Set();
+    let pairs = 0;
+    for (let a = 0; a < c.levels.length; a++) {
+        for (let b = a; b < c.levels.length; b++) {
+            const left = quantity === 'defect' ? defect(c, worth, a, b) : premiumOf(c, worth, a, b);
+            if (!Number.isFinite(left)) {
+                throw new UnitError('NOT_FINITE', 'this way of valuing levels is not finite');
+            }
+            pairs++;
+            const step = 10 ** places;
+            seen.add(Math.round(left * step) / step);
+        }
+    }
+    const values = [...seen].sort((x, y) => x - y);
+    return {
+        values,
+        pairs,
+        band: { low: values[0] ?? 0, high: values[values.length - 1] ?? 0 },
+        degeneracy: values.length > 0 ? pairs / values.length : 0,
+    };
+}

package/dist/lattice/scale-lattice.d.ts

@@ -0,0 +1,5 @@
+import { WideMask } from '../debit/masks.ts';
+import type { Lattice } from './lattice.ts';
+import type { Scale, Unit } from './types.ts';
+export declare function fromScale(c: Scale): Lattice<Unit>;
+export declare function subsets(tokens: readonly string[]): Lattice<WideMask>;

package/dist/lattice/scale-lattice.js

@@ -0,0 +1,35 @@
+import { WideMask } from "../debit/masks.js";
+import { entails, fuse, permitAll, state } from "../debit/unit.js";
+export function fromScale(c) {
+    const inhabited = (x) => state(c, x) !== 'CONFLICT';
+    return {
+        top: permitAll(c, ''),
+        bottom: { subject: '', floor: c.levels[c.topIx] ?? '', ceiling: c.levels[c.bottomIx] ?? '' },
+        leq: (a, b) => entails(c, a, b),
+        meet: (a, b) => fuse(c, [a, b]),
+        join: (a, b) => {
+            if (!inhabited(a))
+                return b;
+            if (!inhabited(b))
+                return a;
+            return {
+                subject: a.subject || b.subject,
+                floor: c.levels[c.lower(c.rank(a.floor), c.rank(b.floor))] ?? a.floor,
+                ceiling: c.levels[c.higher(c.rank(a.ceiling), c.rank(b.ceiling))] ?? a.ceiling,
+            };
+        },
+        show: (x) => `[${x.floor}, ${x.ceiling}]`,
+        inhabited,
+    };
+}
+export function subsets(tokens) {
+    return {
+        bottom: new WideMask(tokens.length),
+        top: WideMask.filled(tokens.length),
+        leq: (a, b) => a.subsetOf(b),
+        meet: (a, b) => a.and(b),
+        join: (a, b) => a.or(b),
+        show: (x) => x.members(tokens).join(','),
+        inhabited: (x) => x.size() > 0,
+    };
+}

package/dist/lattice/types.d.ts

@@ -0,0 +1,40 @@
+export type State = 'FREE' | 'REQUIRED' | 'FORBIDDEN' | 'CONFLICT';
+export type DebitOutcome = State | 'REQUIRED_OR_CONFLICT';
+export type Level = number;
+export interface Scale {
+    readonly levels: readonly string[];
+    readonly isLadder: boolean;
+    readonly isSimple: boolean;
+    readonly bottomIx: Level;
+    readonly topIx: Level;
+    readonly bottom: string;
+    readonly top: string;
+    leq(a: Level, b: Level): boolean;
+    higher(a: Level, b: Level): Level;
+    lower(a: Level, b: Level): Level;
+    rank(level: string): Level;
+    stateOf(floor: Level, ceiling: Level): State;
+    joins(): Level[];
+    limits(): Level[];
+    debits(): Level[];
+    intervalHeight(lo: Level, hi: Level): number | null;
+}
+export interface Unit {
+    readonly subject: string;
+    readonly floor: string;
+    readonly ceiling: string;
+}
+export type BoolView = {
+    readonly kind: 'exactly';
+    readonly value: boolean;
+} | {
+    readonly kind: 'lossy';
+    readonly value: boolean;
+    readonly lost: string;
+} | {
+    readonly kind: 'unsayable';
+    readonly lost: string;
+};
+export type Method = 'declared' | 'statistics' | 'sample' | 'exact';
+export type MeasureForm = 'ladder' | 'alphabet' | 'continuous';
+export type Edge = readonly [string, string];

package/dist/lattice/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lattice/vacuity.d.ts

@@ -0,0 +1,22 @@
+import type { Level, Scale } from './types.ts';
+type Valuation = (level: Level) => number;
+export interface Verdict {
+    readonly predicate: string;
+    readonly structure: string;
+    readonly samples: number;
+    readonly yes: number;
+    readonly no: number;
+    readonly verdict: 'CONSTANT' | 'DISCRIMINATES' | 'INDEPENDENT';
+    readonly witnesses?: {
+        readonly yes: readonly number[];
+        readonly no: readonly number[];
+    };
+}
+export interface VacuityOptions {
+    readonly samples?: number;
+    readonly spread?: number;
+    readonly monotone?: boolean;
+}
+export declare function isMonotone(c: Scale, value: Valuation): boolean;
+export declare function vacuityOf(predicate: string, structure: string, c: Scale, test: (c: Scale, value: Valuation) => boolean, opts?: VacuityOptions): Verdict;
+export {};