@lapxo/obligations 0.2.0

package/dist/field/motion.js

@@ -0,0 +1,38 @@
+import { isDistributive } from "../lattice/order.js";
+import { isSupermodular, premium } from "../lattice/price/premium.js";
+import { state, unit } from "../debit/unit.js";
+import { statesPerDebit } from "../debit/unit-span.js";
+import { STATES } from "../debit/vector.js";
+export function declarationOf(c, place) {
+    return place.seen.reduce((held, s) => ({ demand: c.higher(held.demand, s.span.lo), limit: c.lower(held.limit, s.span.hi) }), { demand: c.bottomIx, limit: c.topIx });
+}
+export function unitOf(c, place) {
+    const { demand, limit } = declarationOf(c, place);
+    return unit(place.at.join('/'), { floor: c.levels[demand] ?? c.bottom, ceiling: c.levels[limit] ?? c.top });
+}
+export function stateOf(c, place) {
+    return state(c, unitOf(c, place));
+}
+export function registerOf(c, place) {
+    return statesPerDebit(c, unitOf(c, place));
+}
+export function premiumOf(c, value, place) {
+    const { demand, limit } = declarationOf(c, place);
+    return premium(c, value, demand, limit);
+}
+export function degenerate(c, value) {
+    return isSupermodular(c, value);
+}
+export function withdrawsExactly(c) {
+    return isDistributive(c);
+}
+export function movesOf(c, before, after) {
+    const moves = Object.fromEntries(STATES.map((a) => [a, Object.fromEntries(STATES.map((b) => [b, 0]))]));
+    const was = new Map(registerOf(c, before));
+    for (const [debit, now] of registerOf(c, after)) {
+        const then = was.get(debit);
+        if (then)
+            moves[then][now] += 1;
+    }
+    return moves;
+}

package/dist/field/present.d.ts

@@ -0,0 +1,8 @@
+import type { Point } from './field.ts';
+import type { Interval } from '../lattice/forms.ts';
+export declare function present(place: Point): Interval | 'potential' | null;
+export declare function converge(width: number, maturation: number, forgetting: number, epochs: number): {
+    readonly width: number;
+    readonly trend: 'widens' | 'narrows' | 'holds' | 'zero';
+};
+export declare function endsBeforeNow(now: number, leading: readonly (readonly [number, number])[], lagging: readonly (readonly [number, number])[]): boolean;

package/dist/field/present.js

@@ -0,0 +1,18 @@
+import { meetAt, potential } from "./encounter.js";
+export function present(place) {
+    if (potential(place))
+        return 'potential';
+    const held = meetAt(place);
+    return held.lo > held.hi ? null : held;
+}
+export function converge(width, maturation, forgetting, epochs) {
+    let at = width;
+    for (let epoch = 0; epoch < epochs; epoch += 1)
+        at = Math.max(0, at + maturation - forgetting);
+    return { width: at, trend: at === 0 && width > 0 ? 'zero' : at > width ? 'widens' : at < width ? 'narrows' : 'holds' };
+}
+export function endsBeforeNow(now, leading, lagging) {
+    const ends = [...leading, ...lagging].map(([, hi]) => hi);
+    const end = ends.length ? Math.max(...ends) : 0;
+    return leading.length === 0 && end < now;
+}

package/dist/field/signatures.d.ts

@@ -0,0 +1,6 @@
+import type { Poset } from '../lattice/lattice.ts';
+export declare function foldSigned<T>(L: Poset<T>, values: readonly T[]): {
+    readonly classes: readonly (readonly number[])[];
+    readonly standing: readonly number[];
+    readonly fork: boolean;
+};

package/dist/field/signatures.js

@@ -0,0 +1,19 @@
+import { relate } from "../lattice/lattice.js";
+export function foldSigned(L, values) {
+    const classes = [];
+    for (let i = 0; i < values.length; i++) {
+        const home = classes.find((c) => relate(L, values[c[0]], values[i]) === 'equal');
+        if (home)
+            home.push(i);
+        else
+            classes.push([i]);
+    }
+    const standing = [];
+    for (let c = 0; c < classes.length; c++) {
+        const mine = values[classes[c][0]];
+        const beaten = classes.some((other, o) => o !== c && relate(L, values[other[0]], mine) === 'narrower');
+        if (!beaten)
+            standing.push(c);
+    }
+    return { classes, standing, fork: standing.length > 1 };
+}

package/dist/field/yield.d.ts

@@ -0,0 +1,15 @@
+import type { Scale, Unit } from '../lattice/types.ts';
+export interface Act {
+    readonly by: string;
+    readonly epoch: number;
+    readonly before: Unit;
+    readonly after: Unit;
+}
+export interface Yield {
+    readonly by: string;
+    readonly epoch: number;
+    readonly closed: number;
+    readonly reopened: number;
+    readonly acts: number;
+}
+export declare function yieldOf(c: Scale, acts: readonly Act[]): readonly Yield[];

package/dist/field/yield.js

@@ -0,0 +1,16 @@
+import { freedom } from "../debit/ideal.js";
+export function yieldOf(c, acts) {
+    const by = new Map();
+    for (const act of acts) {
+        const moved = freedom(c, act.before) - freedom(c, act.after);
+        const key = `${act.by} ${act.epoch}`;
+        const held = by.get(key) ?? { by: act.by, epoch: act.epoch, closed: 0, reopened: 0, acts: 0 };
+        by.set(key, {
+            ...held,
+            closed: held.closed + Math.max(moved, 0),
+            reopened: held.reopened + Math.max(-moved, 0),
+            acts: held.acts + 1,
+        });
+    }
+    return [...by.values()].sort((a, b) => (a.by === b.by ? a.epoch - b.epoch : a.by < b.by ? -1 : 1));
+}

package/dist/lattice/axioms.d.ts

@@ -0,0 +1,14 @@
+import type { Lattice, MeetSemilattice, Poset } from './lattice.ts';
+import type { IdealDebit } from '../debit/ideal.ts';
+import type { Scale } from './types.ts';
+export declare const POSET_LAW_NAMES: readonly ["transitivity", "antisymmetry"];
+export declare const MEET_LAW_NAMES: readonly ["idempotence.meet", "unit.top", "top.greatest", "commutativity.meet", "consistency.meet", "associativity.meet"];
+export declare const JOIN_LAW_NAMES: readonly ["idempotence.join", "unit.bottom", "bottom.least", "commutativity.join", "consistency.join", "associativity.join"];
+export declare const BOTH_LAW_NAMES: readonly ["absorption.meet", "absorption.join"];
+export declare const CLOSURE_LAW_NAMES: readonly ["closure.demand", "closure.permit", "closure.meet", "closure.join"];
+export declare const LATTICE_LAW_NAMES: readonly ["transitivity", "antisymmetry", "idempotence.meet", "unit.top", "top.greatest", "commutativity.meet", "consistency.meet", "associativity.meet", "idempotence.join", "unit.bottom", "bottom.least", "commutativity.join", "consistency.join", "associativity.join", "absorption.meet", "absorption.join"];
+export type LatticeLawName = (typeof LATTICE_LAW_NAMES)[number];
+export declare function posetViolationsIn<T>(L: Poset<T>, xs: readonly T[]): readonly string[];
+export declare function meetViolationsIn<T>(L: MeetSemilattice<T>, xs: readonly T[]): readonly string[];
+export declare function violationsIn<T>(L: Lattice<T>, xs: readonly T[]): readonly string[];
+export declare function closureViolationsIn(c: Scale, xs: readonly IdealDebit[]): readonly string[];

package/dist/lattice/axioms.js

@@ -0,0 +1,140 @@
+import { eq } from "./lattice.js";
+import { isDownset, isUpset, idealJoin, idealMeet } from "../debit/ideal.js";
+export const POSET_LAW_NAMES = [
+    'transitivity',
+    'antisymmetry',
+];
+export const MEET_LAW_NAMES = [
+    'idempotence.meet',
+    'unit.top',
+    'top.greatest',
+    'commutativity.meet',
+    'consistency.meet',
+    'associativity.meet',
+];
+export const JOIN_LAW_NAMES = [
+    'idempotence.join',
+    'unit.bottom',
+    'bottom.least',
+    'commutativity.join',
+    'consistency.join',
+    'associativity.join',
+];
+export const BOTH_LAW_NAMES = [
+    'absorption.meet',
+    'absorption.join',
+];
+export const CLOSURE_LAW_NAMES = [
+    'closure.demand',
+    'closure.permit',
+    'closure.meet',
+    'closure.join',
+];
+export const LATTICE_LAW_NAMES = [
+    ...POSET_LAW_NAMES,
+    ...MEET_LAW_NAMES,
+    ...JOIN_LAW_NAMES,
+    ...BOTH_LAW_NAMES,
+];
+const sayAt = (L, law, at) => `${law}: ${at.map((x) => L.show(x)).join(' , ')}`;
+export function posetViolationsIn(L, xs) {
+    const out = [];
+    const same = (a, b) => eq(L, a, b);
+    for (const a of xs) {
+        for (const b of xs) {
+            if (L.leq(a, b) && L.leq(b, a) && !same(a, b)) {
+                out.push(sayAt(L, 'antisymmetry', [a, b]));
+            }
+            for (const d of xs) {
+                if (L.leq(a, b) && L.leq(b, d) && !L.leq(a, d)) {
+                    out.push(sayAt(L, 'transitivity', [a, b, d]));
+                }
+            }
+        }
+    }
+    return out;
+}
+export function meetViolationsIn(L, xs) {
+    const out = [...posetViolationsIn(L, xs)];
+    const same = (a, b) => eq(L, a, b);
+    const say = (law, ...at) => {
+        out.push(sayAt(L, law, at));
+    };
+    for (const a of xs) {
+        if (!same(L.meet(a, a), a))
+            say('idempotence.meet', a);
+        if (!same(L.meet(a, L.top), a))
+            say('unit.top', a);
+        if (!L.leq(a, L.top))
+            say('top.greatest', a);
+        for (const b of xs) {
+            if (!same(L.meet(a, b), L.meet(b, a)))
+                say('commutativity.meet', a, b);
+            const le = L.leq(a, b);
+            if (le !== same(L.meet(a, b), a))
+                say('consistency.meet', a, b);
+            for (const d of xs) {
+                if (!same(L.meet(L.meet(a, b), d), L.meet(a, L.meet(b, d)))) {
+                    say('associativity.meet', a, b, d);
+                }
+            }
+        }
+    }
+    return out;
+}
+export function violationsIn(L, xs) {
+    const out = [...meetViolationsIn(L, xs)];
+    const same = (a, b) => eq(L, a, b);
+    const say = (law, ...at) => {
+        out.push(sayAt(L, law, at));
+    };
+    for (const a of xs) {
+        if (!same(L.join(a, a), a))
+            say('idempotence.join', a);
+        if (!same(L.join(a, L.bottom), a))
+            say('unit.bottom', a);
+        if (!L.leq(L.bottom, a))
+            say('bottom.least', a);
+        for (const b of xs) {
+            if (!same(L.join(a, b), L.join(b, a)))
+                say('commutativity.join', a, b);
+            if (!same(L.meet(a, L.join(a, b)), a))
+                say('absorption.meet', a, b);
+            if (!same(L.join(a, L.meet(a, b)), a))
+                say('absorption.join', a, b);
+            const le = L.leq(a, b);
+            if (le !== same(L.join(a, b), b))
+                say('consistency.join', a, b);
+            for (const d of xs) {
+                if (!same(L.join(L.join(a, b), d), L.join(a, L.join(b, d)))) {
+                    say('associativity.join', a, b, d);
+                }
+            }
+        }
+    }
+    return out;
+}
+export function closureViolationsIn(c, xs) {
+    const out = [];
+    const say = (law, at) => {
+        out.push(`${law}: ${at}`);
+    };
+    const shown = (d) => `{${d.demand.join(',')}}/{${d.permit.join(',')}}`;
+    for (const a of xs) {
+        if (!isUpset(c, a.demand))
+            say('closure.demand', shown(a));
+        if (!isDownset(c, a.permit))
+            say('closure.permit', shown(a));
+        for (const b of xs) {
+            const m = idealMeet(a, b);
+            const j = idealJoin(a, b);
+            if (!isUpset(c, m.demand) || !isDownset(c, m.permit)) {
+                say('closure.meet', `${shown(a)} , ${shown(b)}`);
+            }
+            if (!isUpset(c, j.demand) || !isDownset(c, j.permit)) {
+                say('closure.join', `${shown(a)} , ${shown(b)}`);
+            }
+        }
+    }
+    return out;
+}

package/dist/lattice/declaration.d.ts

@@ -0,0 +1,9 @@
+import type { Level, Scale, Unit } from './types.ts';
+export interface Declaration {
+    readonly demand: Level;
+    readonly limit: Level;
+}
+export declare function declaration(c: Scale, u: Unit): Declaration;
+export declare function asUnit(c: Scale, d: Declaration, subject?: string): Unit;
+export declare function conj(c: Scale, a: Declaration, b: Declaration): Declaration;
+export declare function disj(c: Scale, a: Declaration, b: Declaration): Declaration;

package/dist/lattice/declaration.js

@@ -0,0 +1,12 @@
+export function declaration(c, u) {
+    return { demand: c.rank(u.floor), limit: c.rank(u.ceiling) };
+}
+export function asUnit(c, d, subject = '') {
+    return { subject, floor: c.levels[d.demand], ceiling: c.levels[d.limit] };
+}
+export function conj(c, a, b) {
+    return { demand: c.higher(a.demand, b.demand), limit: c.lower(a.limit, b.limit) };
+}
+export function disj(c, a, b) {
+    return { demand: c.lower(a.demand, b.demand), limit: c.higher(a.limit, b.limit) };
+}

package/dist/lattice/errors.d.ts

@@ -0,0 +1,6 @@
+export type UnitErrorCode = 'UNKNOWN_LEVEL' | 'MALFORMED' | 'EMPTY_CHAIN' | 'DUPLICATE_LEVEL' | 'NOT_FINITE' | 'UNKNOWN_ROW';
+export declare class UnitError extends Error {
+    readonly code: UnitErrorCode;
+    readonly detail: Readonly<Record<string, unknown>>;
+    constructor(code: UnitErrorCode, message: string, detail?: Record<string, unknown>);
+}

package/dist/lattice/errors.js

@@ -0,0 +1,11 @@
+export class UnitError extends Error {
+    code;
+    detail;
+    constructor(code, message, detail = {}) {
+        super(message);
+        this.name = 'UnitError';
+        this.code = code;
+        this.detail = Object.freeze({ ...detail });
+        Object.setPrototypeOf(this, UnitError.prototype);
+    }
+}

package/dist/lattice/forms.d.ts

@@ -0,0 +1,38 @@
+import type { Lattice, Poset } from './lattice.ts';
+import { WideMask } from '../debit/masks.ts';
+import type { Unit } from './types.ts';
+export interface Interval {
+    readonly lo: number;
+    readonly hi: number;
+}
+export declare function intervals(lo: number, hi: number): Lattice<Interval>;
+export interface Alphabet {
+    readonly polarity: 'permit' | 'forbid';
+    readonly values: ReadonlySet<string>;
+}
+export declare function alphabets(): Poset<Alphabet>;
+export type FormCount = {
+    readonly kind: 'finite';
+    readonly n: number;
+} | {
+    readonly kind: 'refused';
+    readonly why: string;
+};
+export interface Form<T = unknown> {
+    readonly id: string;
+    lattice(params: unknown): Lattice<T>;
+    parse(params: unknown, demand: unknown): T;
+    emit(params: unknown, value: T): unknown;
+    count(folded: T, params?: unknown): FormCount;
+    show(value: T): string;
+    points(params: unknown, seed: number, n: number): readonly T[];
+}
+export declare const ladderForm: Form<Unit>;
+export declare const alphabetForm: Form<WideMask>;
+export declare const continuousForm: Form<{
+    lo: number;
+    hi: number;
+}>;
+export declare const latticeForm: Form<Unit>;
+export declare const FORM_IMPLEMENTATIONS: ReadonlyArray<Form>;
+export declare const FORMS: Form<unknown>[];

package/dist/lattice/forms.js

@@ -0,0 +1,198 @@
+import { WideMask } from "../debit/masks.js";
+import { fromScale, subsets } from "./scale-lattice.js";
+import { chain, order } from "./order.js";
+export function intervals(lo, hi) {
+    const low = Math.min(lo, hi);
+    const high = Math.max(lo, hi);
+    return {
+        bottom: { lo: high, hi: low },
+        top: { lo: low, hi: high },
+        leq(a, b) {
+            if (a.lo > a.hi)
+                return true;
+            if (b.lo > b.hi)
+                return false;
+            return b.lo <= a.lo && a.hi <= b.hi;
+        },
+        meet(a, b) {
+            return { lo: Math.max(a.lo, b.lo), hi: Math.min(a.hi, b.hi) };
+        },
+        join(a, b) {
+            if (a.lo > a.hi)
+                return b;
+            if (b.lo > b.hi)
+                return a;
+            return { lo: Math.min(a.lo, b.lo), hi: Math.max(a.hi, b.hi) };
+        },
+        show(x) {
+            return x.lo > x.hi ? 'empty' : `${x.lo}..${x.hi}`;
+        },
+        inhabited(x) {
+            return x.lo <= x.hi;
+        },
+    };
+}
+export function alphabets() {
+    const within = (x, y) => [...x].every((v) => y.has(v));
+    return {
+        leq(a, b) {
+            if (a.polarity === 'permit' && b.polarity === 'permit')
+                return within(a.values, b.values);
+            if (a.polarity === 'forbid' && b.polarity === 'forbid')
+                return within(b.values, a.values);
+            if (a.polarity === 'permit')
+                return [...a.values].every((v) => !b.values.has(v));
+            return false;
+        },
+        show(x) {
+            return `${x.polarity === 'forbid' ? 'not:' : ''}${[...x.values].sort().join('|')}`;
+        },
+    };
+}
+function form(f) {
+    const held = { lattice: f.lattice, parse: f.parse, emit: f.emit, count: f.count, show: f.show, points: f.points };
+    const lacking = Object.entries(held).find(([, fn]) => typeof fn !== 'function');
+    if (lacking)
+        throw new Error(`form \`${f.id}\` declared no ${lacking[0]}`);
+    return f;
+}
+const rec = (x) => x !== null && typeof x === 'object' ? x : {};
+function strings(x) {
+    return Array.isArray(x) ? x.map(String) : [];
+}
+const drawn = (seed) => {
+    let s = seed >>> 0;
+    return () => {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = Math.imul(s ^ (s >>> 15), s | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+};
+const picked = (draw, xs) => xs[Math.floor(draw() * xs.length)];
+function bandCount(levels, folded) {
+    if (levels.length === 0)
+        return { kind: 'refused', why: 'a ladder with no levels cannot be counted' };
+    const c = chain(levels);
+    const f = c.rank(folded.floor);
+    const cl = c.rank(folded.ceiling);
+    if (!c.leq(f, cl))
+        return { kind: 'finite', n: 0 };
+    const n = levels.filter((_, i) => c.leq(f, i) && c.leq(i, cl)).length;
+    return { kind: 'finite', n };
+}
+const BAND = {
+    parse(params, demand) {
+        const L = this.lattice(params);
+        const d = rec(demand);
+        return {
+            subject: String(d.subject ?? ''),
+            floor: String(d.floor ?? L.top.floor),
+            ceiling: String(d.ceiling ?? L.top.ceiling),
+        };
+    },
+    emit(_params, value) {
+        return { subject: value.subject, floor: value.floor, ceiling: value.ceiling };
+    },
+    count(folded, params) {
+        return bandCount(strings(rec(params).levels), folded);
+    },
+    points(params, seed, n) {
+        const L = this.lattice(params);
+        const levels = strings(rec(params).levels);
+        const draw = drawn(seed);
+        const band = (floor, ceiling) => ({ subject: '', floor, ceiling });
+        return Array.from({ length: n }, () => {
+            const [a, b] = [picked(draw, levels), picked(draw, levels)];
+            return [band(a, b), band(b, a)].find((x) => L.inhabited(x)) ?? band(a, a);
+        });
+    },
+};
+export const ladderForm = form({
+    id: 'ladder',
+    lattice(params) {
+        const levels = strings(rec(params).levels);
+        if (levels.length === 0)
+            throw new Error('ladder needs levels');
+        return fromScale(chain(levels));
+    },
+    ...BAND,
+    show(value) {
+        return value.floor === value.ceiling ? value.floor : `${value.floor}..${value.ceiling}`;
+    },
+});
+export const alphabetForm = form({
+    id: 'alphabet',
+    lattice(params) {
+        return subsets(strings(rec(params).tokens));
+    },
+    parse(params, demand) {
+        const tokens = strings(rec(params).tokens);
+        const d = rec(demand);
+        const want = d.want !== undefined ? strings(d.want) : tokens;
+        return WideMask.fromTokens(tokens, new Set(want));
+    },
+    emit(params, value) {
+        return { want: value.members(strings(rec(params).tokens)) };
+    },
+    count(folded) {
+        return { kind: 'finite', n: folded.size() };
+    },
+    show(value) {
+        return `${value.size()}`;
+    },
+    points(params, seed, n) {
+        const tokens = strings(rec(params).tokens);
+        const draw = drawn(seed);
+        return Array.from({ length: n }, () => WideMask.fromTokens(tokens, new Set(tokens.filter(() => draw() < 0.5))));
+    },
+});
+export const continuousForm = form({
+    id: 'continuous',
+    lattice(params) {
+        const p = rec(params);
+        return intervals(Number(p.lo ?? 0), Number(p.hi ?? 1));
+    },
+    parse(params, demand) {
+        const L = this.lattice(params);
+        const d = rec(demand);
+        return {
+            lo: d.lo === undefined ? L.top.lo : Number(d.lo),
+            hi: d.hi === undefined ? L.top.hi : Number(d.hi),
+        };
+    },
+    emit(_params, value) {
+        return { lo: value.lo, hi: value.hi };
+    },
+    count() {
+        return { kind: 'refused', why: 'a continuous band has no count; prefer not to exist over inventing one' };
+    },
+    show(value) {
+        return value.lo > value.hi ? 'empty' : `${value.lo}..${value.hi}`;
+    },
+    points(params, seed, n) {
+        const p = rec(params);
+        const lo = Number(p.lo ?? 0);
+        const hi = Number(p.hi ?? 1);
+        const draw = drawn(seed);
+        const at = () => lo + Math.round(draw() * (hi - lo));
+        return Array.from({ length: n }, () => ({ lo: at(), hi: at() }));
+    },
+});
+export const latticeForm = form({
+    id: 'lattice',
+    lattice(params) {
+        const p = rec(params);
+        const levels = strings(p.levels);
+        const leq = p.leq;
+        if (levels.length && leq)
+            return fromScale(order(levels, leq));
+        throw new Error('lattice needs levels+leq');
+    },
+    ...BAND,
+    show(value) {
+        return `${value.floor}..${value.ceiling}`;
+    },
+});
+export const FORM_IMPLEMENTATIONS = [ladderForm, alphabetForm, continuousForm, latticeForm];
+export const FORMS = [...FORM_IMPLEMENTATIONS];

package/dist/lattice/index.d.ts

@@ -0,0 +1,45 @@
+export { UnitError } from './errors.ts';
+export type { UnitErrorCode } from './errors.ts';
+export { BOOLEAN, chain, height, isDistributive, order } from './order.ts';
+export { asBoolean, bitLoss, compose, composeState, fuse, widen, conflictDebits, anyOf, missing, entails, permitAll, state, statesPerDebit, table, unit } from '../debit/unit.ts';
+export { WIDTH, and, or, canonical } from '../debit/packed.ts';
+export type { Packed, Packer } from '../debit/packed.ts';
+export { WideMask, chunkCount } from '../debit/masks.ts';
+export { rebuild, register } from '../debit/register.ts';
+export type { Register } from '../debit/register.ts';
+export { DANGEROUS, STATES, dangerous, moved, quadrants, runQuadrants, sizes, stateAt, transitions } from '../debit/vector.ts';
+export type { Matrix, Quadrants, Run, Span } from '../debit/vector.ts';
+export { METHODS, weakest } from '../debit/provenance.ts';
+export { touches, holds } from '../debit/standing.ts';
+export { declaration, asUnit, conj, disj } from './declaration.ts';
+export type { Declaration } from './declaration.ts';
+export { relate } from './lattice.ts';
+export type { Poset, MeetSemilattice, JoinSemilattice, Lattice, Relation } from './lattice.ts';
+export { intervals, alphabets } from './forms.ts';
+export type { Interval, Alphabet } from './forms.ts';
+export { foldIn, witnessesIn } from '../debit/debit.ts';
+export { foldSigned } from '../field/signatures.ts';
+export { size, sufficientResolution } from '../field/field.ts';
+export { present, converge, endsBeforeNow } from '../field/present.ts';
+export { yieldOf } from '../field/yield.ts';
+export type { Act, Yield } from '../field/yield.ts';
+export { frontier } from '../field/frontier.ts';
+export type { Asked, Open } from '../field/frontier.ts';
+export { declarationOf, unitOf, stateOf, registerOf, premiumOf, degenerate, withdrawsExactly, movesOf } from '../field/motion.ts';
+export { violationsIn, meetViolationsIn, posetViolationsIn, closureViolationsIn, LATTICE_LAW_NAMES, POSET_LAW_NAMES, MEET_LAW_NAMES, JOIN_LAW_NAMES, BOTH_LAW_NAMES, CLOSURE_LAW_NAMES, } from './axioms.ts';
+export type { LatticeLawName } from './axioms.ts';
+export { fromScale, subsets } from './scale-lattice.ts';
+export { downset, freedom, fromIdeals, idealComplexity, idealDebit, idealEntails, idealJoin, idealMeet, isDownset, isIdealPair, isUpset, unitToIdeal, upset } from '../debit/ideal.ts';
+export type { IdealDebit } from '../debit/ideal.ts';
+export { FORM_IMPLEMENTATIONS, FORMS, ladderForm, alphabetForm, continuousForm, latticeForm } from './forms.ts';
+export type { Form, FormCount } from './forms.ts';
+export { buildGraph, reachIds } from '../debit/graph.ts';
+export type { Graph } from '../debit/graph.ts';
+export { isMonotone, vacuityOf } from './vacuity.ts';
+export type { Verdict, VacuityOptions } from './vacuity.ts';
+export { permute, permutationBlind, unitStream } from '../debit/shuffle.ts';
+export type { BoolView, Scale, Edge, Level, Method, MeasureForm, DebitOutcome, State, Unit, } from './types.ts';
+export { answers, coarsen, coordinate, contracts, covers, exclusive, foldRegion, key, outranks, passes, point, region, resolution, retracted, verified, within } from '../field/field.ts';
+export { disagree, latest, meetAt, origins, potential, turned } from '../field/encounter.ts';
+export type { Fold, Point, Region, Sighting } from '../field/field.ts';
+export { replay } from '../replay.ts';

package/dist/lattice/index.js

@@ -0,0 +1,29 @@
+export { UnitError } from "./errors.js";
+export { BOOLEAN, chain, height, isDistributive, order } from "./order.js";
+export { asBoolean, bitLoss, compose, composeState, fuse, widen, conflictDebits, anyOf, missing, entails, permitAll, state, statesPerDebit, table, unit } from "../debit/unit.js";
+export { WIDTH, and, or, canonical } from "../debit/packed.js";
+export { WideMask, chunkCount } from "../debit/masks.js";
+export { rebuild, register } from "../debit/register.js";
+export { DANGEROUS, STATES, dangerous, moved, quadrants, runQuadrants, sizes, stateAt, transitions } from "../debit/vector.js";
+export { METHODS, weakest } from "../debit/provenance.js";
+export { touches, holds } from "../debit/standing.js";
+export { declaration, asUnit, conj, disj } from "./declaration.js";
+export { relate } from "./lattice.js";
+export { intervals, alphabets } from "./forms.js";
+export { foldIn, witnessesIn } from "../debit/debit.js";
+export { foldSigned } from "../field/signatures.js";
+export { size, sufficientResolution } from "../field/field.js";
+export { present, converge, endsBeforeNow } from "../field/present.js";
+export { yieldOf } from "../field/yield.js";
+export { frontier } from "../field/frontier.js";
+export { declarationOf, unitOf, stateOf, registerOf, premiumOf, degenerate, withdrawsExactly, movesOf } from "../field/motion.js";
+export { violationsIn, meetViolationsIn, posetViolationsIn, closureViolationsIn, LATTICE_LAW_NAMES, POSET_LAW_NAMES, MEET_LAW_NAMES, JOIN_LAW_NAMES, BOTH_LAW_NAMES, CLOSURE_LAW_NAMES, } from "./axioms.js";
+export { fromScale, subsets } from "./scale-lattice.js";
+export { downset, freedom, fromIdeals, idealComplexity, idealDebit, idealEntails, idealJoin, idealMeet, isDownset, isIdealPair, isUpset, unitToIdeal, upset } from "../debit/ideal.js";
+export { FORM_IMPLEMENTATIONS, FORMS, ladderForm, alphabetForm, continuousForm, latticeForm } from "./forms.js";
+export { buildGraph, reachIds } from "../debit/graph.js";
+export { isMonotone, vacuityOf } from "./vacuity.js";
+export { permute, permutationBlind, unitStream } from "../debit/shuffle.js";
+export { answers, coarsen, coordinate, contracts, covers, exclusive, foldRegion, key, outranks, passes, point, region, resolution, retracted, verified, within } from "../field/field.js";
+export { disagree, latest, meetAt, origins, potential, turned } from "../field/encounter.js";
+export { replay } from "../replay.js";

package/dist/lattice/lattice.d.ts

@@ -0,0 +1,18 @@
+export interface Poset<T> {
+    leq(a: T, b: T): boolean;
+    show(x: T): string;
+}
+export interface MeetSemilattice<T> extends Poset<T> {
+    readonly top: T;
+    meet(a: T, b: T): T;
+    inhabited(x: T): boolean;
+}
+export interface JoinSemilattice<T> extends Poset<T> {
+    readonly bottom: T;
+    join(a: T, b: T): T;
+}
+export interface Lattice<T> extends MeetSemilattice<T>, JoinSemilattice<T> {
+}
+export declare function eq<T>(L: Poset<T>, a: T, b: T): boolean;
+export type Relation = 'equal' | 'narrower' | 'wider' | 'incomparable';
+export declare function relate<T>(L: Poset<T>, a: T, b: T): Relation;