@lapxo/obligations 0.2.0 → 0.3.3

package/dist/lattice/obligatory.js

@@ -1,33 +1,58 @@
 import { coordinate } from "../field/field.js";
+import { UnitError } from "./errors.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 mark(one) {
+    if (one.widens !== undefined && one.reach === 'travels') {
+        throw new UnitError('widening-travels', 'obligations: REFUSE·widening-travels a widening stands where it was witnessed and never travels to what rests there', { pole: one.pole });
+    }
+    return one.takes === undefined ? one : { ...one, sign: -1 };
 }
-export function observe(one, claim) {
-    return { ...one, epoch: Math.max(one.epoch, claim.at ?? one.epoch), seen: [...one.seen, claim] };
+export function live(lines) {
+    const taken = new Set(lines.flatMap((line) => (line.takes === undefined ? [] : [line.takes])));
+    return lines.filter((line) => line.takes === undefined && (line.id === undefined || !taken.has(line.id)));
 }
-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));
+export function restOf(c, world = new Map()) {
+    const own = c.at.join('/');
+    const out = [];
+    const held = new Set();
+    const edge = [...c.restsOn];
+    for (let i = 0; i < edge.length; i += 1) {
+        const name = edge[i];
+        if (name === own)
+            throw new UnitError('rest-cycle', `obligations: REFUSE·rest ${own} rests on itself: an order of rest with a cycle has no fold to reach`, { at: own });
+        if (held.has(name))
+            continue;
+        held.add(name);
+        out.push(name);
+        edge.push(...(world.get(name)?.restsOn ?? []));
     }
-    return new Map([...held, [name, lattice.meet(held.get(name) ?? lattice.top, span)]]);
+    return out;
 }
-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 parts(L, c, world = new Map()) {
+    const rest = restOf(c, world);
+    const above = rest.flatMap((name) => live(world.get(name)?.marks ?? []).filter((one) => one.reach === 'travels' && one.widens === undefined));
+    const marks = [...live(c.marks ?? []), ...above].sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
+    let required = L.top;
+    let signed = L.top;
+    for (const one of marks) {
+        if (one.pole === 'floor')
+            required = L.meet(required, one.span);
+        else
+            signed = one.widens === undefined ? L.meet(signed, one.span) : L.join(signed, one.span);
+    }
+    const origins = live(c.seen);
+    const held = origins.reduce((acc, claim) => L.meet(acc, claim.span), L.top);
+    return { floor: L.meet(required, held), ceiling: L.meet(signed, held), origins, rest, required, signed };
 }
-export function refine(one, steps) {
-    return { ...one, at: steps >= one.at.length ? one.at : one.at.slice(0, Math.max(1, steps)) };
+export function state(L, c, world = new Map()) {
+    const { floor, ceiling, origins, required, signed } = parts(L, c, world);
+    if (!L.inhabited(L.meet(required, signed)))
+        return 'CONFLICT';
+    if (new Set(origins.map((claim) => claim.origin)).size < 2)
+        return 'REQUIRED';
+    if (!L.inhabited(origins.reduce((acc, claim) => L.meet(acc, claim.span), L.top)))
+        return 'CONFLICT';
+    return L.inhabited(L.meet(floor, ceiling)) ? 'FREE' : 'FORBIDDEN';
 }

package/dist/lattice/order.d.ts

@@ -3,4 +3,3 @@ 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

@@ -147,4 +147,3 @@ export function order(levels, leq) {
     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/views/field/physics.js

@@ -1,4 +1,4 @@
-import { meet } from "../../lattice/obligatory.js";
+import { meet } from "../../field/meet.js";
 import { coherence } from "./wave.js";
 export function disturbance(lattice, one, claim) {
     const was = meet(lattice, one);

package/dist/views/field/policy.js

@@ -1,4 +1,5 @@
-import { encounter, meet } from "../../lattice/obligatory.js";
+import { encounter } from "../../field/encounter.js";
+import { meet } from "../../field/meet.js";
 import { coherence } from "./wave.js";
 import { neighbours, reach } from "../product/reach.js";
 const at = (cell) => cell.at.join('/');

package/dist/views/field/self.js

@@ -1,4 +1,5 @@
-import { meet, observe } from "../../lattice/obligatory.js";
+import { meet } from "../../field/meet.js";
+import { observe } from "../../field/observe.js";
 export function selfFold(lattice, one, epochs, width, spread, seed) {
     let held = seed;
     const next = () => { held = (held * 1103515245 + 12345) % 2147483648; return held / 2147483648; };

package/dist/views/field.d.ts

@@ -1,11 +1,19 @@
 export { foldIn, witnessesIn } from '../debit/debit.ts';
-export { disagree, latest, meetAt, origins, potential, turned } from '../field/encounter.ts';
+export { cancels, disagree, encounter, laminar, latest, meetAt, origins, pairs, potential, turned } from '../field/encounter.ts';
 export { contracts, coordinate, covers, exclusive, key, passes, point, region, resolution, within } from '../field/field.ts';
+export { join } from '../field/join.ts';
+export { meet } from '../field/meet.ts';
+export { observe } from '../field/observe.ts';
+export { refine } from '../field/refine.ts';
+export { require } from '../field/require.ts';
+export { bites, restingOn, sign } from '../field/sign.ts';
 export { converge, endsBeforeNow, present } from '../field/present.ts';
 export { amplitude, coherence, fringes, interfere, phase, seenAs } from './field/wave.ts';
 export type { Claim } from './field/wave.ts';
-export { cell, encounter, join, meet, observe, refine, sign } from '../lattice/obligatory.ts';
-export type { Obligatory } from '../lattice/obligatory.ts';
+export { cell, mark, parts, restOf, state } from '../lattice/obligatory.ts';
+export { fragility } from '../field/fragility.ts';
+export type { Act, Cell, Mark, Obligatory, Origin, World } from '../lattice/obligatory.ts';
+export { looksLeft, pay, price } from '../debit/observer.ts';
 export { budget, decohere, disturbance, distinct, evolve, sameObject } from './field/physics.ts';
 export { choose, play } from './field/policy.ts';
 export { selfFold } from './field/self.ts';

package/dist/views/field.js

@@ -1,9 +1,17 @@
 export { foldIn, witnessesIn } from "../debit/debit.js";
-export { disagree, latest, meetAt, origins, potential, turned } from "../field/encounter.js";
+export { cancels, disagree, encounter, laminar, latest, meetAt, origins, pairs, potential, turned } from "../field/encounter.js";
 export { contracts, coordinate, covers, exclusive, key, passes, point, region, resolution, within } from "../field/field.js";
+export { join } from "../field/join.js";
+export { meet } from "../field/meet.js";
+export { observe } from "../field/observe.js";
+export { refine } from "../field/refine.js";
+export { require } from "../field/require.js";
+export { bites, restingOn, sign } from "../field/sign.js";
 export { converge, endsBeforeNow, present } from "../field/present.js";
 export { amplitude, coherence, fringes, interfere, phase, seenAs } from "./field/wave.js";
-export { cell, encounter, join, meet, observe, refine, sign } from "../lattice/obligatory.js";
+export { cell, mark, parts, restOf, state } from "../lattice/obligatory.js";
+export { fragility } from "../field/fragility.js";
+export { looksLeft, pay, price } from "../debit/observer.js";
 export { budget, decohere, disturbance, distinct, evolve, sameObject } from "./field/physics.js";
 export { choose, play } from "./field/policy.js";
 export { selfFold } from "./field/self.js";

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@lapxo/obligations",
-  "version": "0.2.0",
-  "description": "The algebra of a cell: two poles, origins with phase, six operations.",
+  "version": "0.3.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"
+    "url": "git+https://github.com/Lapxo/obligations.git"
   },
   "keywords": [
     "obligations",