@lapxo/obligations 0.2.0

package/dist/views/product/reach.js

@@ -0,0 +1,106 @@
+import { meetAt, origins } from "../../field/encounter.js";
+const at = (cell) => cell.at.join('/');
+const spoke = (cell, bounds) => [...new Set(cell.seen.map((s) => s.origin))].filter((one) => !bounds.includes(one));
+export function neighbours(world, bounds = []) {
+    const byOrigin = new Map();
+    for (const cell of world)
+        for (const one of spoke(cell, bounds))
+            byOrigin.set(one, [...(byOrigin.get(one) ?? []), at(cell)]);
+    const out = new Map();
+    for (const held of byOrigin.values()) {
+        for (const a of held) {
+            const mine = out.get(a) ?? new Set();
+            for (const b of held)
+                if (b !== a)
+                    mine.add(b);
+            out.set(a, mine);
+        }
+    }
+    return new Map([...out].map(([place, said]) => [place, [...said]]));
+}
+export function distance(world, from, to, bounds = []) {
+    if (from === to)
+        return 0;
+    const next = neighbours(world, bounds);
+    const seen = new Set([from]);
+    let edge = [from];
+    for (let step = 1; edge.length; step += 1) {
+        const further = [];
+        for (const one of edge) {
+            for (const other of next.get(one) ?? []) {
+                if (seen.has(other))
+                    continue;
+                if (other === to)
+                    return step;
+                seen.add(other);
+                further.push(other);
+            }
+        }
+        edge = further;
+    }
+    return world.length;
+}
+export function horizon(world, from, bounds = []) {
+    const next = neighbours(world, bounds);
+    const seen = new Set([from]);
+    const edge = [from];
+    while (edge.length) {
+        const one = edge.pop();
+        for (const other of next.get(one) ?? [])
+            if (!seen.has(other)) {
+                seen.add(other);
+                edge.push(other);
+            }
+    }
+    return world.map(at).filter((place) => !seen.has(place));
+}
+export function reach(world, from, bounds = []) {
+    return world.length - horizon(world, from, bounds).length - 1;
+}
+export function tunnel(world, places, bounds = []) {
+    const crossed = [];
+    for (const a of places)
+        for (const b of places)
+            if (a < b && distance(world, a, b, bounds) >= world.length)
+                crossed.push([a, b]);
+    return crossed;
+}
+export function curvature(world) {
+    const counts = world.map((cell) => origins(cell)).filter((n) => n > 0).sort((a, b) => b - a);
+    if (!counts.length)
+        return 0;
+    const top = counts.slice(0, Math.max(1, Math.floor(counts.length / 10)));
+    const low = counts.slice(-Math.max(1, Math.floor(counts.length / 10)));
+    const mean = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+    if (mean(low) === 0)
+        throw new Error('obligations: REFUSE·curvature the sparsest tenth of this field holds no origin, so there is no ratio to take');
+    return mean(top) / mean(low);
+}
+export function grow(walls, placed) {
+    const edges = [...new Set(walls)].sort((a, b) => a - b);
+    const held = [...placed].sort((a, b) => a - b);
+    const first = edges[0] ?? 0;
+    const last = edges[edges.length - 1] ?? 0;
+    return held.map((one) => {
+        const lo = Math.max(...edges.filter((w) => w <= one), first);
+        const hi = Math.min(...edges.filter((w) => w >= one), last);
+        const inside = held.filter((other) => other > lo && other < hi);
+        const i = inside.indexOf(one);
+        const left = i > 0 ? (inside[i - 1] + one) / 2 : lo;
+        const right = i < inside.length - 1 ? (inside[i + 1] + one) / 2 : hi;
+        return { at: one, width: right - left };
+    });
+}
+export function entangled(world, bound) {
+    return world.filter((cell) => cell.seen.some((s) => s.origin === bound)).map(at);
+}
+export function resting(world, bound, was, now) {
+    const under = (span, cell) => {
+        const held = meetAt({ ...cell, seen: cell.seen.map((s) => (s.origin === bound ? { ...s, span } : s)) });
+        return held.hi >= held.lo;
+    };
+    return entangled(world, bound).flatMap((place) => {
+        const cell = world.find((one) => at(one) === place);
+        return cell !== undefined && under(was, cell) !== under(now, cell) ? [place] : [];
+    });
+}

package/dist/views/product/resolution.d.ts

@@ -0,0 +1,8 @@
+import type { Point } from '../../field/field.ts';
+export declare function agreements(cells: readonly Point[], steps: number): {
+    readonly agreed: number;
+    readonly forks: number;
+    readonly cells: number;
+};
+export declare function residual(cells: readonly Point[], steps: number): number;
+export declare function sufficient(cells: readonly Point[], upTo: number, tolerance?: number): number;

package/dist/views/product/resolution.js

@@ -0,0 +1,34 @@
+import { coarsen } from "../../field/field.js";
+import { verdict } from "../../field/encounter.js";
+import { area } from "./polygon.js";
+export function agreements(cells, steps) {
+    const pooled = new Map();
+    for (const cell of cells) {
+        const coarse = coarsen(cell, steps);
+        const key = coarse.at.join('/');
+        const held = pooled.get(key);
+        pooled.set(key, held === undefined ? coarse : { ...held, seen: [...held.seen, ...coarse.seen] });
+    }
+    const said = [...pooled.values()].map((one) => verdict(one));
+    return { agreed: said.filter((one) => one === 'together').length, forks: said.filter((one) => one === 'apart').length, cells: pooled.size };
+}
+export function residual(cells, steps) {
+    const pooled = new Map();
+    for (const cell of cells) {
+        const coarse = coarsen(cell, steps);
+        const key = coarse.at.join('/');
+        const held = pooled.get(key);
+        pooled.set(key, held === undefined ? coarse : { ...held, seen: [...held.seen, ...coarse.seen] });
+    }
+    return [...pooled.values()].reduce((sum, one) => sum + area(one), 0);
+}
+export function sufficient(cells, upTo, tolerance = 1e-9) {
+    let held = residual(cells, 1);
+    for (let steps = 2; steps <= upTo; steps += 1) {
+        const now = residual(cells, steps);
+        if (Math.abs(now - held) <= tolerance)
+            return steps - 1;
+        held = now;
+    }
+    return upTo;
+}

package/dist/views/product.d.ts

@@ -0,0 +1,12 @@
+export { buildGraph, reachIds } from '../debit/graph.ts';
+export { or } from '../debit/packed.ts';
+export { compose, fuse } from '../debit/unit.ts';
+export { continuousForm, intervals, ladderForm } from '../lattice/forms.ts';
+export { fromScale } from '../lattice/scale-lattice.ts';
+export { area, centre, density, hull, outliers, steady, vertices, width } from './product/polygon.ts';
+export type { Vertex } from './product/polygon.ts';
+export { pour, red, stretch, tense, tighter } from './product/mould.ts';
+export type { Lock } from './product/mould.ts';
+export { agreements, residual, sufficient } from './product/resolution.ts';
+export { curvature, distance, entangled, grow, horizon, neighbours, reach, resting, tunnel } from './product/reach.ts';
+export { apart, design, horizonTotal, lone, loom, rank, sited } from './product/design.ts';

package/dist/views/product.js

@@ -0,0 +1,10 @@
+export { buildGraph, reachIds } from "../debit/graph.js";
+export { or } from "../debit/packed.js";
+export { compose, fuse } from "../debit/unit.js";
+export { continuousForm, intervals, ladderForm } from "../lattice/forms.js";
+export { fromScale } from "../lattice/scale-lattice.js";
+export { area, centre, density, hull, outliers, steady, vertices, width } from "./product/polygon.js";
+export { pour, red, stretch, tense, tighter } from "./product/mould.js";
+export { agreements, residual, sufficient } from "./product/resolution.js";
+export { curvature, distance, entangled, grow, horizon, neighbours, reach, resting, tunnel } from "./product/reach.js";
+export { apart, design, horizonTotal, lone, loom, rank, sited } from "./product/design.js";

package/dist/views/quotient.d.ts

@@ -0,0 +1,2 @@
+export { permutationBlind, permute } from '../debit/shuffle.ts';
+export { answers, outranks, retracted, verified } from '../field/field.ts';

package/dist/views/quotient.js

@@ -0,0 +1,2 @@
+export { permutationBlind, permute } from "../debit/shuffle.js";
+export { answers, outranks, retracted, verified } from "../field/field.js";

package/dist/views/spectrum.d.ts

@@ -0,0 +1,4 @@
+export { attainable, classifyValue } from '../lattice/price/attainable.ts';
+export { meetBlocks } from '../lattice/price/blocks.ts';
+export { c_n } from '../lattice/price/premium.ts';
+export { spectrum } from '../lattice/price/quote.ts';

package/dist/views/spectrum.js

@@ -0,0 +1,4 @@
+export { attainable, classifyValue } from "../lattice/price/attainable.js";
+export { meetBlocks } from "../lattice/price/blocks.js";
+export { c_n } from "../lattice/price/premium.js";
+export { spectrum } from "../lattice/price/quote.js";

package/dist/views/valuation.d.ts

@@ -0,0 +1,9 @@
+export { unitStream } from '../debit/shuffle.ts';
+export { declarationOf, degenerate, movesOf, premiumOf, registerOf, stateOf, unitOf, withdrawsExactly } from '../field/motion.ts';
+export { asUnit, conj, declaration, disj } from '../lattice/declaration.ts';
+export { chain, height, order } from '../lattice/order.ts';
+export { best, collapses, costOfState, gap, isSupermodular, premium, pricesAnything } from '../lattice/price/premium.ts';
+export { defect, dropTo, price, slack } from '../lattice/price/quote.ts';
+export { isMonotone, vacuityOf } from '../lattice/vacuity.ts';
+export { frontier } from '../field/frontier.ts';
+export { yieldOf } from '../field/yield.ts';

package/dist/views/valuation.js

@@ -0,0 +1,9 @@
+export { unitStream } from "../debit/shuffle.js";
+export { declarationOf, degenerate, movesOf, premiumOf, registerOf, stateOf, unitOf, withdrawsExactly } from "../field/motion.js";
+export { asUnit, conj, declaration, disj } from "../lattice/declaration.js";
+export { chain, height, order } from "../lattice/order.js";
+export { best, collapses, costOfState, gap, isSupermodular, premium, pricesAnything } from "../lattice/price/premium.js";
+export { defect, dropTo, price, slack } from "../lattice/price/quote.js";
+export { isMonotone, vacuityOf } from "../lattice/vacuity.js";
+export { frontier } from "../field/frontier.js";
+export { yieldOf } from "../field/yield.js";

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@lapxo/obligations",
+  "version": "0.2.0",
+  "description": "The algebra of a cell: two poles, origins with phase, six operations.",
+  "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"
+    },
+    "./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",
+    "receipts.bound"
+  ],
+  "scripts": {
+    "build": "tsc --build"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5.9.3"
+  }
+}