@lapxo/bound 0.1.0

package/dist/cli/place.js

@@ -0,0 +1,290 @@
+import { timing } from "../host/timing.js";
+import { attestationObservations } from "../fold/evidence.js";
+import { parse as parseEvidenceFields } from '@lapxo/topos/wire';
+import { releasePolicy, releaseFaults } from "../fold/release-policy.js";
+import { point, region, within } from '@lapxo/obligations/field';
+import { basename, join } from 'node:path';
+import { observeText } from "../observe/files.js";
+import { placesOf, viewsOf } from "../fold/views.js";
+import { prerender, viewOf } from "../render/view.js";
+import { meets } from "../fold/closed.js";
+import { foldPoints, keepFold, keptPlace } from "../fold/kept.js";
+import { openCells } from "../render/open.js";
+import { boundOf, packRegions, regionsNamed, regionsOf, unlikeReplay } from "../fold/region.js";
+import { answersElsewhere, foldCeilings } from "../fold/ceilings.js";
+import { keyOf, keyFor, lockLines, lockStanding } from "../fold/keys.js";
+import { wordFrom, wordOf, wordOn } from "../fold/wire.js";
+import { bytesDigest, instrumentOf, signaturesOf } from "../fold/digests.js";
+import { claimKey, fieldOf, fieldsOf, isWire } from "../fold/claims.js";
+import { canonical, LOCK, parse } from '@lapxo/topos/wire';
+import { classDefaults, kindsOf, placesIn, spoken } from "../fold/places.js";
+import { isCeiling } from "../fold/configures.js";
+import { observedClaims, placedReadings } from "../fold/observed.js";
+import { capsuleReadingsOver } from "../observe/regions.js";
+import { costReadings, ownReadings } from "../fold/own.js";
+import { paidOf } from "../fold/paid.js";
+import { rolesOf } from "../fold/roles.js";
+import { secondHead } from "../fold/second.js";
+import { authorityFor, rootSigner, writerFor } from "../fold/signers.js";
+import { ledgerLines, storeOf } from "../land/ledger.js";
+import { vouchedCoordinates } from "../land/vouched.js";
+import { ownLock, ownRoot } from "../observe/runner.js";
+import { epochOf, historyOf, renderedLock, standingDemands } from "./owner.js";
+function beatsOf(store, standing, under) {
+    const folder = writerFor(standing, 'fold');
+    const middle = (at) => {
+        const ms = (folder === undefined ? [] : ledgerLines(store, folder))
+            .filter((line) => fieldOf(line, 'scope') === `beat/${under ?? '.'}` && fieldOf(line, 'at') === `place:${at}`)
+            .map((line) => Number(fieldOf(line, 'value').split('..')[0])).filter((one) => Number.isFinite(one)).slice(-10).sort((a, b) => a - b);
+        return ms.length ? ms[Math.floor(ms.length / 2)] ?? 0 : 0;
+    };
+    return { kept: middle('kept'), folded: middle('folded') };
+}
+const costsOf = (store) => ledgerLines(store, 'take').filter((line) => fieldOf(line, 'measure') === 'ms')
+    .map((line) => Number(fieldOf(line, 'value').split('..')[0])).filter((ms) => Number.isFinite(ms)).slice(-10);
+function effectStates(_store) {
+    return 'none';
+}
+function listed(misses) {
+    const by = new Map();
+    for (const o of misses)
+        by.set(o.ceiling, [...(by.get(o.ceiling) ?? []), o.question === o.ceiling ? o.got : `${o.question}=${o.got}`]);
+    return [...by].map(([scope, got]) => `${scope} · ${got.length > 4 ? `${got.slice(0, 4).join(' ')} +${got.length - 4}` : got.join(' ')}`);
+}
+/**
+ * The fold of a place: the standing lock and what readers saw, narrowed to the place when one is named. A demand is the
+ * place's when every place it asks about lies there; a SHORT on a question also read outside it is not the place's to
+ * answer. The count of a place's own readings is the instrument's, taken inside the place alone. What each key has
+ * signed that stands is counted apart: the owner's lines stand in this fold, a second head's in its own ledger, and its
+ * word on a lock is asked once for the lines a batch and the ledger own together.
+ */
+const counted = new WeakMap();
+const seconds = new WeakMap();
+function secondOf(root, store, attested, owned) {
+    const held = seconds.get(owned);
+    if (held !== undefined)
+        return held;
+    const head = keyOf(store, 'attest');
+    const heard = head === undefined ? undefined : authorityFor([...owned, ...ledgerLines(store, head)], rootSigner(root), signaturesOf(store).admitted);
+    return seconds.set(owned, secondHead(store, attested, (line) => heard?.of(line).kind === 'admitted', owned)).get(owned);
+}
+function signedByKey(store, standing, observed) {
+    const signed = new Map();
+    const reader = (() => {
+        try {
+            return keyFor(store, 'read');
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    for (const line of standing)
+        signed.set(fieldOf(line, 'by'), (signed.get(fieldOf(line, 'by')) ?? 0) + 1);
+    for (const line of standing) {
+        const key = /^keys\/([^/]+)$/.exec(fieldOf(line, 'scope'))?.[1];
+        const lines = key === undefined || signed.has(key) ? undefined : key === reader ? observed : ledgerLines(store, key);
+        if (key !== undefined && lines !== undefined)
+            signed.set(key, counted.get(lines) ?? counted.set(lines, new Set(lines.filter(line => fieldOf(line, 'sig') !== '')).size).get(lines));
+    }
+    return signed;
+}
+/** Generic view checks: declared output equality and one writer per coordinate. Domain measurements belong to selected providers. */
+function viewReadings(place) {
+    const leaf = wordOn(place.standing, 'region-leaf', ownLock());
+    const at = (coordinate) => join(place.root, place.under ?? '', coordinate);
+    const every = [...viewsOf(place.standing).values()].flatMap((view) => ('regions' in view && view.shape ? [view] : []))
+        .filter((view) => observeText(at(view.shape)) !== undefined);
+    const named = (view) => placesOf(place.standing, view).includes(place.under ?? '');
+    const shaped = every.filter((view) => named(view) || (!placesOf(place.standing, view).length && !every.some((other) => other.shape === view.shape && named(other))));
+    prerender(place, shaped);
+    const same = new Set(shaped.filter((view) => observeText(at(view.shape)) === viewOf(place, view)).map((view) => view.name));
+    const differ = shaped.length - same.size;
+    const twice = [...every.filter((view) => named(view) || !placesOf(place.standing, view).length)
+            .reduce((by, view) => by.set(view.shape, (by.get(view.shape) ?? 0) + 1), new Map()).values()].filter((n) => n > 1).length;
+    return { readings: { [`rendered-${leaf}-differ`]: differ, 'rendered-coordinates-differ': differ, [`${leaf}-with-two-views`]: twice, 'coordinates-with-two-views': twice }, same, here: new Set(shaped.map(view => view.name)) };
+}
+const NONE = [];
+const ownings = new WeakMap();
+const ownedOf = (store, told) => ((lock) => ((byLock) => byLock.get(told) ?? byLock.set(told, [...lock, ...told]).get(told))(ownings.get(lock) ?? ownings.set(lock, new WeakMap()).get(lock)))(lockLines(store));
+export function standingOf(root, under, told = NONE) {
+    const store = storeOf(root);
+    const owned = ownedOf(store, told);
+    const rendered = renderedLock(root, store, told);
+    const lock = rendered.text.split('\n').filter(isWire);
+    const said = spoken(root);
+    if (!said.length)
+        return { standing: lock, lock, rendered, owned };
+    const views = `${wordOf(lock, 'families', 'view')}/`;
+    const isView = (line) => fieldOf(line, 'scope').startsWith(views);
+    const ruled = new Set(said.filter((one) => !isView(one.line)).map((one) => claimKey(one.line)));
+    const owners = new Map();
+    for (const one of said.filter((o) => isView(o.line)))
+        owners.set(fieldOf(one.line, 'scope'), (owners.get(fieldOf(one.line, 'scope')) ?? new Set()).add(`${one.place}/`));
+    const tree = lock.flatMap((line) => {
+        const by = isView(line) ? owners.get(fieldOf(line, 'scope')) : undefined;
+        if (by === undefined)
+            return ruled.has(claimKey(line)) ? [] : [line];
+        const needs = fieldOf(line, 'needs').split('|').filter(Boolean);
+        const left = needs.filter((need) => ![...by].some((place) => need.startsWith(place)));
+        if (!needs.length || left.length === needs.length)
+            return [line];
+        const got = parse(line);
+        return left.length && got.kind === 'fact' ? [canonical({ ...got.value.fields, needs: left.join('|') })] : [];
+    });
+    const here = under?.replace(/\/$/, '');
+    const first = said.filter((one) => one.place === here).map((one) => one.line);
+    const rest = said.filter((one) => one.place !== here).map((one) => one.line);
+    const standing = [...new Set([...first, ...tree, ...rest])];
+    return { standing: [...standing, ...inheritedOf(root, standing)], lock, rendered, owned };
+}
+function inheritedOf(root, standing) {
+    const defaults = classDefaults(root);
+    if (!defaults.length)
+        return [];
+    const held = standing.filter(isCeiling);
+    const extra = [];
+    for (const place of placesIn(root)) {
+        const kinds = kindsOf(root, place);
+        const prefix = `${place}/`;
+        const measures = new Set(held.filter((line) => fieldOf(line, 'scope').startsWith(prefix)).map((line) => fieldOf(line, 'measure')));
+        for (const def of defaults) {
+            if (!def.classes.includes('*') && !def.classes.some((kind) => kinds.includes(kind)))
+                continue;
+            const measure = fieldOf(def.line, 'measure');
+            if (measures.has(measure))
+                continue;
+            const got = parse(def.line);
+            if (got.kind !== 'fact')
+                continue;
+            extra.push(canonical({ ...got.value.fields, scope: `${prefix}${fieldOf(def.line, 'scope')}` }));
+            measures.add(measure);
+        }
+    }
+    return extra;
+}
+export function coneOf(root, entry, ceilings, descent) {
+    const store = storeOf(root);
+    const { standing, rendered } = standingOf(root);
+    const named = regionsNamed(standing);
+    const reach = descent !== undefined && descent.length ? [...descent] : [...new Set(ceilings.map((line) => boundOf(named, line).region))];
+    const read = observedClaims(root, store, { wait: false, ...(reach.includes('') ? {} : { reach }) });
+    const observed = [...read, ...capsuleReadingsOver({ root, store, standing, observed: read })];
+    const own = {
+        ...ownReadings({ root, store, entry, roleOf: rolesOf(store), standing, observed, unadmitted: rendered.grey.length + rendered.refused.length, orphans: 0 }),
+        ...costReadings(store, standing),
+    };
+    const measured = new Set([...Object.keys(own), ...placedReadings(observed).map((reading) => reading.measure), wordOf(standing, 'states', 'unread')]);
+    const reached = ceilings.every((line) => measured.has(fieldOf(line, 'measure')) || fieldOf(line, 'scope') in own);
+    if (reached)
+        return { standing, observed, own, kept: true };
+    const whole = foldPlace(root, entry);
+    return { ...whole, kept: whole.kept ?? false };
+}
+export const ownCeilings = (under) => ((home) => (under === undefined || under === `${home}/`
+    ? ownLock().filter(isCeiling).map((line) => canonical({ ...fieldsOf(line), scope: `${home}/${fieldOf(line, 'scope')}` })) : []))(basename(ownRoot()));
+export function foldPlace(root, entry, under, look = true, given) {
+    const store = storeOf(root);
+    const digestAt = Date.now();
+    const closed = meets(root, store, under ?? '');
+    const digestMs = Date.now() - digestAt;
+    if (closed && given?.free !== true) {
+        const prior = keptPlace(store, under);
+        if (prior !== undefined) {
+            process.stderr.write(`CLOSED   ${under || '.'} · digest ${digestMs} ms\n`);
+            return { ...prior, kept: true };
+        }
+    }
+    const { standing, lock: attested, rendered, owned } = given?.standing ?? standingOf(root, under);
+    const folder = writerFor(standing, 'fold');
+    const answered = given === undefined && under ? new Map() : undefined;
+    const reached = given?.observed ?? observedClaims(root, store, { wait: look, ...(under ? { reach: [under], answered } : {}) });
+    const self = instrumentOf(store, entry, standing, root, ownLock());
+    const inside = (place) => !under || within(point(place.replace(/\/\*$/, '')), region(under));
+    const history = historyOf(root, store, standingDemands(store));
+    const theirs = history.live.filter((line) => ((needs) => !under || (needs.length > 0 && needs.every(inside)))(fieldOf(line, 'needs').split('|').filter(Boolean)));
+    const reads = under && under !== `${basename(ownRoot())}/` ? { owned, place: under, scopes: new Set(theirs.map((line) => fieldOf(line, 'scope'))) } : undefined;
+    const spent = [];
+    const took = timing(spent);
+    const read = given?.observed ?? (under ? took('observe', () => observedClaims(root, store, { wait: look })) : reached);
+    const everywhere = [...read, ...took('capsules', () => capsuleReadingsOver({ root, store, ...(under ? { under } : {}), standing, observed: read }))];
+    const points = foldPoints(store, standing, under, folder, self, reached, root, answered, reads);
+    const taken = bytesDigest(store, new TextEncoder().encode(points.join('\n'))).replace(/^sha256:/, '');
+    const observed = everywhere.filter((line) => !/ measure=observed /.test(line) || inside(fieldOf(line, 'scope')));
+    const shared = new Set(under ? placedReadings(everywhere).filter((r) => !inside(r.place)).map((r) => r.question) : []);
+    const live = history;
+    const demands = theirs;
+    const orphans = [];
+    const ceilings = [...standing.filter((line) => isCeiling(line) && !(under && fieldOf(line, 'measure') === 'unread')), ...ownCeilings(under)];
+    const own = took('own', () => ownReadings({
+        root, store, entry, roleOf: rolesOf(store), standing, observed: everywhere,
+        unadmitted: rendered.grey.length + rendered.refused.length, orphans: orphans.length, ...(under ? { under } : {}),
+    }));
+    const regions = took('regions', () => regionsOf(standing, ceilings.filter((line) => !answersElsewhere(line, own, under, new Set(placesIn(root)))), placedReadings(observed)));
+    const fold = (docs) => foldCeilings({ standing, ceilings, observed, own: { ...own, ...docs }, epoch: epochOf(owned), ...(under ? { under, places: new Set(placesIn(root)) } : {}) });
+    const folded = took('ceilings', () => fold({}));
+    const { paid, missing } = took('paid', () => paidOf(store, demands, observed, `${wordFrom(standing, 'families', 'view', lockStanding(store))}/`));
+    const lock = (observeText(join(root, under ?? '', LOCK)) ?? '').split('\n').filter(isWire).length;
+    const second = secondOf(root, store, attested, owned);
+    const policyStanding = standing.filter((line) => !rendered.grey.includes(line) && !rendered.refused.includes(line));
+    const faults = releaseFaults({ forks: rendered.forks, refused: rendered.refused, grey: rendered.grey, orphans, second });
+    const place = {
+        release: releasePolicy({ standing: policyStanding, demands, paid, ceilings, readings: folded, faults, verdicts: attestationObservations(policyStanding.map(line => { const r = parseEvidenceFields(line); return r.kind === 'fact' ? r.value.fields : {}; }), second), snapshot: { fold: taken, instrument: self } }),
+        root, store, ...(under ? { under } : {}), epoch: epochOf(owned), standing, claims: rendered.standing,
+        forks: rendered.forks, grey: rendered.grey, refused: rendered.refused, vacuous: rendered.vacuous.length,
+        demands, paid, missing,
+        history: live.history.filter((line) => fieldOf(line, 'needs').split('|').filter(Boolean).some(inside)),
+        observed,
+        ceilings: {
+            read: folded.read.length,
+            total: ceilings.length,
+            unread: folded.unread.map((line) => fieldOf(line, 'scope')),
+            vacuous: folded.vacuous.map((line) => fieldOf(line, 'scope')),
+            short: listed(folded.over.filter((o) => o.side === 'short' && !shared.has(o.question))),
+            over: listed(folded.over.filter((o) => o.side === 'over')),
+        },
+        orphans,
+        lock,
+        signed: signedByKey(store, standing, everywhere),
+        second,
+        effects: effectStates(store),
+        key: taken,
+        instrument: self,
+        own,
+        open: openCells({ store, standing, observed, grey: rendered.grey, epoch: epochOf(owned) }),
+        regions: packRegions(regions),
+        beats: beatsOf(store, standing, under),
+        landed: [...vouchedCoordinates(store).keys()].filter((coordinate) => !under || coordinate.startsWith(under)).length,
+        costs: costsOf(store),
+    };
+    const { readings: found, same, here } = took('docs', () => viewReadings(place));
+    const family = `${wordFrom(standing, 'families', 'view', lockStanding(store))}/`;
+    const coordinates = new Set([...here].map((name) => `${family}${name}`));
+    const writes = (line) => coordinates.has(fieldOf(line, 'scope'));
+    const holds = (line) => same.has(fieldOf(line, 'scope').slice(family.length));
+    const owed = [...place.missing.filter((line) => !writes(line) || !holds(line)), ...place.paid.filter((line) => writes(line) && !holds(line))];
+    const docs = {
+        ...found, 'payments-lost-on-equal-output': owed.filter((line) => writes(line) && holds(line)).length,
+        'poles-unlike-replay': unlikeReplay(regions, new Set(folded.over.map((one) => one.ceiling)), { ...own, unread: folded.unread.length + folded.vacuous.length }),
+    };
+    const again = took('ceilings', () => fold(docs));
+    const finalPaid = [...place.paid.filter((line) => !writes(line) || holds(line)), ...place.missing.filter((line) => writes(line) && holds(line))];
+    const whole = {
+        ...place,
+        paid: finalPaid,
+        release: releasePolicy({ standing: policyStanding, demands, paid: finalPaid, ceilings, readings: again, faults, verdicts: attestationObservations(policyStanding.map(line => { const r = parseEvidenceFields(line); return r.kind === 'fact' ? r.value.fields : {}; }), second), snapshot: { fold: taken, instrument: self } }),
+        missing: owed,
+        own: { ...place.own, ...docs },
+        ceilings: {
+            ...place.ceilings,
+            read: again.read.length,
+            unread: again.unread.map((line) => fieldOf(line, 'scope')),
+            vacuous: again.vacuous.map((line) => fieldOf(line, 'scope')),
+            short: listed(again.over.filter((o) => o.side === 'short' && !shared.has(o.question))),
+            over: listed(again.over.filter((o) => o.side === 'over')),
+        },
+    };
+    if (folder !== undefined && closed)
+        took('keep', () => keepFold(store, taken, whole, points, self));
+    process.stderr.write(`SPENT    fold ${spent.join(' ms · ')} ms\n`);
+    return whole;
+}

package/dist/cli/takes.d.ts

@@ -0,0 +1,30 @@
+import { judgeTake } from '../judge/take.ts';
+import type { Gate } from '../judge/take.ts';
+export type Judged = {
+    readonly kind: 'refused';
+    readonly scope: string;
+    readonly why: string;
+} | {
+    readonly kind: 'owed';
+    readonly scope: string;
+    readonly why: string;
+} | {
+    readonly kind: 'conditioned';
+    readonly scope: string;
+    readonly demand: string;
+    readonly receipt: string;
+    readonly condition: string;
+} | {
+    readonly kind: 'judged';
+    readonly scope: string;
+    readonly demand: string;
+    readonly locations: readonly string[];
+    readonly before: ReadonlyMap<string, string>;
+    readonly after: ReadonlyMap<string, string>;
+    readonly verdict: ReturnType<typeof judgeTake>;
+    readonly ignored: ReadonlyMap<string, number>;
+    readonly started: number;
+};
+export declare function judgeDemand(root: string, demand: string): Judged;
+/** A take its batch let land: its receipt sealed with the gates the batch passed, its cone vouched, its fact landed. */
+export declare function landTake(root: string, one: Judged, gates: readonly Gate[]): void;

package/dist/cli/takes.js

@@ -0,0 +1,108 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fullDigest } from "../fold/digests.js";
+import { canonical } from '@lapxo/topos/wire';
+import { fieldOf, foldClaims } from "../fold/claims.js";
+import { rolesOf } from "../fold/roles.js";
+import { writerFor } from "../fold/signers.js";
+import { judgeTake, sealed } from "../judge/take.js";
+import { land, landEnvelope, ledgerLines, storeOf } from "../land/ledger.js";
+import { wordOf } from "../fold/wire.js";
+import { hasVouchedTree, inside, landCoordinates, coordinatesOf, locationsOf, vouchedCoordinates, witnessOf } from "../land/vouched.js";
+import { ownerOf, forkedScopes, signedOwnerLines } from "./owner.js";
+export function judgeDemand(root, demand) {
+    const started = Date.now();
+    const store = storeOf(root);
+    const scope = fieldOf(demand, 'scope');
+    const refuse = (why) => ({ kind: 'refused', scope, why });
+    if (!hasVouchedTree(store))
+        return refuse('no source is vouched; land the lock once');
+    if (forkedScopes(store).has(scope))
+        return refuse('it stands as a fork; the owner narrows or withdraws one line first');
+    const condition = fieldOf(demand, 'condition');
+    if (condition) {
+        const paid = ledgerLines(store, 'judge').filter((line) => fieldOf(line, 'scope') === condition && fieldOf(line, 'value') === 'present').pop();
+        if (!paid)
+            return { kind: 'owed', scope, why: `it rests on ${condition}, which has no FACT: it stands owed until that is paid` };
+        const absent = locationsOf(fieldOf(demand, 'needs')).locations.filter((l) => !existsSync(join(root, l.replace(/\/$/, ''))));
+        if (absent.length)
+            return refuse(`demanded locations absent: ${absent.join(', ')}`);
+        return { kind: 'conditioned', scope, demand, receipt: fieldOf(paid, 'at'), condition };
+    }
+    const { locations, refused } = locationsOf(fieldOf(demand, 'needs'));
+    if (refused.length)
+        return refuse(`needs that are not locations: ${refused.join(', ')}`);
+    const roleOf = rolesOf(store);
+    const ignored = new Map();
+    const walked = (coordinate) => {
+        const role = roleOf(coordinate);
+        if (role !== 'source')
+            ignored.set(role, (ignored.get(role) ?? 0) + 1);
+        return role;
+    };
+    const before = new Map([...vouchedCoordinates(store)].filter(([coordinate]) => locations.some((l) => inside(coordinate, l)) && roleOf(coordinate) === 'source'));
+    const after = new Map();
+    for (const location of locations)
+        for (const [coordinate, digest] of coordinatesOf(root, location, walked))
+            after.set(coordinate, digest);
+    const law = [scope.split('/').pop() ?? scope, fieldOf(demand, 'at').replace(/^witness:/, '')].filter(Boolean);
+    const verdict = judgeTake({
+        root, scope, value: fieldOf(demand, 'value'), locations, before, after, law,
+        shape: fieldOf(demand, 'shape'), restsOn: fieldOf(demand, 'restsOn'), witnessOf: (coordinate) => witnessOf(root, coordinate),
+        template: wordOf(foldClaims(signedOwnerLines(store)).standing, 'templates', '{roots}'),
+    });
+    return { kind: 'judged', scope, demand, locations, before, after, verdict, ignored, started };
+}
+/** A take its batch let land: its receipt sealed with the gates the batch passed, its cone vouched, its fact landed. */
+export function landTake(root, one, gates) {
+    const store = storeOf(root);
+    if (one.kind === 'refused')
+        return;
+    if (one.kind === 'owed') {
+        process.stdout.write(`OWED     take ${one.scope} · ${one.why}\n`);
+        return;
+    }
+    if (one.kind === 'conditioned') {
+        const { scope, demand, receipt, condition } = one;
+        land(store, 'judge', [canonical({
+                scope, role: 'writes', form: 'alphabet', measure: fieldOf(demand, 'measure') || 'status', value: fieldOf(demand, 'value') || 'present', by: 'judge', at: receipt, condition,
+            })]);
+        land(store, 'take', [canonical({ scope: `take/${scope}`, role: 'writes', form: 'alphabet', measure: 'status', value: 'fact', by: 'judge', at: receipt })]);
+        process.stdout.write(`FACT     take ${scope} · paid by ${receipt} · condition ${condition} · no moved set\n`);
+        return;
+    }
+    const { scope, demand, before, after, ignored, started } = one;
+    const verdict = sealed(root, one.verdict, gates);
+    const who = writerFor(signedOwnerLines(store), 'fold') ?? ownerOf(store);
+    const cone = fullDigest(store, [...before].map(([path, digest]) => `${path} ${digest}`));
+    land(store, 'take', [canonical({ scope: `take/${scope}`, role: 'writes', form: 'alphabet', measure: 'status', value: 'open', by: who, at: `place:${cone}` })]);
+    landEnvelope(store, verdict.digest, `${JSON.stringify(verdict.envelope, null, 1)}\n`);
+    const receipt = `receipt:${verdict.digest}`;
+    const generation = fullDigest(store, [...after].sort().map(([coordinate, digest]) => `${coordinate} ${digest}`));
+    land(store, 'judge', verdict.envelope.effects.map((effect) => canonical({
+        scope: `${effect.kind}/${generation}`, role: 'writes', form: 'alphabet', measure: 'status', value: effect.status, by: 'judge', at: receipt,
+    })));
+    if (verdict.kind === 'fact') {
+        const present = new Map(verdict.changed.filter((path) => after.has(path)).map((path) => [path, after.get(path) ?? '']));
+        const gone = verdict.changed.filter((path) => !after.has(path));
+        landCoordinates(store, present, gone, receipt);
+        land(store, 'judge', [
+            canonical({
+                scope, role: 'writes', form: 'alphabet', measure: fieldOf(demand, 'measure') || 'status', value: fieldOf(demand, 'value') || 'present', by: 'judge', at: receipt,
+            }),
+            canonical({ scope, role: 'writes', form: 'alphabet', measure: 'cone', value: verdict.changed.join('|'), by: 'judge', at: receipt }),
+        ]);
+    }
+    const ms = Date.now() - started;
+    land(store, 'take', [
+        canonical({ scope: `take/${scope}`, role: 'writes', form: 'alphabet', measure: 'status', value: verdict.kind, by: 'judge', at: receipt }),
+        canonical({ scope: `take/${scope}`, role: 'writes', form: 'interval', measure: 'ms', value: `${ms}..${ms}`, by: 'judge', at: receipt }),
+    ]);
+    const effects = verdict.envelope.effects.map((e) => `${e.kind}@${e.at || '.'}:${e.admitted ? e.status : `${e.status}·grey`}(${e.ms} ms)`).join(' ') || 'none';
+    process.stdout.write(`${verdict.kind === 'fact' ? 'FACT  ' : 'REFUSE'}   take ${scope} · ${verdict.why}\n`
+        + `MOVED    ${verdict.changed.length} sources: ${verdict.changed.join(' ')}\n`
+        + `IGNORED  ${[...ignored].map(([role, n]) => `${n} ${role}`).join(' · ') || 'none'} (not walked, never landed)\n`
+        + `${verdict.notOwned.length ? `NOT OWN  ${verdict.notOwned.length} witnesses of other laws, left for them: ${verdict.notOwned.join(' ')}\n` : ''}`
+        + `EFFECTS  ${effects}\n`
+        + `RECEIPT  ${verdict.digest} · ${ms} ms\n`);
+}

package/dist/cli/verb.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};