@lapxo/bound 0.1.0

package/dist/fold/readers.d.ts

@@ -0,0 +1,44 @@
+import type { CoordinateRole } from './wire.ts';
+import { capsulesFor } from './reach.ts';
+import type { Kind } from '../observe/run.ts';
+export interface ReaderClaim {
+    readonly id: string;
+    readonly shape: readonly string[];
+    readonly where: readonly string[];
+    readonly module: string;
+    readonly kind: Kind;
+    readonly capsule?: {
+        readonly digest: string;
+        readonly entry: string;
+        readonly region: string;
+        readonly reads: readonly string[];
+        readonly globs: ReadonlyMap<string, readonly string[]>;
+    };
+}
+export type Offer = {
+    readonly place: string;
+    readonly seen: string;
+    readonly bytes: () => Uint8Array;
+    readonly digest?: () => string;
+};
+export type Look = {
+    readonly under: (dir: string, pruned: boolean) => readonly string[];
+    readonly stamp: (at: string) => string;
+};
+export declare function lookOf(root: string, roleOf: (coordinate: string) => CoordinateRole): Look;
+/**
+ * The reader regions of the capsules a place can run, where the place's own lock offers them or, at a world, the wire's offers/world list does for a
+ * region its own lock does not name: `region/<name>` under a measure the wire's region-measures list names gives the region and its coordinates, and the first capsule, pinned before carried, that writes the region
+ * reads them, handed the coordinates it declares it reads among those the place offers. A capsule region takes over what a
+ * place's declared region. A standing reader for that same provider and region keeps ownership, so nothing is read twice.
+ * A newly declared region does not need a retired reader in private history to be observed.
+ */
+export declare function capsuleReadersOf(root: string, store: string, standing: readonly string[], lines: readonly ReaderClaim[], resolve?: typeof capsulesFor): readonly ReaderClaim[];
+export declare function handedAt(root: string, reader: ReaderClaim, roleOf: (coordinate: string) => CoordinateRole, look: Look, place: string): readonly string[];
+/**
+ * What a reader is offered at the places it reads: a coordinate for a reader of coordinates, the listing for one that reads a
+ * directory, and for one that runs over its place its sources and every coordinate its shape names besides — a coordinate a view
+ * writes from what readers said is offered only when named, so no reading moves its own offer — each by the stamp it
+ * was seen at and the bytes that key what it said; a capsule reader is offered the coordinates it is handed.
+ */
+export declare function offersOf(root: string, store: string, reader: ReaderClaim, roleOf: (coordinate: string) => CoordinateRole, look: Look, into: (where: string) => boolean): readonly Offer[];

package/dist/fold/readers.js

@@ -0,0 +1,132 @@
+import { resolve } from "../host/io.js";
+import { canonical, fields, matches } from '@lapxo/topos/wire';
+import { namesAt, wordOn, wordsOf, wireLine } from "./wire.js";
+import { fits } from "../observe/match.js";
+import { bytesDigest, coordinateDigest } from "./digests.js";
+import { fieldOf } from "./claims.js";
+import { capsuleAt, placesIn } from "./places.js";
+import { capsulesFor } from "./reach.js";
+import { ownLockOf } from "./signed.js";
+import { ownLock } from "../observe/runner.js";
+import { entriesIn, coordinatesUnder, observeFile, stampOf } from "../observe/files.js";
+export function lookOf(root, roleOf) {
+    const walked = new Map();
+    const stamped = new Map();
+    return {
+        under: (dir, pruned) => walked.get(`${pruned} ${dir}`) ?? walked.set(`${pruned} ${dir}`, coordinatesUnder(dir, root, pruned ? (one) => roleOf(one) !== 'foreign' : undefined)).get(`${pruned} ${dir}`),
+        stamp: (at) => stamped.get(at) ?? stamped.set(at, stampOf(at)?.stamp ?? '').get(at),
+    };
+}
+function entriesOf(root, where, roleOf) {
+    const dir = where.replace(/\/?$/, '/');
+    const at = resolve(root, dir);
+    if (stampOf(at)?.kind !== 'dir')
+        return undefined;
+    const names = entriesIn(at)
+        .filter((entry) => roleOf(`${dir}${entry.name}`) === 'source')
+        .map((entry) => (entry.dir ? `${entry.name}/` : entry.name))
+        .sort();
+    return new TextEncoder().encode(names.join('\n'));
+}
+const reachOfLine = (module, where) => {
+    const [pkg = '', ...rest] = module.split('/');
+    const stem = (rest.at(-1) ?? '').replace(/\.[^.]+$/, '');
+    return where.flatMap((one) => [`${pkg} ${stem} ${one.replace(/\/?$/, '/')}`, `${pkg} ${stem}s ${one.replace(/\/?$/, '/')}`]);
+};
+/**
+ * The reader regions of the capsules a place can run, where the place's own lock offers them or, at a world, the wire's offers/world list does for a
+ * region its own lock does not name: `region/<name>` under a measure the wire's region-measures list names gives the region and its coordinates, and the first capsule, pinned before carried, that writes the region
+ * reads them, handed the coordinates it declares it reads among those the place offers. A capsule region takes over what a
+ * place's declared region. A standing reader for that same provider and region keeps ownership, so nothing is read twice.
+ * A newly declared region does not need a retired reader in private history to be observed.
+ */
+export function capsuleReadersOf(root, store, standing, lines, resolve = capsulesFor) {
+    const reaching = new Set(lines.flatMap((reader) => reachOfLine(reader.module, reader.where)));
+    const measures = wordsOf(standing, 'region-measures');
+    const world = fields(fieldOf(wireLine(standing, 'offers/world') ?? '', 'value')).map(([region, globs]) => canonical({ scope: `region/${region}`, measure: wordOn(standing, 'region-coordinate', ownLock()), value: globs }));
+    const groups = new Map();
+    for (const place of ['', ...placesIn(root)]) {
+        const where = place ? `${place}/` : '';
+        const own = ownLockOf(root, place).filter((line) => fieldOf(line, 'scope').startsWith('region/') && measures.includes(fieldOf(line, 'measure')) && fieldOf(line, 'value') !== 'withdraw');
+        const offered = [...own, ...(capsuleAt(root, place) ? world.filter((line) => !own.some((one) => fieldOf(one, 'scope') === fieldOf(line, 'scope'))) : [])];
+        if (!offered.length)
+            continue;
+        const capsules = resolve(standing, place, root);
+        for (const line of offered) {
+            const region = fieldOf(line, 'scope').slice('region/'.length);
+            const by = capsules.find(({ capsule }) => capsule.lines.some((one) => fieldOf(one, 'scope') === `region/${region}` && fieldOf(one, 'measure') === 'writes'));
+            const pkg = fieldOf(by?.offer ?? '', 'scope').split('/')[1] ?? '';
+            if (by === undefined || reaching.has(`${pkg} ${region} ${where || '/'}`))
+                continue;
+            const key = `${by.capsule.digest} ${region}`;
+            const group = groups.get(key) ?? groups.set(key, { module: `${pkg}/${region}`, digest: by.capsule.digest, entry: fieldOf(by.offer, 'shape'), region, reads: by.capsule.declaration.regions[region] ?? [], globs: new Map() }).get(key);
+            group.globs.set(where, fieldOf(line, 'value').split('|').filter(Boolean));
+        }
+    }
+    return [...groups.values()].map((group) => ({ id: group.module, shape: ['run'], where: [...group.globs.keys()], module: group.module, kind: 'process',
+        capsule: { digest: group.digest, entry: group.entry, region: group.region, reads: group.reads, globs: group.globs } }));
+}
+export function handedAt(root, reader, roleOf, look, place) {
+    const { reads, globs } = reader.capsule;
+    const run = reads.some((read) => read.includes('@'));
+    return look.under(resolve(root, place), true).filter((coordinate) => {
+        const inside = coordinate.slice(place.length);
+        return (!run || roleOf(coordinate) === 'source') && reads.some((read) => fits(read, inside)) && (globs.get(place) ?? []).some((glob) => matches(glob, inside));
+    }).sort();
+}
+/**
+ * What a reader is offered at the places it reads: a coordinate for a reader of coordinates, the listing for one that reads a
+ * directory, and for one that runs over its place its sources and every coordinate its shape names besides — a coordinate a view
+ * writes from what readers said is offered only when named, so no reading moves its own offer — each by the stamp it
+ * was seen at and the bytes that key what it said; a capsule reader is offered the coordinates it is handed.
+ */
+export function offersOf(root, store, reader, roleOf, look, into) {
+    const offered = [];
+    const wheres = reader.where.filter(into);
+    if (reader.capsule !== undefined && reader.capsule.reads.some((read) => read.includes('@'))) {
+        for (const where of wheres) {
+            const held = handedAt(root, reader, roleOf, look, where);
+            const stamps = held.map((coordinate) => `${coordinate} ${look.stamp(resolve(root, coordinate))}`).join('\n');
+            offered.push({
+                place: where,
+                seen: bytesDigest(store, new TextEncoder().encode(stamps)).replace(/^[^:]*:/, '').slice(0, 16),
+                bytes: () => new TextEncoder().encode(held.map((coordinate) => `${coordinate} ${coordinateDigest(store, resolve(root, coordinate)) ?? bytesDigest(store, new Uint8Array())}`).join('\n')),
+            });
+        }
+    }
+    else if (reader.capsule !== undefined) {
+        for (const coordinate of [...new Set(wheres.flatMap((where) => handedAt(root, reader, roleOf, look, where)))].sort()) {
+            offered.push({ place: coordinate, seen: look.stamp(resolve(root, coordinate)), bytes: () => observeFile(resolve(root, coordinate)) ?? new Uint8Array(), digest: () => coordinateDigest(store, resolve(root, coordinate)) ?? bytesDigest(store, new Uint8Array()) });
+        }
+    }
+    else if (reader.kind === 'process') {
+        for (const where of wheres) {
+            const dir = resolve(root, where);
+            if (stampOf(dir)?.kind !== 'dir')
+                continue;
+            const held = look.under(dir, true).filter((coordinate) => roleOf(coordinate) === 'source' || (roleOf(coordinate) !== 'foreign' && reader.shape.some((name) => namesAt(coordinate, name) || fits(name, coordinate)))).sort();
+            const stamps = held.map((coordinate) => `${coordinate} ${look.stamp(resolve(root, coordinate))}`).join('\n');
+            offered.push({
+                place: where.replace(/\/?$/, '/'),
+                seen: bytesDigest(store, new TextEncoder().encode(stamps)).replace(/^[^:]*:/, '').slice(0, 16),
+                bytes: () => new TextEncoder().encode(held.map((coordinate) => `${coordinate} ${coordinateDigest(store, resolve(root, coordinate)) ?? bytesDigest(store, new Uint8Array())}`).join('\n')),
+            });
+        }
+    }
+    else if (reader.shape.some((name) => name.endsWith('/'))) {
+        for (const where of wheres) {
+            const listed = entriesOf(root, where, roleOf);
+            if (listed)
+                offered.push({ place: where.replace(/\/?$/, '/'), seen: bytesDigest(store, listed).replace(/^[^:]*:/, '').slice(0, 16), bytes: () => listed });
+        }
+    }
+    else {
+        const paths = wheres.flatMap((where) => look.under(resolve(root, where), true));
+        for (const path of [...new Set(paths)].sort()) {
+            if (!reader.shape.some((name) => namesAt(path, name)))
+                continue;
+            offered.push({ place: path, seen: look.stamp(resolve(root, path)), bytes: () => observeFile(resolve(root, path)) ?? new Uint8Array(), digest: () => coordinateDigest(store, resolve(root, path)) ?? bytesDigest(store, new Uint8Array()) });
+        }
+    }
+    return offered;
+}

package/dist/fold/receipts.d.ts

@@ -0,0 +1,8 @@
+/** A receipt as the fold sees it: the scope it paid and the coordinates it moved. */
+interface Receipt {
+    readonly scope: string;
+    readonly digest: string;
+    readonly moved: readonly string[];
+}
+export declare function receiptsIn(store: string, scopes?: readonly string[]): readonly Receipt[];
+export {};

package/dist/fold/receipts.js

@@ -0,0 +1,47 @@
+import { join } from "../host/io.js";
+import { wordOf } from "./wire.js";
+import { ledgerLines, storeAt } from "../land/ledger.js";
+import { lockStanding } from "./keys.js";
+import { fieldOf } from "./claims.js";
+import { entriesIn, exists, observeText } from "../observe/files.js";
+/** The writer of the index that names, per scope, the receipts judged before the ledger existed. */
+/** The receipt files the session index names for these scopes; without scopes, every receipt file. The index is a ledger. */
+function receiptNames(store, dir, scopes) {
+    if (!scopes)
+        return entriesIn(dir).map((entry) => entry.name);
+    const wanted = new Set(ledgerLines(store, wordOf(lockStanding(store), 'families', 'session'))
+        .filter((line) => scopes.includes(fieldOf(line, 'scope')))
+        .map((line) => fieldOf(line, 'value').replace(/^sha256:/, '')));
+    return [...wanted].flatMap((hex) => [`${hex}.json`, `sha256:${hex}.json`]).filter((name) => exists(join(dir, name)));
+}
+export function receiptsIn(store, scopes) {
+    const out = [];
+    const dir = storeAt(store, 'cas', 'receipts');
+    for (const name of receiptNames(store, dir, scopes)) {
+        if (!/^(sha256:)?[0-9a-f]{64}\.json$/.test(name))
+            continue;
+        const parsed = JSON.parse(observeText(join(dir, name)) ?? '{}');
+        const r = parsed.receipt;
+        if (r?.kind !== 'fact')
+            continue;
+        const floor = typeof r.floor === 'string' ? r.floor : r.floor?.scope ?? '';
+        if (!floor)
+            continue;
+        const moved = Array.isArray(r.moved) ? r.moved.filter((m) => typeof m === 'string') : [];
+        out.push({ scope: floor.replace(/\.(status|count|id|ms|order|kind)$/, ''), digest: name.replace(/\.json$/, ''), moved });
+    }
+    for (const line of ledgerLines(store, 'judge')) {
+        const at = fieldOf(line, 'at');
+        if (fieldOf(line, 'value') !== 'present' || !at.startsWith('receipt:'))
+            continue;
+        if (scopes && !scopes.includes(fieldOf(line, 'scope')))
+            continue;
+        const digest = at.slice('receipt:'.length);
+        const envelope = JSON.parse(observeText(storeAt(store, 'cas', 'envelopes', `${digest.slice(digest.indexOf(':') + 1)}.json`)) ?? '{}');
+        const before = envelope.before ?? {};
+        const after = envelope.after ?? {};
+        const moved = [...new Set([...Object.keys(before), ...Object.keys(after)])].filter((coordinate) => before[coordinate] !== after[coordinate]);
+        out.push({ scope: fieldOf(line, 'scope'), digest, moved });
+    }
+    return out;
+}

package/dist/fold/region.d.ts

@@ -0,0 +1,72 @@
+import type { Interval } from '@lapxo/obligations/forms';
+/**
+ * A region is a prefix of the place, read at a resolution: the prefixes a lock already names — the steps a role, a
+ * directory or a need is given at — are its regions, a cell belongs to the longest of them that holds it, and a region
+ * rests on the region its prefix extends. A signature or a requirement is a line at the region its scope names, never a
+ * value copied into the cells there; a cell's poles are the meet of the live bounds on its chain of rest, met in the
+ * lattice of their form. Each region carries a summary of what lies in it, summed over the regions that rest on it —
+ * cells, the sums and the values they read at the lattice's own resolution, the bounds signed at it — so what a bound
+ * would bite is read off a summary without visiting a cell, and two readings of one place differ exactly in the regions
+ * whose summaries differ. Nothing here is kept between folds; a region is read from the lines that stand and the cells seen.
+ */
+export interface Bound {
+    readonly line: string;
+    readonly question: string;
+    readonly region: string;
+    readonly measure: string;
+    readonly form: string;
+    readonly value: string;
+}
+export interface Regions {
+    readonly named: readonly string[];
+    readonly bounds: readonly Bound[];
+    readonly summaries: ReadonlyMap<string, {
+        readonly region: string;
+        readonly cells: number;
+        readonly sums: ReadonlyMap<string, number>;
+        readonly values: ReadonlyMap<string, ReadonlyMap<string, number>>;
+        readonly bounds: readonly Bound[];
+    }>;
+}
+export declare function regionsNamed(standing: readonly string[]): readonly string[];
+export declare function boundOf(named: readonly string[], line: string): Bound;
+/**
+ * The poles of a region, question by question: each live bound is signed at the region it names and travels by rest, as
+ * the object signs, so the ceiling is what the region reads up its chain of rest, the meet in the lattice of their form, and beside it what the region's cells hold under that question,
+ * value by count. Read off the summaries alone; no cell is visited.
+ */
+export declare function polesOf(regions: Regions, region: string): ReadonlyMap<string, {
+    readonly ceiling: Interval | readonly string[] | undefined;
+    readonly held: ReadonlyMap<string, number> | undefined;
+}>;
+export declare function regionsOf(standing: readonly string[], ceilings: readonly string[], cells: readonly {
+    readonly question: string;
+    readonly measure: string;
+    readonly value: string;
+    readonly place: string;
+}[]): Regions;
+/**
+ * What a bound bites, read off the summary of its region and never off a cell: the values its region's cells read that
+ * lie outside it, and of those the ones every bound above it still admits. A question finer than a summary is not asked.
+ */
+export declare function rankOf(regions: Regions, bound: Bound, own?: Readonly<Record<string, number>>): {
+    readonly bars: number;
+    readonly cells: number;
+    readonly fresh: number;
+    readonly met: number;
+    readonly sums: number;
+};
+export declare function finerOf(regions: Regions): ReadonlyMap<string, readonly string[]>;
+export declare function digestsOf(regions: Regions): ReadonlyMap<string, string>;
+export declare function differing(a: Regions, b: Regions): {
+    readonly regions: readonly string[];
+    readonly compared: number;
+};
+export interface Packed {
+    readonly named: readonly string[];
+    readonly bounds: readonly string[];
+    readonly summaries: readonly (readonly [string, number, readonly (readonly [string, number])[], readonly (readonly [string, readonly (readonly [string, number])[]])[]])[];
+}
+export declare const packRegions: (regions: Regions) => Packed;
+export declare function unpackRegions(packed: Packed): Regions;
+export declare function unlikeReplay(regions: Regions, red: ReadonlySet<string>, own: Readonly<Record<string, number>>): number;

package/dist/fold/region.js

@@ -0,0 +1,286 @@
+import { createHash } from "../host/io.js";
+import { alphabetForm } from '@lapxo/obligations/forms';
+import { cell, parts, sign } from '@lapxo/obligations/views/field';
+import { point, region as coordinates, within } from '@lapxo/obligations/field';
+import { matches, parse, roleClaimsOf } from '@lapxo/topos/wire';
+import { fieldOf } from "./claims.js";
+import { INTERVALS, spanOf } from '@lapxo/topos/forms';
+const trimmed = (prefix) => prefix.replace(/(?:\/\*\*|\/\*|\/)+$/, '');
+const globbed = (prefix) => prefix.includes('*');
+export function regionsNamed(standing) {
+    const out = new Set(['']);
+    for (const line of standing) {
+        if (fieldOf(line, 'value') === 'withdraw')
+            continue;
+        const scope = fieldOf(line, 'scope');
+        const got = ['role', 'paths'].includes(fieldOf(line, 'measure')) ? parse(line) : undefined;
+        const roled = got?.kind === 'fact' ? roleClaimsOf([got.value.fields]).map((claim) => claim.name) : [];
+        const said = roled.length ? roled
+            : scope.startsWith('dir/') ? [scope.slice('dir/'.length)]
+                : scope.startsWith('region/') && fieldOf(line, 'res') ? [fieldOf(line, 'value')] : [];
+        for (const prefix of [...said, ...fieldOf(line, 'needs').split('|')].map(trimmed))
+            if (prefix && !globbed(prefix))
+                out.add(prefix);
+    }
+    return [...out].sort();
+}
+function restsOn(named, prefix) {
+    let best = '';
+    for (const one of named)
+        if (one.length > best.length && one !== prefix && prefix.startsWith(`${one}/`))
+            best = one;
+    return best;
+}
+function regionOf(named, place) {
+    const at = trimmed(place);
+    let best = '';
+    for (const one of named)
+        if (one.length > best.length && (at === one || at.startsWith(`${one}/`)))
+            best = one;
+    return best;
+}
+const names = (named, prefix) => (globbed(prefix) ? named.some((one) => matches(prefix, one)) : named.includes(prefix));
+export function boundOf(named, line) {
+    const scope = fieldOf(line, 'scope');
+    const steps = scope.split('/');
+    const of = (question, region) => ({ line, question, region, measure: fieldOf(line, 'measure'), form: fieldOf(line, 'form'), value: fieldOf(line, 'value') });
+    for (let i = 1; i < steps.length; i += 1) {
+        const tail = trimmed(steps.slice(i).join('/'));
+        if (tail && names(named, tail))
+            return of(steps.slice(0, i).join('/'), tail);
+    }
+    for (let j = steps.length - 1; j > 0; j -= 1) {
+        const head = steps.slice(0, j).join('/');
+        if (names(named, head))
+            return of(steps.slice(j).join('/'), head);
+    }
+    return of(scope, '');
+}
+function poleAt(named, region, bounds) {
+    const chain = [];
+    for (let at = region; !chain.includes(at); at = restsOn(named, at))
+        chain.push(at);
+    const signedIn = (L, spans) => {
+        let world = new Map(chain.map((_, i) => [`c${i}`, cell(`c${i}`, 0, [], i + 1 < chain.length ? [`c${i + 1}`] : [])]));
+        for (const [one, span] of spans)
+            world = sign(L, world, `c${Math.max(0, chain.indexOf(one.region))}`, span);
+        return parts(L, world.get('c0'), world).signed;
+    };
+    const spans = bounds.filter((one) => one.form === 'interval').flatMap((one) => ((got) => (got ? [[one, got]] : []))(spanOf(one.value)));
+    if (spans.length)
+        return signedIn(INTERVALS, spans);
+    const alphabets = bounds.filter((one) => one.form === 'alphabet');
+    if (!alphabets.length)
+        return undefined;
+    const words = (value) => (value.startsWith('not:') ? value.slice(4) : value).split('|').filter((one) => one && one !== 'none');
+    const tokens = [...new Set(['', ...alphabets.flatMap((one) => words(one.value))])].sort();
+    const mask = (value) => alphabetForm.parse({ tokens }, {
+        want: value.startsWith('not:') ? tokens.filter((one) => !words(value).includes(one)) : words(value),
+    });
+    const held = signedIn(alphabetForm.lattice({ tokens }), alphabets.map((one) => [one, mask(one.value)])).members(tokens);
+    return held.includes('') ? tokens.filter((one) => one !== '' && !held.includes(one)).map((one) => `not:${one}`) : held;
+}
+/**
+ * The poles of a region, question by question: each live bound is signed at the region it names and travels by rest, as
+ * the object signs, so the ceiling is what the region reads up its chain of rest, the meet in the lattice of their form, and beside it what the region's cells hold under that question,
+ * value by count. Read off the summaries alone; no cell is visited.
+ */
+export function polesOf(regions, region) {
+    const chain = [];
+    for (let at = region;; at = restsOn(regions.named, at)) {
+        chain.push(at);
+        if (at === '')
+            break;
+    }
+    const asked = new Map();
+    for (const bound of regions.bounds.filter((one) => chain.includes(one.region))) {
+        const key = `${bound.question} ${bound.measure}`;
+        asked.set(key, [...(asked.get(key) ?? []), bound]);
+    }
+    const summary = regions.summaries.get(region);
+    const heldAt = (question, measure) => {
+        const out = new Map();
+        for (const [key, bar] of summary?.values ?? []) {
+            const [asked_, at] = [key.slice(0, key.lastIndexOf(' ')), key.slice(key.lastIndexOf(' ') + 1)];
+            if (at !== measure || !within(point(asked_), coordinates(question)))
+                continue;
+            for (const [value, count] of bar)
+                out.set(value, (out.get(value) ?? 0) + count);
+        }
+        return out.size ? out : undefined;
+    };
+    return new Map([...asked].map(([key, bounds]) => [key, { ceiling: poleAt(regions.named, region, bounds), held: heldAt(bounds[0].question, bounds[0].measure) }]));
+}
+export function regionsOf(standing, ceilings, cells) {
+    const named = regionsNamed(standing);
+    const bounds = ceilings.map((line) => boundOf(named, line));
+    const summaries = new Map();
+    const at = (region) => summaries.get(region)
+        ?? summaries.set(region, { region, cells: 0, sums: new Map(), values: new Map(), bounds: [] }).get(region);
+    for (const region of [...named, ...bounds.map((one) => one.region)])
+        at(region);
+    for (const bound of bounds)
+        at(bound.region).bounds.push(bound);
+    const chains = new Map();
+    const chainOf = (region) => chains.get(region) ?? chains.set(region, region === '' ? [''] : [region, ...chainOf(restsOn(named, region))]).get(region);
+    const globs = [...summaries.keys()].filter(globbed);
+    const placed = new Map();
+    for (const cell of cells) {
+        const key = `${cell.question} ${cell.measure}`;
+        const span = /^(-?\d+(?:\.\d+)?)\.\./.exec(cell.value);
+        const held = placed.get(`${cell.place}\u0000${key}`) ?? placed.set(`${cell.place}\u0000${key}`, { place: cell.place, key, ids: new Set() }).get(`${cell.place}\u0000${key}`);
+        if (span)
+            held.sum = (held.sum ?? 0) + Number(span[1]);
+        else
+            for (const one of cell.value.split('|'))
+                if (one && one !== 'none')
+                    held.ids.add(one);
+    }
+    for (const { place, key, sum, ids } of placed.values()) {
+        const home = regionOf(named, place);
+        const reached = [...chainOf(home), ...globs.filter((glob) => chainOf(home).some((one) => one && matches(glob, one)))];
+        for (const region of new Set(reached)) {
+            const summary = at(region);
+            summary.cells += 1;
+            if (sum !== undefined)
+                summary.sums.set(key, (summary.sums.get(key) ?? 0) + sum);
+            const bars = summary.values.get(key) ?? summary.values.set(key, new Map()).get(key);
+            for (const one of sum !== undefined ? [String(sum)] : ids)
+                bars.set(one, (bars.get(one) ?? 0) + 1);
+        }
+    }
+    return { named, bounds, summaries };
+}
+/**
+ * What a bound bites, read off the summary of its region and never off a cell: the values its region's cells read that
+ * lie outside it, and of those the ones every bound above it still admits. A question finer than a summary is not asked.
+ */
+export function rankOf(regions, bound, own = {}) {
+    const mine_ = own[bound.measure] ?? (bound.measure === 'count' ? own[fieldOf(bound.line, 'scope')] : undefined);
+    if (mine_ !== undefined) {
+        const span = poleAt(regions.named, bound.region, [bound]);
+        const off = span !== undefined && !Array.isArray(span) && (mine_ < span.lo || mine_ > span.hi) ? 1 : 0;
+        return { bars: off, cells: 0, fresh: off, met: 1, sums: off };
+    }
+    const summary = regions.summaries.get(bound.region);
+    if (!summary)
+        return { bars: 0, cells: 0, fresh: 0, met: 0, sums: 0 };
+    const above = regions.bounds.filter((one) => one !== bound && one.measure === bound.measure && one.form === bound.form
+        && within(point(bound.question), coordinates(one.question))
+        && (one.region === '' || bound.region === one.region || bound.region.startsWith(`${one.region}/`) || (globbed(one.region) && matches(one.region, bound.region))));
+    const alone = bound.form === 'alphabet' || bound.measure === 'per-file' || fieldOf(bound.line, 'scope').endsWith('/*');
+    const outside = (value, of) => {
+        if (of === undefined)
+            return false;
+        if (!Array.isArray(of)) {
+            const n = Number(value);
+            return !INTERVALS.leq({ lo: n, hi: n }, of);
+        }
+        const list = of;
+        return list.some((one) => one.startsWith('not:')) ? list.includes(`not:${value}`) : !list.includes(value);
+    };
+    const mine = poleAt(regions.named, bound.region, [bound]);
+    const held = poleAt(regions.named, bound.region, above);
+    let bars = 0;
+    let cells = 0;
+    let fresh = 0;
+    let met = 0;
+    const whole = coordinates(fieldOf(bound.line, 'scope'));
+    const top = regions.summaries.get('') ?? summary;
+    const picked = new Map();
+    const take = (from, holds) => {
+        for (const [key, bar] of from.values) {
+            const [question, measure] = [key.slice(0, key.lastIndexOf(' ')), key.slice(key.lastIndexOf(' ') + 1)];
+            if (!picked.has(key) && measure === bound.measure && holds(question))
+                picked.set(key, { bar, sum: from.sums.get(key) });
+        }
+    };
+    take(top, (question) => within(point(question), whole));
+    take(summary, (question) => within(point(question), coordinates(bound.question)));
+    for (const { bar } of picked.values()) {
+        for (const [value, count] of bar) {
+            met += count;
+            if (!alone || !outside(value, mine))
+                continue;
+            bars += 1;
+            cells += count;
+            if (!outside(value, held))
+                fresh += count;
+        }
+    }
+    const sums = alone ? 0 : [...picked.values()].filter(({ sum }) => sum !== undefined && outside(String(sum), mine)).length;
+    return { bars, cells, fresh, met, sums };
+}
+function ownDigest(summary) {
+    const hash = createHash('sha256');
+    hash.update(`${summary.region}\n${summary.cells}\n`);
+    for (const line of summary.bounds.map((one) => one.line).sort())
+        hash.update(`${line}\n`);
+    for (const key of [...summary.sums.keys()].sort())
+        hash.update(`${key}=${summary.sums.get(key)}\n`);
+    for (const key of [...summary.values.keys()].sort())
+        hash.update(`${key}:${[...summary.values.get(key)].sort(([a], [b]) => (a < b ? -1 : 1)).map(([v, n]) => `${v}*${n}`).join(',')}\n`);
+    return hash.digest('hex');
+}
+export function finerOf(regions) {
+    const finer = new Map();
+    for (const region of regions.summaries.keys())
+        if (region !== '') {
+            const parent = globbed(region) ? '' : restsOn(regions.named, region);
+            finer.set(parent, [...(finer.get(parent) ?? []), region]);
+        }
+    return finer;
+}
+export function digestsOf(regions) {
+    const finer = finerOf(regions);
+    const out = new Map();
+    const digest = (region) => out.get(region) ?? out.set(region, createHash('sha256').update(`${ownDigest(regions.summaries.get(region))}\n${[...(finer.get(region) ?? [])].sort().map(digest).join('\n')}`).digest('hex')).get(region);
+    digest('');
+    return out;
+}
+export function differing(a, b) {
+    const [x, y] = [digestsOf(a), digestsOf(b)];
+    const named = [...new Set([...a.named, ...b.named])];
+    const out = [];
+    let compared = 0;
+    const descend = (region) => {
+        compared += 1;
+        if (x.get(region) === y.get(region))
+            return;
+        const [one, two] = [a.summaries.get(region), b.summaries.get(region)];
+        if (!one || !two || ownDigest(one) !== ownDigest(two))
+            out.push(region);
+        const finer = new Set([...a.summaries.keys(), ...b.summaries.keys()].filter((name) => name !== '' && name !== region
+            && (globbed(name) ? region === '' : restsOn(named, name) === region)));
+        for (const name of [...finer].sort())
+            descend(name);
+    };
+    descend('');
+    return { regions: out, compared };
+}
+export const packRegions = (regions) => ({
+    named: regions.named,
+    bounds: regions.bounds.map((one) => one.line),
+    summaries: [...regions.summaries.values()].map((one) => [one.region, one.cells, [...one.sums], [...one.values].map(([key, bars]) => [key, [...bars]])]),
+});
+export function unpackRegions(packed) {
+    const bounds = packed.bounds.map((line) => boundOf(packed.named, line));
+    return {
+        named: packed.named,
+        bounds,
+        summaries: new Map(packed.summaries.map(([region, cells, sums, values]) => [region, {
+                region, cells, sums: new Map(sums), values: new Map(values.map(([key, bars]) => [key, new Map(bars)])), bounds: bounds.filter((one) => one.region === region),
+            }])),
+    };
+}
+export function unlikeReplay(regions, red, own) {
+    const read = new Map();
+    for (const bound of regions.bounds) {
+        const got = rankOf(regions, bound, own);
+        if (got.met === 0)
+            continue;
+        const scope = fieldOf(bound.line, 'scope');
+        read.set(scope, (read.get(scope) ?? false) || got.cells > 0 || got.sums > 0);
+    }
+    return [...read].filter(([scope, bitten]) => bitten !== red.has(scope)).length;
+}

package/dist/fold/release-policy.d.ts

@@ -0,0 +1,67 @@
+import type { VerdictDemand, VerdictObservation } from '@lapxo/topos/authority';
+type CeilingReading = {
+    readonly read: readonly string[];
+    readonly unread: readonly string[];
+    readonly vacuous: readonly string[];
+    readonly over: readonly {
+        readonly ceiling: string;
+        readonly question: string;
+        readonly got: string;
+        readonly side: 'short' | 'over';
+    }[];
+};
+export interface ReleasePolicyInput {
+    /** Standing already admitted by the same fold. This function does not admit lines. */
+    readonly verdicts?: readonly VerdictObservation[];
+    readonly standing: readonly string[];
+    readonly demands: readonly string[];
+    readonly paid: readonly string[];
+    readonly ceilings: readonly string[];
+    readonly readings: CeilingReading;
+    readonly snapshot: {
+        readonly fold: string;
+        readonly instrument: string;
+    };
+    readonly faults?: readonly {
+        readonly kind: string;
+        readonly evidence: readonly string[];
+        readonly obligation?: string;
+    }[];
+}
+export interface ReleasePolicyResult {
+    readonly gates?: readonly VerdictDemand[];
+    readonly status: 'absent' | 'incomplete' | 'blocked' | 'ready';
+    readonly snapshot: ReleasePolicyInput['snapshot'];
+    readonly policy: readonly string[];
+    readonly categories: readonly {
+        readonly name: string;
+        readonly links: readonly string[];
+        readonly selected: readonly string[];
+        readonly failures: readonly {
+            readonly line: string;
+            readonly reason: string;
+            readonly evidence: readonly string[];
+        }[];
+    }[];
+    readonly unresolved: readonly string[];
+    /** All obligations, including those not selected; the normal fold keeps their verdicts. */
+    readonly debt: readonly string[];
+}
+/** Preserve actual fold faults; none gets a release category from its spelling. */
+export declare function releaseFaults(fold: {
+    readonly forks: readonly {
+        readonly key: string;
+        readonly lines: readonly string[];
+    }[];
+    readonly refused: readonly string[];
+    readonly grey: readonly string[];
+    readonly orphans: readonly string[];
+    readonly second: {
+        readonly verdict: string;
+    };
+}): NonNullable<ReleasePolicyInput['faults']>;
+/** Select declared obligations, never categories inferred from their names or paths. */
+export declare function releasePolicy(input: ReleasePolicyInput): ReleasePolicyResult;
+/** Existing fold output can show the policy without a new view or a release action. */
+export declare function releasePolicyLines(result: ReleasePolicyResult | undefined): readonly string[];
+export {};