@lapxo/obligations 0.2.0

package/dist/debit/register.d.ts

@@ -0,0 +1,7 @@
+import type { Scale, Unit } from '../lattice/types.ts';
+export interface Register {
+    readonly demanded: readonly string[];
+    readonly limiting: readonly string[];
+}
+export declare function register(c: Scale, u: Unit): Register;
+export declare function rebuild(c: Scale, reg: Register, subject?: string): Unit;

package/dist/debit/register.js

@@ -0,0 +1,17 @@
+export function register(c, u) {
+    const f = c.rank(u.floor);
+    const cl = c.rank(u.ceiling);
+    return {
+        demanded: c.joins().filter((j) => c.leq(j, f)).map((j) => c.levels[j]),
+        limiting: c.limits().filter((m) => c.leq(cl, m)).map((m) => c.levels[m]),
+    };
+}
+export function rebuild(c, reg, subject = '') {
+    let floor = c.bottomIx;
+    for (const name of reg.demanded)
+        floor = c.higher(floor, c.rank(name));
+    let ceiling = c.topIx;
+    for (const name of reg.limiting)
+        ceiling = c.lower(ceiling, c.rank(name));
+    return { subject, floor: c.levels[floor], ceiling: c.levels[ceiling] };
+}

package/dist/debit/shuffle.d.ts

@@ -0,0 +1,3 @@
+export declare function unitStream(seed: number): () => number;
+export declare function permute<T>(xs: readonly T[], salt: number): T[];
+export declare function permutationBlind<T, R>(values: readonly T[], claim: (xs: readonly T[]) => R, draws?: number): boolean;

package/dist/debit/shuffle.js

@@ -0,0 +1,30 @@
+function stream(seed) {
+    let s = (Math.imul(seed + 1, 2654435761) ^ 0x5f3759df) >>> 0;
+    return () => {
+        s = (Math.imul(s, 1664525) + 1013904223) >>> 0;
+        return s;
+    };
+}
+export function unitStream(seed) {
+    const next = stream(seed);
+    return () => next() / 4294967296;
+}
+export function permute(xs, salt) {
+    const next = stream(salt);
+    const out = xs.slice();
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = next() % (i + 1);
+        const t = out[i];
+        out[i] = out[j];
+        out[j] = t;
+    }
+    return out;
+}
+export function permutationBlind(values, claim, draws = 8) {
+    const want = JSON.stringify(claim(values));
+    for (let d = 0; d < draws; d++) {
+        if (JSON.stringify(claim(permute(values, d + 1))) !== want)
+            return false;
+    }
+    return true;
+}

package/dist/debit/standing.d.ts

@@ -0,0 +1,3 @@
+import type { Scale, Unit } from '../lattice/types.ts';
+export declare function touches(c: Scale, mine: Unit, folded: Unit): boolean;
+export declare function holds(c: Scale, units: readonly Unit[], index: number): boolean;

package/dist/debit/standing.js

@@ -0,0 +1,12 @@
+import { fuse } from "./unit.js";
+export function touches(c, mine, folded) {
+    return c.rank(mine.floor) === c.rank(folded.floor) || c.rank(mine.ceiling) === c.rank(folded.ceiling);
+}
+export function holds(c, units, index) {
+    if (index < 0 || index >= units.length)
+        return false;
+    const whole = fuse(c, units);
+    const rest = units.filter((_, i) => i !== index);
+    const next = fuse(c, rest);
+    return next.floor !== whole.floor || next.ceiling !== whole.ceiling;
+}

package/dist/debit/unit-span.d.ts

@@ -0,0 +1,8 @@
+import type { Scale, State, Unit } from '../lattice/types.ts';
+export declare function statesPerDebit(c: Scale, u: Unit): [string, State][];
+export declare function anyOf(c: Scale, units: readonly Unit[]): Unit[];
+export declare function missing(c: Scale, have: Unit, want: Unit): {
+    raiseFloorTo: string[];
+    raiseCeilingTo: string[];
+};
+export declare function complexity(c: Scale, u: Unit): number;

package/dist/debit/unit-span.js

@@ -0,0 +1,63 @@
+import { unitComplexity } from "./ideal.js";
+export function statesPerDebit(c, u) {
+    const f = c.rank(u.floor);
+    const cl = c.rank(u.ceiling);
+    return c.joins().map((j) => {
+        const demanded = c.leq(j, f);
+        const permitted = c.leq(j, cl);
+        return [
+            c.levels[j],
+            demanded ? (permitted ? 'REQUIRED' : 'CONFLICT') : permitted ? 'FREE' : 'FORBIDDEN',
+        ];
+    });
+}
+export function anyOf(c, units) {
+    const rank = (u) => [c.rank(u.floor), c.rank(u.ceiling)];
+    const holds = (f, cl, l) => c.leq(f, l) && c.leq(l, cl);
+    const levels = [...c.levels.keys()];
+    let live = units.filter((u) => {
+        const [f, cl] = rank(u);
+        return c.leq(f, cl);
+    });
+    for (let changed = true; changed;) {
+        changed = false;
+        outer: for (let i = 0; i < live.length; i++) {
+            for (let j = i + 1; j < live.length; j++) {
+                const [af, ac] = rank(live[i]);
+                const [bf, bc] = rank(live[j]);
+                const lo = c.lower(af, bf);
+                const hi = c.higher(ac, bc);
+                const gains = levels.some((l) => holds(lo, hi, l) && !holds(af, ac, l) && !holds(bf, bc, l));
+                if (gains)
+                    continue;
+                live = [
+                    ...live.filter((_, k) => k !== i && k !== j),
+                    { subject: live[i].subject, floor: c.levels[lo], ceiling: c.levels[hi] },
+                ];
+                changed = true;
+                break outer;
+            }
+        }
+    }
+    return live.sort((x, y) => {
+        const [xf, xc] = rank(x);
+        const [yf, yc] = rank(y);
+        return xf - yf || xc - yc;
+    });
+}
+export function missing(c, have, want) {
+    const [hf, hc] = [c.rank(have.floor), c.rank(have.ceiling)];
+    const [wf, wc] = [c.rank(want.floor), c.rank(want.ceiling)];
+    const all = [...c.levels.keys()];
+    const weakestOf = (works) => {
+        const ok = all.filter(works);
+        return ok.filter((l) => !ok.some((o) => o !== l && c.leq(o, l))).map((l) => c.levels[l]);
+    };
+    return {
+        raiseFloorTo: c.leq(wf, hf) ? [] : weakestOf((l) => c.leq(wf, c.higher(hf, l))),
+        raiseCeilingTo: c.leq(wc, hc) ? [] : weakestOf((l) => c.leq(wc, c.higher(hc, l))),
+    };
+}
+export function complexity(c, u) {
+    return unitComplexity(c, u);
+}

package/dist/debit/unit.d.ts

@@ -0,0 +1,22 @@
+import type { BoolView, DebitOutcome, Scale, State, Unit } from '../lattice/types.ts';
+export declare function unit(subject: string, bounds: {
+    floor: string;
+    ceiling: string;
+}): Unit;
+export declare const permitAll: (c: Scale, subject: string) => Unit;
+export declare function state(c: Scale, u: Unit): State;
+export declare function asBoolean(c: Scale, u: Unit): BoolView;
+export declare function bitLoss(c: Scale): {
+    readonly possible: number;
+    readonly exactly: number;
+    readonly lossy: number;
+    readonly unsayable: number;
+};
+export declare function compose(c: Scale, units: readonly Unit[]): Unit;
+export declare function fuse(c: Scale, units: readonly Unit[]): Unit;
+export declare function composeState(c: Scale, units: readonly Unit[]): State;
+export declare function table(a: State, b: State): DebitOutcome;
+export declare function conflictDebits(c: Scale, u: Unit): number;
+export declare function entails(c: Scale, a: Unit, b: Unit): boolean;
+export declare function widen(c: Scale, units: readonly Unit[]): Unit;
+export { anyOf, missing, statesPerDebit, complexity } from './unit-span.ts';

package/dist/debit/unit.js

@@ -0,0 +1,110 @@
+import { UnitError } from "../lattice/errors.js";
+export function unit(subject, bounds) {
+    return { subject, floor: bounds.floor, ceiling: bounds.ceiling };
+}
+export const permitAll = (c, subject) => unit(subject, { floor: c.bottom, ceiling: c.top });
+export function state(c, u) {
+    return c.stateOf(c.rank(u.floor), c.rank(u.ceiling));
+}
+export function asBoolean(c, u) {
+    const s = state(c, u);
+    if (s === 'CONFLICT') {
+        return {
+            kind: 'unsayable',
+            lost: 'a boolean has no way to say two promises cannot both hold, so a ' +
+                'register of booleans settles it by precedence instead',
+        };
+    }
+    if (s === 'REQUIRED') {
+        return {
+            kind: 'lossy',
+            value: true,
+            lost: 'the floor: a boolean says may, never must, so nothing records that ' +
+                'somebody depends on this',
+        };
+    }
+    if (s === 'FORBIDDEN') {
+        return c.rank(u.ceiling) === c.bottomIx
+            ? { kind: 'exactly', value: false }
+            : { kind: 'lossy', value: true, lost: 'the ceiling: a boolean cannot say how far' };
+    }
+    return { kind: 'exactly', value: true };
+}
+export function bitLoss(c) {
+    let exactly = 0;
+    let lossy = 0;
+    let unsayable = 0;
+    let possible = 0;
+    for (const floor of c.levels) {
+        for (const ceiling of c.levels) {
+            possible++;
+            const k = asBoolean(c, { subject: '', floor, ceiling }).kind;
+            if (k === 'exactly')
+                exactly++;
+            else if (k === 'lossy')
+                lossy++;
+            else
+                unsayable++;
+        }
+    }
+    return { possible, exactly, lossy, unsayable };
+}
+export function compose(c, units) {
+    for (const u of units) {
+        if (!c.leq(c.rank(u.floor), c.rank(u.ceiling))) {
+            throw new UnitError('MALFORMED', `\`${u.subject}\` cannot be met by anything`, {
+                subject: u.subject,
+                floor: u.floor,
+                ceiling: u.ceiling,
+            });
+        }
+    }
+    return fuse(c, units);
+}
+function band(c, units, from, onFloor, onCeiling) {
+    let floor = from.floor;
+    let ceiling = from.ceiling;
+    for (const u of units) {
+        floor = onFloor(floor, c.rank(u.floor));
+        ceiling = onCeiling(ceiling, c.rank(u.ceiling));
+    }
+    return { subject: units[0].subject, floor: c.levels[floor], ceiling: c.levels[ceiling] };
+}
+export function fuse(c, units) {
+    if (units.length === 0)
+        return permitAll(c, '');
+    return band(c, units, { floor: c.bottomIx, ceiling: c.topIx }, (a, b) => c.higher(a, b), (a, b) => c.lower(a, b));
+}
+export function composeState(c, units) {
+    const u = compose(c, units);
+    return c.stateOf(c.rank(u.floor), c.rank(u.ceiling));
+}
+const ORDER = ['FREE', 'REQUIRED', 'FORBIDDEN', 'CONFLICT'];
+const RoC = 'REQUIRED_OR_CONFLICT';
+const TABLE = [
+    ['FREE', 'REQUIRED', 'FORBIDDEN', 'CONFLICT'],
+    ['REQUIRED', RoC, RoC, 'CONFLICT'],
+    ['FORBIDDEN', RoC, 'FORBIDDEN', 'CONFLICT'],
+    ['CONFLICT', 'CONFLICT', 'CONFLICT', 'CONFLICT'],
+];
+export function table(a, b) {
+    return TABLE[ORDER.indexOf(a)][ORDER.indexOf(b)];
+}
+export function conflictDebits(c, u) {
+    const f = c.rank(u.floor);
+    const cl = c.rank(u.ceiling);
+    if (c.leq(f, cl))
+        return 0;
+    return c.joins().filter((j) => c.leq(j, f) && !c.leq(j, cl)).length;
+}
+export function entails(c, a, b) {
+    const [af, ac] = [c.rank(a.floor), c.rank(a.ceiling)];
+    const [bf, bc] = [c.rank(b.floor), c.rank(b.ceiling)];
+    return c.leq(bf, af) && c.leq(ac, bc);
+}
+export function widen(c, units) {
+    if (units.length === 0)
+        return { subject: '', floor: c.levels[c.topIx], ceiling: c.levels[c.bottomIx] };
+    return band(c, units, { floor: c.topIx, ceiling: c.bottomIx }, (a, b) => c.lower(a, b), (a, b) => c.higher(a, b));
+}
+export { anyOf, missing, statesPerDebit, complexity } from "./unit-span.js";

package/dist/debit/vector-move.d.ts

@@ -0,0 +1,12 @@
+import type { State } from '../lattice/types.ts';
+type Quadrants = import('./vector.ts').Quadrants;
+export type Matrix = Readonly<Record<State, Readonly<Record<State, number>>>>;
+export declare const DANGEROUS: readonly (readonly [State, State])[];
+export declare function transitions(before: Quadrants, after: Quadrants, width: number): Matrix;
+export declare function dangerous(m: Matrix): readonly {
+    from: State;
+    to: State;
+    n: number;
+}[];
+export declare function moved(m: Matrix): number;
+export {};

package/dist/debit/vector-move.js

@@ -0,0 +1,48 @@
+const STATES = ['REQUIRED', 'FREE', 'FORBIDDEN', 'CONFLICT'];
+function findWithin(runs, s) {
+    let n = 0;
+    for (const r of runs)
+        if (r.within)
+            n += r.within[s];
+    return n;
+}
+export const DANGEROUS = STATES.filter((s) => s !== 'CONFLICT').map((s) => [s, 'CONFLICT']);
+const zero = () => {
+    const m = {};
+    for (const a of STATES) {
+        m[a] = {};
+        for (const b of STATES)
+            m[a][b] = 0;
+    }
+    return m;
+};
+export function transitions(before, after, width) {
+    const at = (q, bit) => {
+        for (const s of STATES)
+            if (q[s].has(bit))
+                return s;
+        return null;
+    };
+    const m = zero();
+    for (let bit = 0; bit < width; bit++) {
+        const a = at(before, bit);
+        const b = at(after, bit);
+        if (a === null || b === null)
+            continue;
+        m[a][b] += 1;
+    }
+    return m;
+}
+export function dangerous(m) {
+    return DANGEROUS
+        .map(([from, to]) => ({ from, to, n: m[from][to] }))
+        .filter((x) => x.n > 0);
+}
+export function moved(m) {
+    let n = 0;
+    for (const a of STATES)
+        for (const b of STATES)
+            if (a !== b)
+                n += m[a][b];
+    return n;
+}

package/dist/debit/vector.d.ts

@@ -0,0 +1,26 @@
+import { WideMask } from './masks.ts';
+import type { State } from '../lattice/types.ts';
+export declare const STATES: readonly ["REQUIRED", "FREE", "FORBIDDEN", "CONFLICT"];
+export interface Quadrants {
+    readonly REQUIRED: WideMask;
+    readonly FREE: WideMask;
+    readonly FORBIDDEN: WideMask;
+    readonly CONFLICT: WideMask;
+}
+export declare function quadrants(demanded: WideMask, permitted: WideMask, extent: WideMask): Quadrants;
+export declare function sizes(q: Quadrants): Readonly<Record<State, number>>;
+export declare function stateAt(q: Quadrants, bit: number): State | null;
+export interface Run {
+    readonly lo: number;
+    readonly hi: number;
+    readonly state: State;
+    readonly coalesced?: number;
+    readonly within?: Readonly<Record<State, number>>;
+}
+export interface Span {
+    readonly lo: number;
+    readonly hi: number;
+}
+export declare function runQuadrants(demanded: readonly Span[], permitted: Span | null, extent: Span): readonly Run[];
+export type { Matrix } from './vector-move.ts';
+export { DANGEROUS, dangerous, moved, transitions } from './vector-move.ts';

package/dist/debit/vector.js

@@ -0,0 +1,68 @@
+import { WideMask } from "./masks.js";
+export const STATES = ['REQUIRED', 'FREE', 'FORBIDDEN', 'CONFLICT'];
+export function quadrants(demanded, permitted, extent) {
+    const d = demanded.and(extent);
+    const p = permitted.and(extent);
+    return {
+        REQUIRED: d.and(p),
+        FREE: p.difference(d),
+        FORBIDDEN: extent.difference(p).difference(d),
+        CONFLICT: d.difference(p),
+    };
+}
+export function sizes(q) {
+    return {
+        REQUIRED: q.REQUIRED.size(),
+        FREE: q.FREE.size(),
+        FORBIDDEN: q.FORBIDDEN.size(),
+        CONFLICT: q.CONFLICT.size(),
+    };
+}
+export function stateAt(q, bit) {
+    for (const s of STATES)
+        if (q[s].has(bit))
+            return s;
+    return null;
+}
+const overlaps = (a, x) => x >= a.lo && x <= a.hi;
+export function runQuadrants(demanded, permitted, extent) {
+    if (extent.hi < extent.lo)
+        return [];
+    const cuts = new Set([extent.lo]);
+    const add = (s) => {
+        if (s.lo > extent.lo && s.lo <= extent.hi)
+            cuts.add(s.lo);
+        if (s.hi >= extent.lo && s.hi < extent.hi)
+            cuts.add(s.hi + 1);
+    };
+    for (const s of demanded)
+        add(s);
+    if (permitted)
+        add(permitted);
+    const at = (x) => {
+        const d = demanded.some((s) => overlaps(s, x));
+        const p = permitted !== null && overlaps(permitted, x);
+        if (d && p)
+            return 'REQUIRED';
+        if (d)
+            return 'CONFLICT';
+        return p ? 'FREE' : 'FORBIDDEN';
+    };
+    const points = [...cuts].sort((a, b) => a - b);
+    const out = [];
+    for (let i = 0; i < points.length; i++) {
+        const lo = points[i];
+        const hi = i + 1 < points.length ? points[i + 1] - 1 : extent.hi;
+        if (hi < lo)
+            continue;
+        const state = at(lo);
+        const last = out[out.length - 1];
+        if (last && last.state === state && last.hi + 1 === lo) {
+            out[out.length - 1] = { lo: last.lo, hi, state };
+            continue;
+        }
+        out.push({ lo, hi, state });
+    }
+    return out;
+}
+export { DANGEROUS, dangerous, moved, transitions } from "./vector-move.js";

package/dist/field/encounter.d.ts

@@ -0,0 +1,9 @@
+import type { Point, Sighting } from './field.ts';
+import type { Interval } from '../lattice/forms.ts';
+export declare function origins(place: Point): number;
+export declare function potential(place: Point): boolean;
+export declare function disagree(place: Point): readonly [Sighting, Sighting] | null;
+export declare function meetAt(place: Point): Interval;
+export declare function latest(places: readonly Point[]): Point | null;
+export declare function verdict(place: Point): string;
+export declare function turned(before: readonly Point[], after: readonly Point[]): readonly Point[];

package/dist/field/encounter.js

@@ -0,0 +1,36 @@
+import { witnessesIn } from "../debit/debit.js";
+import { key } from "./field.js";
+import { intervals } from "../lattice/forms.js";
+const spanning = (spans) => intervals(Math.min(...spans.map((one) => one.lo)), Math.max(...spans.map((one) => one.hi)));
+export function origins(place) {
+    return new Set(place.seen.map((s) => s.origin)).size;
+}
+export function potential(place) {
+    return origins(place) < 2;
+}
+export function disagree(place) {
+    const spans = place.seen.map((s) => s.span);
+    const split = spans.length ? witnessesIn(spanning(spans), spans) : null;
+    if (!split)
+        return null;
+    const left = place.seen.find((s) => s.span === split[0]);
+    const right = place.seen.find((s) => s.span === split[1]);
+    return left && right ? [left, right] : null;
+}
+export function meetAt(place) {
+    const spans = place.seen.map((s) => s.span);
+    if (!spans.length)
+        throw new Error('obligations: REFUSE·meet a cell no origin has claimed has no meet of its own: read it against the form it belongs to');
+    const form = spanning(spans);
+    return spans.reduce((held, span) => form.meet(held, span));
+}
+export function latest(places) {
+    return places.reduce((held, place) => (held === null || place.epoch > held.epoch ? place : held), null);
+}
+export function verdict(place) {
+    return potential(place) ? 'one' : disagree(place) ? 'apart' : 'together';
+}
+export function turned(before, after) {
+    const held = new Map(before.map((p) => [key([{ at: p.at }]), verdict(p)]));
+    return after.filter((p) => held.get(key([{ at: p.at }])) !== verdict(p));
+}

package/dist/field/field.d.ts

@@ -0,0 +1,39 @@
+import type { Interval } from '../lattice/forms.ts';
+export interface Sighting {
+    readonly origin: string;
+    readonly span: Interval;
+}
+export interface Point {
+    readonly at: readonly string[];
+    readonly epoch: number;
+    readonly seen: readonly Sighting[];
+}
+export interface Region {
+    readonly at: readonly string[];
+}
+export declare function coordinate(name: string, steps?: string): readonly string[];
+export declare function point(name: string, epoch?: number, seen?: readonly Sighting[], steps?: string): Point;
+export declare function region(name: string, steps?: string): Region;
+export declare function coarsen(place: Point, steps: number): Point;
+export declare function passes(place: Point | Region, step: string): boolean;
+export declare function resolution(place: Point | Region): number;
+export declare function within(inner: Point | Region, outer: Region): boolean;
+export declare function exclusive(mine: readonly Region[], others: readonly (readonly Region[])[]): readonly Region[];
+export declare function contracts(regions: readonly Region[], touched: readonly Point[]): boolean;
+export declare function key(regions: readonly Region[]): string;
+export interface Fold<T> {
+    readonly at: string;
+    readonly value: T;
+}
+export declare function foldRegion<T>(places: readonly Point[], where: Region, f: (met: readonly Point[]) => T): readonly Fold<T>[];
+export declare function covers(met: readonly Point[], of: {
+    readonly where: readonly Region[];
+    readonly steps: Interval;
+    readonly when: Interval;
+}): boolean;
+export declare function outranks(met: readonly Point[], named: readonly (readonly [string, string])[], order: readonly string[]): string | null;
+export declare function answers(met: readonly Point[], where: readonly Region[]): boolean;
+export declare function verified(met: readonly Point[], green: (place: Point) => boolean): boolean;
+export declare function retracted(met: readonly Point[], by: readonly Region[]): readonly Point[];
+export declare function size(at: readonly string[], steps?: number): number;
+export declare function sufficientResolution<T>(finest: number, verdict: (steps: number) => T, same?: (a: T, b: T) => boolean): number;

package/dist/field/field.js

@@ -0,0 +1,79 @@
+export function coordinate(name, steps = '/') {
+    const at = name.split(new RegExp(`[${steps.replace(/[.*+?^${}()|[\]\\-]/g, '\\$&')}]`)).filter((s) => s !== '');
+    while (at[at.length - 1] === '*' || at[at.length - 1] === '**')
+        at.pop();
+    return at;
+}
+export function point(name, epoch = 0, seen = [], steps = '/') {
+    return { at: coordinate(name, steps), epoch, seen };
+}
+export function region(name, steps = '/') {
+    return { at: coordinate(name, steps) };
+}
+export function coarsen(place, steps) {
+    return { at: place.at.slice(0, Math.max(0, steps)), epoch: place.epoch, seen: place.seen };
+}
+export function passes(place, step) {
+    return step.startsWith('*') ? place.at.some((s) => s.endsWith(step.slice(1))) : place.at.includes(step);
+}
+export function resolution(place) {
+    return place.at.length;
+}
+export function within(inner, outer) {
+    const refines = (i, j) => j === outer.at.length
+        || (outer.at[j] === '**'
+            ? refines(i, j + 1) || (i < inner.at.length && refines(i + 1, j))
+            : i < inner.at.length && (outer.at[j] === '*' || outer.at[j] === inner.at[i]) && refines(i + 1, j + 1));
+    return refines(0, 0);
+}
+export function exclusive(mine, others) {
+    return mine.filter((one) => !others.some((other) => other.some((theirs) => resolution(theirs) === resolution(one) && within(one, theirs))));
+}
+export function contracts(regions, touched) {
+    return !regions.some((one) => touched.some((p) => within(p, one)));
+}
+export function key(regions) {
+    return [...new Set(regions.map((one) => one.at.join('/')))].sort().join('|');
+}
+const inside = (one, of) => one >= of.lo && one <= of.hi;
+export function foldRegion(places, where, f) {
+    const gathered = new Map();
+    for (const place of places) {
+        if (!within(place, where))
+            continue;
+        const at = place.at.join('/');
+        gathered.set(at, [...(gathered.get(at) ?? []), place]);
+    }
+    return [...gathered].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).map(([at, met]) => ({ at, value: f(met) }));
+}
+export function covers(met, of) {
+    return met.every((place) => of.where.some((one) => within(place, one))
+        && inside(resolution(place), of.steps)
+        && inside(place.epoch, of.when));
+}
+export function outranks(met, named, order) {
+    const matched = named.filter(([step]) => met.some((place) => passes(place, step))).map(([, kind]) => kind);
+    return order.find((kind) => matched.includes(kind)) ?? null;
+}
+export function answers(met, where) {
+    return met.length > 0 && met.every((place) => where.some((one) => within(place, one)));
+}
+export function verified(met, green) {
+    return met.some((place) => green(place));
+}
+export function retracted(met, by) {
+    return met.filter((place) => by.some((one) => within(place, one)));
+}
+export function size(at, steps) {
+    return new Set(at.map((name) => {
+        const place = point(name);
+        return (steps === undefined ? place : coarsen(place, steps)).at.join('/');
+    })).size;
+}
+export function sufficientResolution(finest, verdict, same = Object.is) {
+    const whole = verdict(finest);
+    for (let steps = 1; steps < finest; steps += 1)
+        if (same(verdict(steps), whole))
+            return steps;
+    return finest;
+}

package/dist/field/frontier.d.ts

@@ -0,0 +1,20 @@
+import type { Point } from './field.ts';
+import type { Level, Scale, Unit } from '../lattice/types.ts';
+export interface Asked {
+    readonly at: Point;
+    readonly bound: Unit;
+    readonly dependents: readonly string[];
+    readonly closers: readonly {
+        readonly by: string;
+        readonly cost: number;
+    }[];
+}
+export interface Open {
+    readonly at: string;
+    readonly resolution: number;
+    readonly premium: number;
+    readonly dependents: number;
+    readonly closer: string | null;
+    readonly cost: number | null;
+}
+export declare function frontier(c: Scale, value: (level: Level) => number, asked: readonly Asked[]): readonly Open[];

package/dist/field/frontier.js

@@ -0,0 +1,16 @@
+import { origins } from "./encounter.js";
+import { resolution } from "./field.js";
+import { premium } from "../lattice/price/premium.js";
+export function frontier(c, value, asked) {
+    return asked.filter((one) => origins(one.at) === 0).map((one) => {
+        const cheapest = [...one.closers].sort((a, b) => (a.cost === b.cost ? (a.by < b.by ? -1 : 1) : a.cost - b.cost))[0];
+        return {
+            at: one.at.at.join('/'),
+            resolution: resolution(one.at),
+            premium: premium(c, value, c.rank(one.bound.floor), c.rank(one.bound.ceiling)),
+            dependents: one.dependents.length,
+            closer: cheapest?.by ?? null,
+            cost: cheapest?.cost ?? null,
+        };
+    });
+}

package/dist/field/motion.d.ts

@@ -0,0 +1,14 @@
+import type { Level, Scale, State, Unit } from '../lattice/types.ts';
+import type { Matrix } from '../debit/vector-move.ts';
+import type { Point } from './field.ts';
+export declare function declarationOf(c: Scale, place: Point): {
+    readonly demand: Level;
+    readonly limit: Level;
+};
+export declare function unitOf(c: Scale, place: Point): Unit;
+export declare function stateOf(c: Scale, place: Point): State;
+export declare function registerOf(c: Scale, place: Point): readonly [string, State][];
+export declare function premiumOf(c: Scale, value: (level: Level) => number, place: Point): number;
+export declare function degenerate(c: Scale, value: (level: Level) => number): boolean;
+export declare function withdrawsExactly(c: Scale): boolean;
+export declare function movesOf(c: Scale, before: Point, after: Point): Matrix;