@lapxo/bound 0.1.0

package/dist/cli/verb.js

@@ -0,0 +1,478 @@
+#!/usr/bin/env node
+import { resolveSources } from "../host/source-content.js";
+import { cellsWithReceipts } from "../host/cell-receipts.js";
+import { releasePolicyLines } from "../fold/release-policy.js";
+import { admittedObjects } from "../host/objects.js";
+import { objectFold } from "../fold/object.js";
+import { OBJECT_VIEW } from '@lapxo/topos/wire';
+import { toposStanding } from '@lapxo/topos/standing';
+import { wireAt, parse as parseWire } from '@lapxo/topos/wire';
+import { ownLock } from "../observe/runner.js";
+import { signedOwnerLines } from "./owner.js";
+import { existsSync, lstatSync, mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { eraOf, signaturesOf } from "../fold/digests.js";
+import { fullDigest as bootstrapDigest } from "../host/digest.js";
+import { canonical } from '@lapxo/topos/wire';
+import { EXTENSION, LOCK, fieldOf, foldClaims, isWire, selfName } from "../fold/claims.js";
+import { observedClaims } from "../fold/observed.js";
+import { rolesOf } from "../fold/roles.js";
+import { authorityFor, releaseSigner, rootSigner, writerFor } from "../fold/signers.js";
+import { land, ledgerLines, storeOf } from "../land/ledger.js";
+import { lockLines, releaseOf } from "../fold/keys.js";
+import { signConsentLine } from "../land/sign.js";
+import { admittedIn, ownLockOf, tellOwn } from "../fold/signed.js";
+import { hasVouchedTree, landCoordinates, coordinatesOf, locationsOf, vouching, sourced } from "../land/vouched.js";
+import { observeText } from "../observe/files.js";
+import { askWhy, unrendered, viewOf } from "../render/view.js";
+import { openCards } from "../render/open.js";
+import { foldPlace, ownCeilings, standingOf } from "./place.js";
+import { foldPoints, movedPoints } from "../fold/kept.js";
+import { placesOf, sharedShapes, viewsOf } from "../fold/views.js";
+import { placesIn } from "../fold/places.js";
+import { isCeiling } from "../fold/configures.js";
+import { readingsIn } from "../land/inert.js";
+import { pass } from "./pass.js";
+import { underTheLock, underTheRegions } from "../land/act.js";
+import { ownerOf, renderInto, signedDemands, targetFile } from "./owner.js";
+import { claimLinesIn, entryOf, namedPlaces, positionalsOf, valueOf } from "./args.js";
+import { EXIT, FLAGS, NAMED_VIEWS, helpLines } from "./names.js";
+import { accept, signedBatch } from "./accept.js";
+/** The first land of a lock: TARGET.bound into an empty owner ledger, then the sources that lock names. */
+function firstLand(root, args) {
+    const started = Date.now();
+    const store = storeOf(root);
+    const today = claimLinesIn(targetFile(root));
+    const proposed = observeText(targetFile(root));
+    let owner;
+    let keyId;
+    let born;
+    let verified = 0;
+    let anchored;
+    try {
+        if (!today.length)
+            throw new Error('REFUSE·bootstrap the proposed lock holds no claims');
+        const config = eraOf(today);
+        const digestLine = today.find((line) => ['wire/digest-algorithms', 'audit/wire/digest-algorithms'].includes(fieldOf(line, 'scope')) && fieldOf(line, 'value') !== 'withdraw');
+        const algorithm = fieldOf(digestLine ?? '', 'value').split('|').filter(Boolean)[0]?.split(':')[0] ?? '';
+        if (!algorithm)
+            throw new Error('REFUSE·bootstrap the proposed lock names no digest algorithm');
+        owner = writerFor(today, 'authorize') ?? '';
+        if (!owner)
+            throw new Error('REFUSE·bootstrap the proposed lock declares no root authorizer');
+        keyId = valueOf(args, FLAGS.key) ?? owner;
+        if (ledgerLines(store, owner).length)
+            throw new Error('REFUSE·bootstrap the owner ledger already holds claims; the first land happens once');
+        const keyFile = valueOf(args, FLAGS.keyFile);
+        if (keyFile !== undefined) {
+            const pem = observeText(keyFile);
+            if (pem === undefined)
+                throw new Error('REFUSE·bootstrap the requested signing key is unreadable');
+            const signed = [];
+            for (const line of today) {
+                if (/\bsig=/.test(line)) {
+                    signed.push(line);
+                    continue;
+                }
+                const got = signConsentLine(line, pem, { epoch: 1, by: keyId, algorithm: config.era });
+                if (got.kind === 'refuse')
+                    throw new Error(got.why);
+                signed.push(got.line);
+            }
+            today.splice(0, today.length, ...signed);
+        }
+        const said = (measure) => {
+            const values = new Set(today.filter((line) => fieldOf(line, 'scope') === `keys/${owner}` && fieldOf(line, 'measure') === measure && fieldOf(line, 'value') !== 'withdraw').map((line) => fieldOf(line, 'value')));
+            if (values.size !== 1)
+                throw new Error(`REFUSE·bootstrap root key ${owner} must declare one ${measure}`);
+            return [...values][0];
+        };
+        if (said('class') !== 'authorize')
+            throw new Error('REFUSE·bootstrap the root key must authorize');
+        const publicKey = said('public-key');
+        const coverage = said('coverage').split('|').filter(Boolean);
+        if (!publicKey || !coverage.length)
+            throw new Error('REFUSE·bootstrap the root key must declare its public key and coverage');
+        const authority = authorityFor(today, { ...releaseSigner(today), id: owner, publicKey, coverage }, config.admitted);
+        for (const line of today) {
+            const verdict = authority.of(line);
+            if (verdict.kind !== 'admitted')
+                throw new Error(`REFUSE·bootstrap ${fieldOf(line, 'scope')} is not admitted: ${verdict.why ?? verdict.kind}`);
+            verified += 1;
+        }
+        // Source receipts require admitted instrument coordinates before the root commit.
+        vouching(today);
+        sourced(today);
+        born = bootstrapDigest(today.map((line) => line.replace(/ sig="[^"]*"/, '')).sort(), algorithm);
+        anchored = { [owner]: { id: owner, publicKey, coverage } };
+    }
+    catch (error) {
+        process.stderr.write(`${selfName()}: ${error instanceof Error ? error.message : String(error)}\n`);
+        return EXIT.refuse;
+    }
+    // Preflight above performs no writes. Only an admitted batch may establish its root of trust.
+    return underTheLock(store, 'bootstrap', () => {
+        if (ledgerLines(store, owner).length || observeText(targetFile(root)) !== proposed) {
+            process.stderr.write(`${selfName()}: REFUSE·bootstrap the proposed lock or owner ledger changed before commit\n`);
+            return EXIT.refuse;
+        }
+        const landed = land(store, owner, today);
+        if (keyId !== owner)
+            land(store, keyId, today);
+        const file = join(store, `${selfName()}.keys`);
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, `${JSON.stringify(anchored, null, 2)}\n`);
+        const signedLines = today.filter((line) => /\bsig=/.test(line));
+        const failing = signedLines.length - verified;
+        land(store, 'land', [canonical({
+                scope: 'bootstrap', role: 'writes', form: 'alphabet', measure: 'status', value: 'present', by: 'land', at: `bootstrap:${born}`,
+                about: 'the lines this clone was born from: one land per clone, and a second is a fork of the same cell',
+            })]);
+        const rendered = renderInto(root, store);
+        process.stdout.write(`FACT     landed ${landed.appended} unique lines from ${today.length} in TARGET`
+            + ` · ${failing} of ${signedLines.length} signed lines fail admission by declared authority\n`
+            + `TARGET   ${rendered.standing} claims · ${rendered.superseded.length} superseded · ${Date.now() - started} ms\n`);
+        for (const line of rendered.superseded)
+            process.stdout.write(`SUPERSEDED ${line}\n`);
+        if (!hasVouchedTree(store)) {
+            const locations = new Set();
+            const refused = new Set();
+            for (const line of signedDemands(store)) {
+                const got = locationsOf(fieldOf(line, 'needs'));
+                for (const l of got.locations)
+                    locations.add(l);
+                for (const r of got.refused)
+                    refused.add(r);
+            }
+            const coordinates = new Map();
+            const roleOf = rolesOf(store);
+            for (const location of locations)
+                for (const [path, digest] of coordinatesOf(root, location, roleOf))
+                    coordinates.set(path, digest);
+            const vouched = landCoordinates(store, coordinates, [], 'origin:land');
+            process.stdout.write(`FACT     vouched · ${vouched} sources under ${locations.size} locations · ${refused.size} needs refused as globs\n`);
+        }
+        return EXIT.closed;
+    });
+}
+/** What one fold cost, where it was taken and whether its points had already been folded: a beat of the instrument. */
+function beat(root, fold, ms) {
+    const folder = writerFor(fold.standing, 'fold');
+    const seconds = (n) => `${(n / 1000).toFixed(n < 100 ? 2 : 1)} s`;
+    process.stderr.write(`BEAT     fold ${fold.key.slice(0, 8)} ${fold.kept ? 'kept' : 'folded'} ${seconds(ms)}`
+        + `${fold.beats.kept ? ` · ${seconds(fold.beats.kept)} kept` : ''}${fold.beats.folded ? ` · ${seconds(fold.beats.folded)} folded` : ''}\n`);
+    if (folder === undefined)
+        return;
+    if (!fold.kept) {
+        const moved = movedPoints(storeOf(root), foldPoints(storeOf(root), fold.standing, fold.under, folder, fold.instrument), fold.key);
+        const named = moved === undefined ? 'no fold was kept before this one'
+            : `${moved.gone.length} points gone · ${moved.came.length} came · ${[...moved.gone, ...moved.came].slice(0, 3).map((one) => one.split(' ')[0]).join(' ') || 'none'}`;
+        process.stderr.write(`KEPT     fold ${fold.key.slice(0, 8)} miss · ${named}\n`);
+    }
+    land(storeOf(root), folder, [canonical({
+            scope: `beat/${fold.under ?? '.'}`, role: 'writes', form: 'interval', measure: 'ms',
+            value: `${ms}..${ms}`, by: folder, at: `place:${fold.kept ? 'kept' : 'folded'}`,
+        })]);
+}
+/**
+ * A view of a place, rendered from its fold; a shaped one writes the coordinate its shape names. With a batch named, it is the view of the tree
+ * as if the batch had landed: the batch is signed and folded, never landed, and nothing is written — `--as rank <batch>`
+ * is what a batch would move, read before land.
+ */
+async function view(root, under, asked, told = [], coord, key, includePolicy = true) {
+    const [name = asked, depth] = asked.split('@');
+    if (name === NAMED_VIEWS.help) {
+        process.stdout.write(`${helpLines().join('\n')}\n`);
+        return EXIT.closed;
+    }
+    if (!lockLines(storeOf(root)).length) {
+        process.stderr.write(`${selfName()}: the owner ledger is empty; land it before rendering a view\n`);
+        return EXIT.refuse;
+    }
+    const at = Date.now();
+    const place = under?.replace(/\/$/, '');
+    const released = releaseOf(storeOf(root));
+    const authority = authorityFor([...released ?? lockLines(storeOf(root)), ...told], released ? releaseSigner(released) : rootSigner(root), signaturesOf(storeOf(root), told).admitted);
+    const ledger = told.filter((line) => authority.of(line).kind === 'admitted');
+    const rest = told.filter((line) => !ledger.includes(line));
+    if (place && rest.length)
+        tellOwn(place, rest);
+    const own = place ? rest.filter((line) => admittedIn(root, place, line)) : [];
+    const fold = told.length
+        ? foldPlace(root, entryOf(root), under, false, { standing: standingOf(root, under, ledger), observed: observedClaims(root, storeOf(root), { wait: false }) })
+        : foldPlace(root, entryOf(root), under, false);
+    if (coord)
+        askWhy(fold, coord);
+    if (name === NAMED_VIEWS.lines) {
+        if (!told.length)
+            beat(root, fold, Date.now() - at);
+        const text = fold.standing.filter(isWire).join('\n');
+        process.stdout.write(text ? `${text}\n` : '');
+        return EXIT.closed;
+    }
+    const views = viewsOf(fold.standing);
+    const cellsView = [...views.entries()].find(([, one]) => !one.shape && one.regions.some((region) => region.name === 'cells'));
+    if (cellsView && name === cellsView[0]) {
+        const history = signedOwnerLines(storeOf(root));
+        const { objectHistory } = await import('@lapxo/topos/wire');
+        const parsed = objectHistory(history);
+        if (parsed.kind !== 'fact')
+            throw Error(`REFUSE·wire ${parsed.why}`);
+        if (parsed.value.objects.length) {
+            await cellsWithReceipts(root, history, text => process.stdout.write(text + '\n'));
+            if (includePolicy)
+                for (const line of releasePolicyLines(fold.release))
+                    process.stdout.write(line + '\n');
+            if (!told.length)
+                beat(root, fold, Date.now() - at);
+            return EXIT.closed;
+        }
+        if (!told.length)
+            beat(root, fold, Date.now() - at);
+        const cells = fold.open ?? [];
+        const mine = key ? cells.filter((cell) => cell.origins.includes(key)) : cells;
+        const cards = openCards(mine);
+        if (key)
+            process.stdout.write(`KEY      ${key}\n`);
+        if (cards.length)
+            process.stdout.write(`${cards.join('\n')}\n`);
+        return EXIT.closed;
+    }
+    if (!told.length)
+        beat(root, fold, Date.now() - at);
+    if (name === 'rank') {
+        const asked = place ? [place] : placesIn(root);
+        const reds = asked.flatMap((one) => sharedShapes(ownLockOf(root, one)).map((said) => `${one} ${said}`));
+        if (reds.length) {
+            process.stderr.write(`${selfName()}: REFUSE·rank ${reds.join(' · ')}: two views naming the same shape in one place\n`);
+            return EXIT.refuse;
+        }
+    }
+    const signed = views.get(name);
+    if (!signed) {
+        process.stderr.write(`${selfName()}: no view/${name} is signed; the lock signs ${[...views.keys()].sort().map((v) => `view/${v}`).join(' · ') || 'no view'}\n`);
+        return EXIT.usage;
+    }
+    const missing = unrendered(fold, signed);
+    if (missing.length) {
+        process.stderr.write(`${selfName()}: REFUSE·view view/${name} asks regions nothing renders: ${missing.join(' ')} · none is the instrument's own and no capsule ${under ?? 'the root'} can run declares it\n`);
+        return EXIT.refuse;
+    }
+    const bound = placesOf(fold.standing, signed);
+    if (bound.length && !bound.includes(under ?? '')) {
+        process.stderr.write(`${selfName()}: view/${name} writes ${bound.map((place) => `${place}${signed.shape}`).join(' · ')}, and nothing of ${under ?? 'this place'}\n`);
+        return EXIT.usage;
+    }
+    const folder = writerFor(fold.standing, 'fold');
+    if (folder !== undefined && !told.length) {
+        const spent = Date.now() - at;
+        land(storeOf(root), folder, [canonical({
+                scope: `beat/${under ?? '.'}`, role: 'writes', form: 'interval', measure: 'ms',
+                value: `${spent}..${spent}`, by: folder, at: `place:command-${fold.kept ? 'kept' : 'folded'}`,
+            })]);
+    }
+    const shown = (fold) => {
+        const text = viewOf(fold, Number.isFinite(Number(depth)) && depth !== undefined ? { ...signed, regions: signed.regions.map((one) => (one.called ? { ...one, at: Number(depth) } : one)) } : signed);
+        if (process.argv.includes(FLAGS.check)) {
+            const coordinate = join(root, under ?? '', signed.shape || '');
+            const held = signed.shape ? observeText(coordinate) : undefined;
+            const same = held !== undefined && held === text;
+            if (same) {
+                process.stdout.write(`SAME     ${signed.shape || `view/${name}`}\n`);
+                return EXIT.closed;
+            }
+            const heldLines = (held ?? '').split('\n');
+            const next = text.split('\n');
+            const found = heldLines.findIndex((line, i) => line !== next[i]);
+            const at = found < 0 ? Math.min(heldLines.length, next.length) : found;
+            const line = (found < 0 ? next[at] : heldLines[at]) ?? next[at] ?? '';
+            process.stdout.write(`DIFFERS     ${signed.shape || `view/${name}`}${held === undefined ? ' · this place holds no such region' : ` · line ${at + 1} · ${line}`}\n`);
+            return EXIT.refuse;
+        }
+        if (!signed.shape || told.length) {
+            if (told.length) {
+                process.stdout.write(`TOLD     ${told.length} lines folded as if landed · ${ledger.length} in the ledger · ${own.length} in ${place ?? 'the root'}'s own lock`
+                    + `${rest.length - own.length ? ` · ${rest.length - own.length} admitted nowhere` : ''} · the batch lands nothing and nothing is written\n`);
+            }
+            process.stdout.write(text);
+            if (depth === '1')
+                for (const line of readingsIn(told.length ? told.filter(isCeiling) : [...fold.standing.filter(isCeiling), ...ownCeilings(under)], fold))
+                    process.stdout.write(`${line}\n`);
+            return EXIT.closed;
+        }
+        const coordinate = join(root, under ?? '', signed.shape);
+        return underTheRegions(storeOf(root), [under ?? ''], `view/${name}`, () => {
+            mkdirSync(dirname(coordinate), { recursive: true });
+            writeFileSync(coordinate, text);
+            process.stdout.write(`RENDERED ${relative(root, coordinate).split(sep).join('/')} · view/${name} · ${text.split('\n').length - 1} lines\n`);
+            return EXIT.closed;
+        });
+    };
+    return shown(fold);
+}
+async function signVerb(root, rest) {
+    const batch = await signedBatch(root, rest, positionalsOf(rest));
+    if (batch.kind === 'exit')
+        return batch.code;
+    if (batch.kind === 'once') {
+        process.stderr.write(`ONCE     ${batch.proposed.length} lines · every one already landed: nothing to sign\n`);
+        return EXIT.closed;
+    }
+    for (const place of namedPlaces(rest))
+        process.stdout.write(`# place ${place}\n`);
+    for (const line of batch.signed)
+        process.stdout.write(`${line}\n`);
+    process.stderr.write(`SIGNED   ${batch.signed.length} lines · epoch ${batch.epoch}${namedPlaces(rest).length ? ` · own lines for ${namedPlaces(rest).join(', ')}` : ''} · they land together, before the lock moves\n`);
+    return EXIT.closed;
+}
+async function landVerb(root, rest) {
+    const lock = resolve(targetFile(root));
+    const batch = positionalsOf(rest).filter((one) => {
+        const at = resolve(one);
+        return existsSync(at) && !lstatSync(at).isDirectory() && at !== lock;
+    });
+    if (!batch.length) {
+        const store = storeOf(root);
+        if (existsSync(join(store, 'ledger')) && ledgerLines(store, ownerOf(store)).length) {
+            process.stderr.write(`${selfName()}: REFUSE·bootstrap the owner ledger already holds claims; provide an explicit signed batch to change it\n`);
+            return EXIT.refuse;
+        }
+        return firstLand(root, rest);
+    }
+    const die = (why) => {
+        process.stderr.write(`${selfName()}: ${why.startsWith('REFUSE·') ? why : `REFUSE·crash ${why}`}\n`);
+        process.exitCode = EXIT.refuse;
+    };
+    process.once('SIGINT', () => die('SIGINT'));
+    process.once('SIGHUP', () => die('SIGHUP'));
+    process.once('uncaughtException', (error) => die(error instanceof Error ? error.message : String(error)));
+    process.once('unhandledRejection', (error) => die(error instanceof Error ? error.message : String(error)));
+    try {
+        return await accept(root, rest);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${selfName()}: ${message.startsWith('REFUSE·') ? message : `REFUSE·crash ${message}`}\n`);
+        return EXIT.refuse;
+    }
+}
+function foldFile(at) {
+    const lines = claimLinesIn(at);
+    const folded = foldClaims(lines);
+    const fields = folded.standing.flatMap(line => { const got = parseWire(line); return got.kind === 'fact' ? [got.value.fields] : []; });
+    const isTopos = fields.some(f => f.scope?.startsWith('region/') && f.measure === 'reads');
+    if (isTopos && folded.forks.length)
+        throw Error('REFUSE·topos incompatible live claims in declared fold');
+    const selected = isTopos ? toposStanding(folded.standing) : undefined;
+    if (selected !== undefined) {
+        const wire = wireAt(ownLock().flatMap(line => { const got = parseWire(line); return got.kind === 'fact' ? [got.value.fields] : []; }), Number.MAX_SAFE_INTEGER);
+        const algorithm = wire?.digests.values().next().value;
+        if (!algorithm)
+            throw Error('REFUSE·topos instrument names no digest algorithm');
+        process.stdout.write(selected.split('\n').filter(Boolean).map(line => 'TOPOS ' + line).join('\n') + '\n');
+        process.stdout.write('PIN ' + bootstrapDigest([selected], algorithm) + '\n');
+    }
+    for (const line of folded.standing)
+        process.stdout.write(`${line}\n`);
+    for (const fork of folded.forks)
+        process.stdout.write(`FORK     ${fork.key}${fork.state ? ` · ${fork.state}` : ''}\n`);
+    process.stdout.write(`FACT     ${folded.standing.length} standing · ${folded.forks.length} forks · ${basename(at)}\n`);
+    return EXIT.closed;
+}
+function foldVerb(_root, rest) {
+    const files = positionalsOf(rest).filter((one) => existsSync(resolve(one)) && !lstatSync(resolve(one)).isDirectory() && one.endsWith(EXTENSION));
+    const places = positionalsOf(rest).filter((one) => existsSync(resolve(one)) && lstatSync(resolve(one)).isDirectory());
+    if (files.length === 1 && !places.length && valueOf(rest, FLAGS.as) === undefined) {
+        const at = resolve(files[0]);
+        if (!at.endsWith(`/${LOCK}`) && at !== LOCK)
+            return foldFile(at);
+        return foldAt(dirname(at), undefined, rest);
+    }
+    const under = places[0];
+    const tree = files.length === 1 ? dirname(resolve(files[0])) : resolve('.');
+    const place = under ? relative(tree, resolve(under)).split(sep).join('/') : '';
+    return foldAt(tree, place ? `${place}/` : undefined, rest);
+}
+async function foldAt(root, under, argv) {
+    const as = valueOf(argv, FLAGS.as);
+    if (as !== NAMED_VIEWS.help && signedOwnerLines(storeOf(root)).length)
+        await resolveSources(standingOf(root, under).standing);
+    if (as === OBJECT_VIEW) {
+        const inputs = positionalsOf(argv).filter(one => existsSync(resolve(one)) && !lstatSync(resolve(one)).isDirectory());
+        if (inputs.length > 1)
+            throw Error('REFUSE·object one history snapshot per fold');
+        const history = inputs.length ? claimLinesIn(inputs[0]) : signedOwnerLines(storeOf(root));
+        const held = await admittedObjects(root, history, text => process.stdout.write(text + '\n'));
+        const cells = objectFold(held.records, held.context);
+        for (const c of cells)
+            process.stdout.write('CELL ' + JSON.stringify(c) + '\n');
+        process.stdout.write(`FACT     object fold ${cells.length} cells\n`);
+        return EXIT.closed;
+    }
+    const key = valueOf(argv, FLAGS.key);
+    if (as === undefined) {
+        const exit = await pass(root, entryOf(root), under, argv.includes(FLAGS.check));
+        if (exit !== 0)
+            return exit;
+        const history = signedOwnerLines(storeOf(root));
+        const { objectHistory } = await import('@lapxo/topos/wire');
+        const parsed = objectHistory(history);
+        if (parsed.kind !== 'fact')
+            throw Error(`REFUSE·wire ${parsed.why}`);
+        if (parsed.value.objects.length) {
+            const signedCells = [...viewsOf(history).values()].find(one => !one.shape && one.regions.some(region => region.name === 'cells'));
+            if (!signedCells)
+                throw Error('REFUSE·view object cells require a signed cells view');
+            return view(root, under, signedCells.name, [], undefined, undefined, false);
+        }
+        return exit;
+    }
+    const named = positionalsOf(argv).filter((one) => existsSync(resolve(one)) && !lstatSync(resolve(one)).isDirectory());
+    const coord = positionalsOf(argv).find((one) => one !== under?.replace(/\/$/, '') && !one.startsWith('-') && !(existsSync(resolve(one)) && lstatSync(resolve(one)).isDirectory()));
+    if ((as === 'why' || as === NAMED_VIEWS.because || as.split('@')[0] === 'why') && coord !== undefined)
+        return view(root, under, as === NAMED_VIEWS.because ? 'why' : as, [], coord, key);
+    if (!named.length)
+        return view(root, under, as, [], undefined, key);
+    const batch = await signedBatch(root, argv, named);
+    if (batch.kind === 'exit')
+        return batch.code;
+    if (batch.kind === 'once')
+        process.stdout.write(`ONCE     ${batch.proposed.length} lines · every one already landed: the view folds the tree as it stands\n`);
+    return view(root, under, as, batch.kind === 'signed' ? batch.signed : [], undefined, key);
+}
+const VERBS = {
+    fold: (root, rest) => foldVerb(root, rest),
+    land: (root, rest) => landVerb(root, rest),
+    sign: (root, rest) => signVerb(root, rest),
+};
+function main(argv) {
+    const verb = argv[0] ?? '';
+    const run = verb in VERBS ? VERBS[verb] : undefined;
+    const places = positionalsOf(run === undefined ? argv : argv.slice(1)).filter((one) => existsSync(resolve(one)) && lstatSync(resolve(one)).isDirectory());
+    if (run !== undefined)
+        return run(resolve(places[0] ?? '.'), argv.slice(1), argv);
+    const under = argv[0] ?? '';
+    if (under && !under.startsWith('-') && places.includes(under)) {
+        const root = resolve('.');
+        const place = relative(root, resolve(under)).split(sep).join('/');
+        return foldAt(root, place ? `${place}/` : undefined, argv);
+    }
+    process.stderr.write(`${selfName()}: ${helpLines().join(' · ')}\n`);
+    return EXIT.usage;
+}
+// The same refusal boundary covers synchronous operations and asynchronous processes.
+const refused = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${selfName()}: ${message.startsWith('REFUSE·') ? message : `REFUSE·crash ${message}`}\n`);
+    process.exitCode = EXIT.refuse;
+};
+try {
+    const ran = main(process.argv.slice(2));
+    if (ran instanceof Promise)
+        ran.then((code) => { process.exitCode = code; }).catch(refused);
+    else
+        process.exitCode = ran;
+}
+catch (error) {
+    refused(error);
+}

package/dist/fold/ceilings.d.ts

@@ -0,0 +1,24 @@
+type Side = 'short' | 'over';
+export interface CeilingFold {
+    readonly read: readonly string[];
+    readonly over: readonly {
+        readonly ceiling: string;
+        readonly question: string;
+        readonly got: string;
+        readonly side: Side;
+    }[];
+    readonly unread: readonly string[];
+    readonly vacuous: readonly string[];
+    readonly readings: ReadonlyMap<string, readonly string[]>;
+}
+export declare const answersElsewhere: (ceiling: string, own: Readonly<Record<string, number>>, under?: string, places?: ReadonlySet<string>) => boolean;
+export declare function foldCeilings(input: {
+    readonly standing: readonly string[];
+    readonly ceilings: readonly string[];
+    readonly observed: readonly string[];
+    readonly own: Readonly<Record<string, number>>;
+    readonly epoch: number;
+    readonly under?: string;
+    readonly places?: ReadonlySet<string>;
+}): CeilingFold;
+export {};

package/dist/fold/ceilings.js

@@ -0,0 +1,129 @@
+import { point, region, within } from '@lapxo/obligations/field';
+import { fieldOf } from "./claims.js";
+import { wordOf, wordsOf } from "./wire.js";
+import { lockStanding } from "./keys.js";
+import { ownLock, ownStore } from "../observe/runner.js";
+import { ALPHABETS, idsOf, INTERVALS, spanOf } from '@lapxo/topos/forms';
+import { placedReadings } from "./observed.js";
+import { combine, matches } from '@lapxo/topos/wire';
+function meeting(scope) {
+    const whole = region(scope);
+    const steps = scope.split('/');
+    const cuts = steps.slice(1).map((_, i) => ({ head: region(steps.slice(0, i + 1).join('/')), tail: region(steps.slice(i + 1).join('/')) }));
+    const globbed = steps.some((step) => step.includes('*') && step !== '*' && step !== '**');
+    return (reading) => within(reading.asked, whole)
+        || cuts.some(({ head, tail }) => (within(reading.asked, head) && within(reading.where, tail))
+            || (within(reading.where, head) && within(reading.asked, tail)))
+        || (globbed && steps.slice(1).some((_, i) => matches(steps.slice(0, i + 1).join('/'), reading.question) && matches(steps.slice(i + 1).join('/'), reading.where.at.join('/'))));
+}
+export const answersElsewhere = (ceiling, own, under, places) => {
+    const measure = fieldOf(ceiling, 'measure');
+    const step = fieldOf(ceiling, 'scope').split('/')[0] ?? '';
+    const here = under?.split('/')[0];
+    return here !== undefined && step !== here && (places?.has(step) ?? false) && (own[measure] ?? (measure === 'count' ? own[fieldOf(ceiling, 'scope')] : undefined)) !== undefined;
+};
+export function foldCeilings(input) {
+    const readings = new Map();
+    for (const got of placedReadings(input.observed)) {
+        const mine = readings.get(got.measure) ?? [];
+        mine.push({ question: got.question, measure: got.measure, value: got.value, asked: point(got.question), where: point(got.place) });
+        readings.set(got.measure, mine);
+    }
+    const unreadOf = (standing) => wordsOf(standing, 'states').includes('unread') ? wordOf(standing, 'states', 'unread') : undefined;
+    const UNREAD = unreadOf(input.standing) ?? unreadOf(ownLock()) ?? unreadOf(lockStanding(ownStore()));
+    const read = [];
+    const over = [];
+    const unmet = [];
+    const lines = new Map();
+    for (const one of readings.get('line') ?? []) {
+        lines.set(`${one.question} ${one.where.at.join('/')}`, new Map(one.value.split('|').filter(Boolean).map((pair) => [pair.slice(0, pair.lastIndexOf(':')), pair.slice(pair.lastIndexOf(':') + 1)])));
+    }
+    const said = new Map();
+    const bound = (ceiling, question, met, at) => {
+        const scope = fieldOf(ceiling, 'scope');
+        const want = fieldOf(ceiling, 'value');
+        const heard = (got) => void said.set(scope, [...(said.get(scope) ?? []), question === scope ? got : `${question} ${got}`]);
+        if (fieldOf(ceiling, 'form') === 'interval') {
+            const span = spanOf(want);
+            if (!span)
+                return;
+            const lows = met.map((value) => spanOf(value)?.lo ?? 0);
+            let total;
+            try {
+                total = combine(fieldOf(ceiling, 'measure'), lows);
+            }
+            catch {
+                over.push({ ceiling: scope, question, got: `no combination for ${fieldOf(ceiling, 'measure')}, read ${lows.length} times`, side: 'over' });
+                return;
+            }
+            const at = { lo: total, hi: total };
+            heard(String(total));
+            if (!INTERVALS.leq(at, { lo: span.lo, hi: Infinity }))
+                over.push({ ceiling: scope, question, got: String(total), side: 'short' });
+            if (!INTERVALS.leq(at, { lo: -Infinity, hi: span.hi }))
+                over.push({ ceiling: scope, question, got: String(total), side: 'over' });
+            return;
+        }
+        const joined = new Set(met.flatMap((value) => [...idsOf(value).values]));
+        heard([...joined].sort().join('|') || 'none');
+        const allowed = idsOf(want);
+        if (!ALPHABETS.leq({ polarity: 'permit', values: joined }, allowed)) {
+            const outside = [...joined].filter((id) => allowed.values.has(id) === (allowed.polarity === 'forbid')).sort();
+            const line = (id) => (at === undefined || lines.get(at)?.get(id) === undefined ? id : `${id}:${lines.get(at).get(id)}`);
+            over.push({ ceiling: scope, question, got: outside.map(line).join('|'), side: 'over' });
+        }
+    };
+    const own = (measure) => (measure === UNREAD ? undefined : input.own[measure]);
+    // A coordinate projected into this place is not a narrower question merely
+    // because its host prefix adds a segment.
+    const localScope = (scope) => input.under && scope.startsWith(input.under)
+        ? scope.slice(input.under.length) : scope;
+    const literal = (scope) => localScope(scope).split('/').filter((step) => !step.includes('*')).length;
+    const last = [];
+    for (const ceiling of input.ceilings) {
+        const measure = fieldOf(ceiling, 'measure');
+        if (measure === UNREAD) {
+            last.push(ceiling);
+            continue;
+        }
+        const mine = own(measure) ?? (measure === 'count' ? input.own[fieldOf(ceiling, 'scope')] : undefined);
+        if (answersElsewhere(ceiling, input.own, input.under, input.places))
+            continue;
+        if (mine !== undefined) {
+            read.push(ceiling);
+            bound(ceiling, fieldOf(ceiling, 'scope'), [`${mine}..${mine}`]);
+            continue;
+        }
+        const byQuestion = new Map();
+        const where = new Map();
+        const meets = meeting(fieldOf(ceiling, 'scope'));
+        const alone = measure === 'per-file' || fieldOf(ceiling, 'scope').endsWith('/*') || fieldOf(ceiling, 'form') === 'alphabet';
+        const narrower = spanOf(fieldOf(ceiling, 'value')) ? input.ceilings.filter((other) => fieldOf(other, 'measure') === measure && spanOf(fieldOf(other, 'value')) && literal(fieldOf(other, 'scope')) > literal(fieldOf(ceiling, 'scope'))).map((other) => meeting(fieldOf(other, 'scope'))) : [];
+        for (const reading of readings.get(measure) ?? []) {
+            if (!meets(reading) || narrower.some((one) => one(reading)))
+                continue;
+            const question = alone ? reading.where.at.join('/') : reading.question;
+            byQuestion.set(question, [...(byQuestion.get(question) ?? []), reading.value]);
+            where.set(question, `${reading.question} ${reading.where.at.join('/')}`);
+        }
+        if (!byQuestion.size) {
+            unmet.push(ceiling);
+            continue;
+        }
+        read.push(ceiling);
+        for (const [question, met] of byQuestion)
+            bound(ceiling, question, met, where.get(question));
+    }
+    for (const ceiling of last) {
+        read.push(ceiling);
+        bound(ceiling, fieldOf(ceiling, 'scope'), [`${unmet.length}..${unmet.length}`]);
+    }
+    const epochOf = (line) => Number(fieldOf(line, 'epoch')) || 0;
+    return {
+        read,
+        over,
+        unread: unmet.filter((line) => epochOf(line) > input.epoch - 3),
+        vacuous: unmet.filter((line) => epochOf(line) <= input.epoch - 3),
+        readings: said,
+    };
+}

package/dist/fold/claims.d.ts

@@ -0,0 +1,25 @@
+export { CAPSULE, EXTENSION, LOCK, RECEIPTS } from '@lapxo/topos/wire';
+export declare const fieldOf: (line: string, name: string) => string;
+export declare const fieldsOf: (line: string) => Record<string, string>;
+export declare function selfName(): string;
+export declare function isWire(line: string): boolean;
+export declare const wireLinesOf: (text: string | undefined) => readonly string[];
+export declare const isConfig: (line: string) => boolean;
+export declare const sayingOf: (line: string) => string;
+/** One key per claim: scope, role and measure; what a line says, its envelope set aside, is one however often it landed. */
+export declare function claimKey(line: string): string;
+export interface Fork {
+    readonly key: string;
+    readonly lines: readonly string[];
+    readonly state?: string;
+}
+export declare function foldClaims(lines: readonly string[], receipts?: readonly {
+    readonly scope: string;
+    readonly moved: readonly string[];
+}[], _placed?: boolean): {
+    readonly standing: readonly string[];
+    readonly superseded: readonly string[];
+    readonly retracted: readonly string[];
+    readonly forks: readonly Fork[];
+    readonly vacuous: readonly string[];
+};