@lapxo/bound 0.1.0

package/dist/fold/own.js

@@ -0,0 +1,215 @@
+import { timing } from "../host/timing.js";
+import { basename, existsSync, relative, resolve } from "../host/io.js";
+import { EXTENSION, matches } from '@lapxo/topos/wire';
+import { fieldOf, isWire } from "./claims.js";
+import { wordsOf } from "./wire.js";
+import { inheritedRoles, stepsOutside } from "./roles.js";
+import { writerFor } from "./signers.js";
+import { isCeiling } from "./configures.js";
+import { keyOf } from "./keys.js";
+import { VERB_NAMES } from "../cli/names.js";
+import { actSeconds, idleCount, receiptsSeen } from "./closed.js";
+import { foldsElsewhere } from "./kept.js";
+import { ledgerLines } from "../land/ledger.js";
+import { vouchedCoordinates } from "../land/vouched.js";
+import { placedReadings, readerLines, readerModules } from "./observed.js";
+import { storeDirs } from "../host/ports/store.js";
+import { entriesIn, observeText } from "../observe/files.js";
+import { placesOf, viewsOf } from "./views.js";
+import { declaredBy } from "../observe/regions.js";
+import { REGION_NAMES } from "../render/names.js";
+import { ownLock, ownRoot } from "../observe/runner.js";
+import { namingTheirPlace, zoomedOutsideThePlace } from "./zoom.js";
+import { resetsOnEqualEmits, withoutVectors } from "../observe/identity.js";
+import { instrumentCoordinates } from "./digests.js";
+import { bugsWithoutANo } from "./nos.js";
+import { writtenIn } from "./signed.js";
+import { laidDiffers } from "./laid.js";
+import { heldBytes } from "../land/held.js";
+import { capsuleAt, placesIn, worldAt } from "./places.js";
+const entered = { foreign: 0 };
+/** Host and instrument measurements. Domain contracts require their selected readers; missing readings are not fabricated zeroes. */
+function shipped(root, store, standing, under) {
+    const shape = [...viewsOf(standing).values()].flatMap((view) => ('regions' in view && view.shape ? [view.shape] : []))
+        .find((coordinate) => coordinate.endsWith(EXTENSION));
+    if (shape === undefined)
+        return 0;
+    const outside = stepsOutside(store);
+    const places = under ? [under] : ['', ...entriesIn(resolve(root)).filter((entry) => entry.dir && !outside.has(entry.name)).map((entry) => `${entry.name}/`)];
+    const ships = () => wordsOf(standing, 'ships');
+    entered.foreign = 0;
+    return Math.max(0, ...places.map((place) => (ships().includes(shape) ? (observeText(resolve(root, place, shape)) ?? '').split('\n').filter(isWire).length : 0)));
+}
+function unrenderedIn(root, store, standing, observed) {
+    const views = [...viewsOf(standing).values()].flatMap((view) => ('regions' in view && view.shape ? [view] : []));
+    const own = new Set(REGION_NAMES);
+    const missing = new Set();
+    for (const place of ['', ...placesIn(root).map((one) => `${one}/`)]) {
+        const declared = declaredBy({ root, store, standing, observed, ...(place ? { under: place } : {}) });
+        const here = views.filter((view) => ((at) => (at.length ? at.includes(place) : observeText(resolve(root, place, view.shape)) !== undefined))(placesOf(standing, view)));
+        for (const region of here.flatMap((view) => view.regions))
+            if (!own.has(region.name) && !declared.some((glob) => matches(glob, region.name)))
+                missing.add(`${place}${region.name}`);
+    }
+    return missing.size;
+}
+function removedByHand(root, store, under) {
+    return [...vouchedCoordinates(store).keys()].filter((coordinate) => (!under || coordinate.startsWith(under)) && !existsSync(resolve(root, coordinate))).length;
+}
+function readersOverFirstRun(store) {
+    const runs = new Map();
+    for (const line of readerLines(store)) {
+        const scope = fieldOf(line, 'scope');
+        if (!scope.startsWith('cost/reader/') || !/^place:[0-9a-f]{64}$/.test(fieldOf(line, 'at')))
+            continue;
+        const key = `${scope} ${fieldOf(line, 'by')} ${fieldOf(line, 'at')}`;
+        runs.set(key, [...(runs.get(key) ?? []), Number(fieldOf(line, 'value').split('..')[0])]);
+    }
+    return [...runs.values()].filter((ms) => ms.length > 1 && ms[ms.length - 1] > ms[0]).length;
+}
+function attestBeat(store, standing) {
+    const head = keyOf(store, 'attest');
+    if (head === undefined)
+        return undefined;
+    return middleBeat(store, standing, `${head}/beat`, 'folded', head);
+}
+function twiceWritten(observed) {
+    const places = new Map();
+    for (const reading of placedReadings(observed)) {
+        if (!reading.question.startsWith('concept/'))
+            continue;
+        places.set(reading.question, (places.get(reading.question) ?? new Set()).add(reading.place));
+    }
+    return [...places.values()].filter((held) => held.size > 1).length;
+}
+function counted(store, standing, scope, at) {
+    const folder = writerFor(standing, 'fold');
+    if (folder === undefined)
+        return 0;
+    return ledgerLines(store, folder)
+        .filter((line) => fieldOf(line, 'scope') === scope && /place:(folded|kept)$/.test(fieldOf(line, 'at')))
+        .slice(-10)
+        .filter((line) => fieldOf(line, 'at') === `place:${at}`).length;
+}
+function middleBeat(store, standing, scope, at, signer) {
+    const folder = signer ?? writerFor(standing, 'fold');
+    if (folder === undefined)
+        return undefined;
+    const ms = ledgerLines(store, folder)
+        .filter((line) => fieldOf(line, 'scope') === scope && 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[Math.floor(ms.length / 2)];
+}
+function alphabetsInCode(observed, standing, under) {
+    const signed = standing
+        .filter((line) => fieldOf(line, 'form') === 'alphabet')
+        .map((line) => fieldOf(line, 'value'))
+        .filter((value) => value !== 'withdraw' && !value.startsWith('not:'))
+        .map((value) => new Set(value.split('|').filter(Boolean)))
+        .filter((alphabet) => alphabet.size > 1);
+    const crossing = placedReadings(observed)
+        .filter((reading) => reading.question === 'alphabet' && reading.measure === 'id' && (!under || reading.place.startsWith(under)))
+        .filter((reading) => signed.some((alphabet) => reading.value.split('|').every((member) => alphabet.has(member))));
+    return new Set(crossing.map((reading) => `${reading.place} ${reading.value}`)).size;
+}
+const ceilingsNamed = (standing, name) => standing.filter((line) => isCeiling(line) && (fieldOf(line, 'measure') === name || fieldOf(line, 'scope').split('/').pop() === name));
+const ownFrom = (line, name, value) => {
+    if (value === undefined)
+        return {};
+    const scope = fieldOf(line ?? '', 'scope');
+    return { [name]: value, ...(scope && scope !== name ? { [scope]: value } : {}) };
+};
+const exporting = (observed, under, names) => new Set(placedReadings(observed).filter((one) => one.place.startsWith(under) && names.some((name) => one.question === `export/${name}`)).map((one) => one.place)).size;
+export const outsideTheirCapsule = (root, standing, lines) => {
+    const family = wordsOf(standing, 'families').find((one) => one === 'reader' || one === 'readers');
+    return lines.filter((line) => (family === undefined || fieldOf(line, 'scope').startsWith(`${family}/`))
+        && fieldOf(line, 'measure') === 'reader' && fieldOf(line, 'value') !== 'withdraw'
+        && ((head) => !fieldOf(line, 'value').includes('/') || (capsuleAt(root, head) && !worldAt(root, head)))(fieldOf(line, 'value').split('/')[0] ?? ''));
+};
+const TREE = new Set(['readers-over-their-first-run', 'stale-capsules', 'accept-line',
+    'regions-described', 'walks-prune-by-role',
+    'ledger-region-verdicts-served-from-a-kept-fold', 'kept-folds-read-under-another-instrument', 'accepts-that-refolded',
+    'readers-without-vectors', 'lines-that-name-their-place', 'memo-resets-on-unchanged-extension', 'status-for-no-effect', 'accept-ms',
+    'bodies-written-twice', 'world-lines-outside-their-capsule']);
+const placeOnly = (readings, under) => Object.fromEntries(Object.entries(readings).flatMap(([measure, value]) => (value === undefined || (under && TREE.has(measure)) ? [] : [[measure, value]])));
+/**
+ * What the instrument reads of itself rather than through a reader: how many programs its source opens, how many
+ * signed lines stand unadmitted, how many stores it keeps, which of the modules it runs are no source, how many samples
+ * nothing names, how many alphabets are spelled both in code and in the lock, and how many regions it writes that no
+ * line of the lock describes, how many bodies are written twice anywhere in the tree rather than once and used by
+ * digest, and whether the version a package carries is the one the lock names. Inside one package, only what lies
+ * there. A cost is read now and never read back from the fold it was taken with: a beat is a line of the ledger.
+ */
+export function costReadings(store, standing, under) {
+    return placeOnly({
+        'beat-kept': middleBeat(store, standing, `beat/${under ?? '.'}`, 'kept'),
+        'accept-line': middleBeat(store, standing, 'beat/accept', 'line'),
+        'accept-ms': middleBeat(store, standing, 'beat/accept', 'total'),
+        'accepts-that-refolded': counted(store, standing, 'beat/accept', 'folded'),
+        'test-kept': under ? middleBeat(store, standing, `beat/${under}`, 'kept') : undefined,
+        'programs-place': under ? middleBeat(store, standing, `beat/${under}`, 'command-kept') : undefined,
+        ...(keyOf(store, 'attest') === undefined ? {} : { [`${keyOf(store, 'attest')}-ms`]: under ? undefined : attestBeat(store, standing) }),
+    }, under);
+}
+export function ownReadings(input) {
+    const { root, store, entry, roleOf, standing, observed, under } = input;
+    const spent = [];
+    const took = timing(spent);
+    const instrument = under === undefined || under === `${basename(ownRoot())}/`;
+    const tree = (fn) => (under ? undefined : fn());
+    const imported = tree(() => took('imports', () => [...instrumentCoordinates(store, resolve(root, entry), standing, root, ownLock()).keys()]
+        .filter((coordinate) => capsuleAt(root, relative(root, coordinate).split('/')[0] ?? '')).length));
+    const twice = tree(() => took('bodies', () => twiceWritten(observed)));
+    const local = {
+        'orphan-samples': input.orphans,
+        'removed-by-hand': took('removed', () => removedByHand(root, store, under)),
+        'readers-over-their-first-run': tree(() => took('readers', () => readersOverFirstRun(store))),
+        'alphabet-in-code': took('alphabets', () => alphabetsInCode(observed, standing, under)),
+        'stale-capsules': tree(() => took('capsules', () => inheritedRoles(store).stale.length)),
+        'beat-kept': middleBeat(store, standing, `beat/${under ?? '.'}`, 'kept'),
+        'accept-line': tree(() => middleBeat(store, standing, 'beat/accept', 'line')),
+        'accept-ms': tree(() => middleBeat(store, standing, 'beat/accept', 'total')),
+        'test-kept': under ? middleBeat(store, standing, `beat/${under}`, 'kept') : undefined,
+        'programs-place': under ? middleBeat(store, standing, `beat/${under}`, 'command-kept') : undefined,
+        'regions-described': tree(() => took('regions', () => unrenderedIn(root, store, standing, observed))),
+        'readers-without-vectors': tree(() => took('vectors', () => withoutVectors(root, readerModules(store), standing))),
+        'lines-that-name-their-place': tree(() => took('zoom', () => namingTheirPlace(root))),
+        ...(instrument ? {
+            'bugs-without-a-no': took('nos', () => bugsWithoutANo(root, store, standing, basename(ownRoot()), 'bugs-without-a-no')),
+            'zoom-rewrites-outside-the-place': took('zoomed', () => zoomedOutsideThePlace(root, standing)),
+            'own-lines-written-in': took('applied', () => writtenIn(root, basename(ownRoot()))),
+            'laid-digest-differs': took('laid', () => laidDiffers(store, ownRoot(), ownLock(), writerFor(standing, 'fold'))),
+        } : {}),
+        'memo-resets-on-unchanged-extension': tree(() => took('resets', () => resetsOnEqualEmits(readerLines(store)))),
+        ...ownFrom(ceilingsNamed(standing, 'capsules-imported').find((line) => fieldOf(line, 'form') === 'interval'), 'capsules-imported', imported),
+        ...((n) => ({ bytes: n, 'store/bytes': n }))(took('store', () => heldBytes(root, store, standing))),
+        'walks-prune-by-role': entered.foreign,
+        ...ownFrom(ceilingsNamed(standing, 'bodies-written-twice').find((line) => fieldOf(line, 'form') === 'interval'), 'bodies-written-twice', twice),
+        ...Object.fromEntries(standing.filter((line) => isCeiling(line) && (fieldOf(line, 'measure') === 'render-modules' || fieldOf(line, 'scope').split('/').pop() === 'render-modules'))
+            .flatMap((line) => ((place) => place === undefined ? [] : [[fieldOf(line, 'scope'), tree(() => exporting(observed, `${place}/`, ['render']))]])(fieldOf(line, 'scope').split('/').find((step) => capsuleAt(root, step))))),
+        ...Object.fromEntries(standing.filter((line) => isCeiling(line) && (fieldOf(line, 'measure') === 'reader-modules' || fieldOf(line, 'scope').split('/').pop() === 'reader-modules'))
+            .flatMap((line) => ((place) => place === undefined ? [] : [[fieldOf(line, 'scope'), tree(() => exporting(observed, `${place}/`, ['observe', 'run']))]])(fieldOf(line, 'scope').split('/').find((step) => capsuleAt(root, step))))),
+        ...ownFrom(ceilingsNamed(standing, 'world-lines-outside-their-capsule').find((line) => fieldOf(line, 'form') === 'interval'), 'world-lines-outside-their-capsule', tree(() => outsideTheirCapsule(root, standing, standing).length)),
+        idle: idleCount(),
+        s: actSeconds(),
+        'cli-verbs': VERB_NAMES.length,
+        'walk-read': receiptsSeen().count,
+        'walk-ms': receiptsSeen().ms,
+        'kept-folds-read-under-another-instrument': tree(() => foldsElsewhere()),
+        'accepts-that-refolded': tree(() => counted(store, standing, 'beat/accept', 'folded')),
+        ...(keyOf(store, 'attest') === undefined ? {} : { [`${keyOf(store, 'attest')}-ms`]: tree(() => attestBeat(store, standing)) }),
+        ship: took('ship', () => shipped(root, store, standing, under)),
+    };
+    process.stderr.write(`OWN      ${spent.join(' ms · ')} ms\n`);
+    if (under)
+        return placeOnly(local, under);
+    return {
+        ...placeOnly(local),
+        unadmitted: input.unadmitted,
+        dirs: storeDirs(store),
+        'artifacts-in-loop': [entry, ...readerModules(store)].filter((coordinate) => roleOf(coordinate) !== 'source').length,
+    };
+}

package/dist/fold/paid.d.ts

@@ -0,0 +1,11 @@
+import { state } from '@lapxo/obligations/views/field';
+import type { PlaceFold } from '../cli/place.ts';
+/** Where a case lies: a demand is judged only over a cone that holds one, by a take or read from a landed cone alike. */
+export declare const holdsCases: (location: string) => boolean;
+export declare function paidOf(store: string, demands: readonly string[], observed: readonly string[], views: string): {
+    readonly paid: readonly string[];
+    readonly missing: readonly string[];
+    readonly answered: ReadonlySet<string>;
+};
+export type Verdict = ReturnType<typeof state>;
+export declare const verdictsFor: (fold: PlaceFold) => Readonly<Record<string, Verdict>>;

package/dist/fold/paid.js

@@ -0,0 +1,92 @@
+import { answers, point, region, within } from '@lapxo/obligations/field';
+import { alphabetForm } from '@lapxo/obligations/forms';
+import { cell, mark, observe, state } from '@lapxo/obligations/views/field';
+import { fieldOf } from "./claims.js";
+import { boundOf, regionsNamed } from "./region.js";
+import { wordFrom } from "./wire.js";
+import { lockStanding } from "./keys.js";
+import { ledgerLines, storeAt } from "../land/ledger.js";
+import { observeText } from "../observe/files.js";
+import { memoized } from "./digests.js";
+/** Where a case lies: a demand is judged only over a cone that holds one, by a take or read from a landed cone alike. */
+export const holdsCases = (location) => {
+    const steps = location.split('/');
+    return steps.includes('yes') || steps.includes('no');
+};
+/**
+ * A cone answers for a region it covers as much as for one it lies inside: the same region read at two resolutions
+ * (L09). A fact about a region a demand never asked about pays nothing, a demand every asked coordinate of which was
+ * judged is paid even when the take that judged it reached further, and an answer pays only what its take judged.
+ */
+function pays(demand, answer, views) {
+    if (answer.value !== (fieldOf(demand, 'value') || 'present'))
+        return false;
+    const needs = fieldOf(demand, 'needs').split('|').filter(Boolean);
+    if (answer.read && !fieldOf(demand, 'scope').startsWith(views) && !needs.some(holdsCases))
+        return false;
+    const asked = needs.map((need) => region(need));
+    if (answer.judged && !asked.every((where) => answer.judged?.some((judged) => within(where, region(judged)))))
+        return false;
+    const moved = answer.cone.split('|').filter(Boolean).map((coordinate) => point(coordinate));
+    if (!moved.length)
+        return true;
+    return answers(moved, asked) || (asked.length > 0 && asked.every((where) => moved.some((coordinate) => within(coordinate, where))));
+}
+function judgedBy(store, scope, at) {
+    if (!at.startsWith('receipt:sha256:'))
+        return undefined;
+    const held = memoized(store, `judged ${at}`, () => {
+        const text = observeText(storeAt(store, 'cas', 'envelopes', `${at.replace(/^receipt:sha256:/, '')}.json`));
+        const got = text === undefined ? {} : JSON.parse(text);
+        return JSON.stringify(Array.isArray(got.cone) ? [got.scope ?? '', ...got.cone] : []);
+    });
+    const [said, ...cone] = JSON.parse(held);
+    return said === scope ? cone : undefined;
+}
+export function paidOf(store, demands, observed, views) {
+    const wanted = new Set(demands.map((line) => fieldOf(line, 'scope')));
+    const seen = [...ledgerLines(store, 'judge'), ...observed].filter((line) => wanted.has(fieldOf(line, 'scope')));
+    const cones = new Map();
+    for (const line of seen)
+        if (fieldOf(line, 'measure') === 'cone')
+            cones.set(`${fieldOf(line, 'scope')} ${fieldOf(line, 'at')}`, fieldOf(line, 'value'));
+    const answered = new Map();
+    for (const line of seen) {
+        const scope = fieldOf(line, 'scope');
+        if (!scope || fieldOf(line, 'measure') === 'cone')
+            continue;
+        const judged = judgedBy(store, scope, fieldOf(line, 'at'));
+        (answered.get(scope) ?? answered.set(scope, []).get(scope)).push({
+            value: fieldOf(line, 'value'), cone: cones.get(`${scope} ${fieldOf(line, 'at')}`) ?? '', read: fieldOf(line, 'at').startsWith('cone:'), ...(judged ? { judged } : {}),
+        });
+    }
+    const paid = demands.filter((line) => (answered.get(fieldOf(line, 'scope')) ?? []).some((answer) => pays(line, answer, views)));
+    return { paid, missing: demands.filter((line) => !paid.includes(line)), answered: new Set(answered.keys()) };
+}
+const HELD = { tokens: ['absent', 'present'] };
+const heldAs = (holds) => alphabetForm.parse(HELD, { want: [holds ? 'present' : 'absent'] });
+/**
+ * The judge's verdict on each demand, as the object judges a cell: the demand is the floor its place requires, and the
+ * two heads are the origins that speak on it — the take, holding it or not where it answered or paid it, and the second
+ * head, holding what the take holds where it agrees, the other where the demand's region stands apart, and silent where
+ * its word is stale, grey or missing. Both holding it is FREE, one alone REQUIRED, their disagreeing CONFLICT, and
+ * neither admitting it FORBIDDEN.
+ */
+function verdictsOf(demands, paid, answered, second, standing) {
+    const named = regionsNamed(standing);
+    const apart = new Set((second.apart ?? []).map((one) => (one === '.' ? '' : one)));
+    const heard = second.verdict === 'agrees' || second.verdict === 'forks';
+    return Object.fromEntries(demands.map((line) => {
+        const scope = fieldOf(line, 'scope');
+        const holds = paid.includes(line);
+        const spoke = holds || answered.has(scope);
+        const differs = second.verdict === 'forks' && (second.apart === undefined || apart.has(boundOf(named, line).region));
+        let one = { ...cell(scope), marks: [mark({ pole: 'floor', reach: 'local', span: heldAs(true) })] };
+        if (spoke)
+            one = observe(one, { origin: 'take', span: heldAs(holds), id: 'take' });
+        if (spoke && heard)
+            one = observe(one, { origin: 'second', span: heldAs(differs ? !holds : holds), id: 'second' });
+        return [scope, state(alphabetForm.lattice(HELD), one)];
+    }));
+}
+export const verdictsFor = (fold) => verdictsOf(fold.demands, fold.paid, paidOf(fold.store, fold.demands, fold.observed, `${wordFrom(fold.standing, 'families', 'view', lockStanding(fold.store))}/`).answered, fold.second, fold.standing);

package/dist/fold/place-inputs.d.ts

@@ -0,0 +1,17 @@
+import { type View } from '../fold/views.ts';
+import type { PlaceFold } from '../cli/place.ts';
+/**
+ * A place seen from inside it: the wire and the keys it is read with, the regions it is written in, and every line of
+ * the place — its manifest, its build, its pages, its prose, its own ceilings and every line a view of it reads. Nothing
+ * of the tree's history, and nothing the instrument keeps for itself, crosses; a need outside the place is left behind.
+ * A capsule renders a place from these lines, in the tree as in the place published alone, so both write one coordinate; the
+ * lock a place is rendered with is these lines as target lines its first land signs at epoch one, the bootstrap first.
+ * A view is the place's own: a line of it that names coordinates is taken when one of them is a coordinate of the place, and a
+ * line that names none where its view names this place or no place at all, or at a world that holds no line of a view
+ * the views/world list names. A line another published place leads is taken only by its needs.
+ */
+export declare function takenFor(held: readonly string[], under: string, world?: {
+    readonly own: readonly string[];
+    readonly tree: ReadonlyMap<string, View>;
+}): (line: string) => boolean;
+export declare function placeLines(fold: Pick<PlaceFold, 'root' | 'standing' | 'under'>): readonly string[];

package/dist/fold/place-inputs.js

@@ -0,0 +1,70 @@
+import { canonical, matches } from '@lapxo/topos/wire';
+import { fieldOf, fieldsOf } from "../fold/claims.js";
+import { lockStanding } from "../fold/keys.js";
+import { worldAt } from "../fold/places.js";
+import { defaulted, placesOf, viewsOf } from "../fold/views.js";
+import { zoomed } from "../fold/zoom.js";
+import { ownLockOf } from "../fold/signed.js";
+import { wordFrom, wireLine } from "../fold/wire.js";
+import { sourced } from "../land/vouched.js";
+import { nameOf } from "../render/page.js";
+/** Ephemeral view input, never a signed source record or publication artifact. */
+const unsigned = (line) => {
+    const fields = fieldsOf(line);
+    delete fields['sig'];
+    delete fields['epoch'];
+    return { ...fields, by: 'target' };
+};
+import { ownLock, ownStore } from "../observe/runner.js";
+/**
+ * A place seen from inside it: the wire and the keys it is read with, the regions it is written in, and every line of
+ * the place — its manifest, its build, its pages, its prose, its own ceilings and every line a view of it reads. Nothing
+ * of the tree's history, and nothing the instrument keeps for itself, crosses; a need outside the place is left behind.
+ * A capsule renders a place from these lines, in the tree as in the place published alone, so both write one coordinate; the
+ * lock a place is rendered with is these lines as target lines its first land signs at epoch one, the bootstrap first.
+ * A view is the place's own: a line of it that names coordinates is taken when one of them is a coordinate of the place, and a
+ * line that names none where its view names this place or no place at all, or at a world that holds no line of a view
+ * the views/world list names. A line another published place leads is taken only by its needs.
+ */
+export function takenFor(held, under, world) {
+    const views = new Map([...viewsOf(held).values()].flatMap((view) => ('regions' in view ? [[view.name, view]] : [])));
+    const inside = (need) => need.startsWith(under);
+    const crosses = ownLock().filter((line) => fieldOf(line, 'scope') === 'publish/takes').flatMap((line) => fieldOf(line, 'value').split('|').filter(Boolean));
+    const kept = new Set([sourced(held), wordFrom(held, 'families', 'reader', lockStanding(ownStore())), 'publish']);
+    const places = new Set(held.map((line) => fieldOf(line, 'scope').split('/')).filter((steps) => steps.length === 3 && steps[0] === 'publish' && steps[2] === 'bootstrap').map((steps) => steps[1]));
+    return (line) => {
+        const scope = fieldOf(line, 'scope');
+        const needs = fieldOf(line, 'needs').split('|').filter(Boolean);
+        if (crosses.some((glob) => matches(glob, scope)))
+            return true;
+        if (scope.startsWith(under))
+            return true;
+        if (scope.startsWith('view/')) {
+            const view = views.get(scope.slice('view/'.length));
+            if (view === undefined || view.shape === '')
+                return false;
+            const listed = wireLine(held, 'views/world');
+            if ((listed === undefined ? [] : fieldOf(listed, 'value').split('|').filter(Boolean)).includes(view.name))
+                return world !== undefined && defaulted(held, view, world.own, world.tree);
+            return (world !== undefined && defaulted(held, view, world.own, world.tree)) || (needs.length ? needs.some(inside) : placesOf(held, view).includes(under) || !placesOf(held, view).length);
+        }
+        const first = scope.split('/')[0] ?? '';
+        if (kept.has(first))
+            return false;
+        return (!places.has(first) && scope.includes(`/${under}`)) || (needs.length > 0 && needs.every(inside));
+    };
+}
+export function placeLines(fold) {
+    const place = nameOf(fold);
+    const under = `${place}/`;
+    const held = fold.standing.filter((line) => fieldOf(line, 'value') !== 'withdraw');
+    const own = ownLockOf(fold.root, place);
+    const taken = takenFor(held, under, worldAt(fold.root, place) ? { own, tree: viewsOf(ownLockOf(fold.root, '')) } : undefined);
+    const rooted = (line) => canonical(unsigned(zoomed(line, place)));
+    const key = (line) => ['scope', 'role', 'measure'].map((field) => fieldOf(line, field)).join(' ');
+    const mine = own.filter((line) => !fieldOf(line, 'scope').startsWith('keys/')).map((line) => canonical(unsigned(line)));
+    const ruled = new Set(mine.map(key));
+    const merged = [...mine, ...held.filter(taken).map(rooted).filter((line) => !ruled.has(key(line)))];
+    const scopes = new Set(merged.map((line) => fieldOf(line, 'scope')));
+    return [...new Set(merged.filter((line) => !fieldOf(line, 'condition') || scopes.has(fieldOf(line, 'condition'))))];
+}

package/dist/fold/places.d.ts

@@ -0,0 +1,20 @@
+type Spoken = {
+    readonly place: string;
+    readonly line: string;
+};
+export declare const placesIn: (root: string) => readonly string[];
+/** A directory with no own lock is founded by the root: a line of its region family names the directory's coordinates, and a covered batch that names the place lands its first own lock. */
+export declare const foundableIn: (root: string, standing: readonly string[], family: string, name: string) => boolean;
+export declare const capsuleAt: (root: string, name: string) => boolean;
+/** A world is a place whose own lock names capsule/key. A view named by wire/views/world resolves into these and no other place. */
+export declare const worldAt: (root: string, name: string) => boolean;
+export declare const worldsIn: (root: string) => readonly string[];
+export declare function kindsOf(root: string, place: string): readonly string[];
+type ClassDefault = {
+    readonly classes: readonly string[];
+    readonly line: string;
+};
+export declare function classDefaults(root: string): readonly ClassDefault[];
+export declare const fromPlace: (place: string, places: readonly string[]) => (path: string) => string;
+export declare function spoken(root: string): readonly Spoken[];
+export {};

package/dist/fold/places.js

@@ -0,0 +1,84 @@
+import { join } from "../host/io.js";
+import { CAPSULE, canonical, LOCK, matches, parse } from '@lapxo/topos/wire';
+import { fieldOf } from "./claims.js";
+import { isCeiling } from "./configures.js";
+import { entriesIn, observeText } from "../observe/files.js";
+import { ownLock } from "../observe/runner.js";
+import { said } from "./wire.js";
+import { ownLockOf } from "./signed.js";
+export const placesIn = (root) => entriesIn(root)
+    .filter((entry) => entry.dir && observeText(join(root, entry.name, LOCK)) !== undefined).map((entry) => entry.name).sort();
+/** A directory with no own lock is founded by the root: a line of its region family names the directory's coordinates, and a covered batch that names the place lands its first own lock. */
+export const foundableIn = (root, standing, family, name) => !placesIn(root).includes(name)
+    && (entriesIn(root).find((entry) => entry.name === name)?.dir ?? false)
+    && standing.some((line) => fieldOf(line, 'scope') === `${family}/${name}` && fieldOf(line, 'measure') === 'coordinates' && fieldOf(line, 'value').split('|').includes(`${name}/**`));
+export const capsuleAt = (root, name) => [LOCK, CAPSULE]
+    .some((lock) => (observeText(join(root, name, lock)) ?? '').split('\n').some((line) => fieldOf(line, 'scope').startsWith('capsule/')));
+/** A world is a place whose own lock names capsule/key. A view named by wire/views/world resolves into these and no other place. */
+export const worldAt = (root, name) => [LOCK, CAPSULE]
+    .some((lock) => (observeText(join(root, name, lock)) ?? '').split('\n').some((line) => fieldOf(line, 'scope') === 'capsule/key' && fieldOf(line, 'value') !== 'withdraw'));
+export const worldsIn = (root) => placesIn(root).filter((name) => worldAt(root, name));
+export function kindsOf(root, place) {
+    const lock = ownLockOf(root, place);
+    const kinds = [];
+    if (worldAt(root, place))
+        kinds.push('world');
+    const saidKind = lock.find((line) => fieldOf(line, 'scope') === 'place/kind' && fieldOf(line, 'value') !== 'withdraw');
+    if (saidKind !== undefined)
+        kinds.push(...fieldOf(saidKind, 'value').split('|').filter(Boolean));
+    return [...new Set(kinds)];
+}
+export function classDefaults(root) {
+    return placesIn(root).flatMap((place) => {
+        const lock = ownLockOf(root, place);
+        return lock.filter((line) => fieldOf(line, 'scope').startsWith('class/') && fieldOf(line, 'value') !== 'withdraw')
+            .flatMap((line) => {
+            const kind = fieldOf(line, 'scope').slice('class/'.length);
+            const named = new Set(fieldOf(line, 'value').split('|').filter(Boolean));
+            return lock.filter((one) => named.has(fieldOf(one, 'scope')) && isCeiling(one))
+                .map((audit) => ({ classes: kind === '' ? [] : [kind], line: audit }));
+        });
+    });
+}
+export const fromPlace = (place, places) => (path) => (path === './' ? `${place}/` : places.some((one) => path.startsWith(`${one}/`)) ? path : `${place}/${path}`);
+/**
+ * What each place's own lock says for the tree, in the tree's names: the families bound's own lock lists, every need
+ * and every reader's module read from the place, and the scopes it lists under a place written with the place after
+ * the steps its glob names. A view the place writes and no need names is the place's own coordinate.
+ */
+const heard = new Map();
+export function spoken(root) {
+    const places = placesIn(root);
+    const parts = [ownLock(), ...places.map((place) => ownLockOf(root, place))];
+    const last = heard.get(root);
+    if (last !== undefined && last.parts.length === parts.length && last.parts.every((part, i) => part === parts[i]))
+        return last.got;
+    const got = speakingOf(root, places);
+    heard.set(root, { parts, got });
+    return got;
+}
+function speakingOf(root, places) {
+    const speaks = said(ownLock(), 'place/speaks');
+    const under = said(ownLock(), 'place/speaks-under');
+    if (!speaks.length && !under.length)
+        return [];
+    return places.flatMap((place) => ownLockOf(root, place).flatMap((line) => {
+        const got = parse(line);
+        const scope = fieldOf(line, 'scope');
+        const steps = scope.split('/');
+        const cut = under.flatMap((glob) => steps.map((_, i) => i + 1).filter((i) => i < steps.length && matches(glob, steps.slice(0, i).join('/')))).sort((a, b) => a - b)[0];
+        if (got.kind !== 'fact' || (cut === undefined && !speaks.some((glob) => matches(glob, scope))))
+            return [];
+        const fields = { ...got.value.fields };
+        const path = fromPlace(place, places);
+        if (cut !== undefined && steps[cut] !== place)
+            fields['scope'] = [...steps.slice(0, cut), place, ...steps.slice(cut)].join('/');
+        if (fields['needs'])
+            fields['needs'] = fields['needs'].split('|').filter(Boolean).map(path).join('|');
+        else if (fields['shape'] && fields['role'] === 'demands')
+            fields['needs'] = path(fields['shape']);
+        if (fields['measure'] === 'reader' && fields['value'])
+            fields['value'] = path(fields['value']);
+        return [{ place, line: canonical(fields) }];
+    }));
+}

package/dist/fold/rank.d.ts

@@ -0,0 +1,3 @@
+import type { PlaceFold } from '../cli/place.ts';
+/** What rests on a signed line: the rank of a signature is the lines that would move with it and nothing else. */
+export declare function rankLines(fold: PlaceFold): readonly string[];

package/dist/fold/rank.js

@@ -0,0 +1,9 @@
+import { fieldOf } from "./claims.js";
+/** What rests on a signed line: the rank of a signature is the lines that would move with it and nothing else. */
+export function rankLines(fold) {
+    const on = new Map();
+    for (const line of fold.standing)
+        for (const name of fieldOf(line, 'restsOn').split('|').filter(Boolean))
+            on.set(name, (on.get(name) ?? 0) + 1);
+    return [...on].sort((a, b) => b[1] - a[1]).map(([scope, n]) => `RANK     ${scope} · ${n} lines rest on it`);
+}

package/dist/fold/reach.d.ts

@@ -0,0 +1,13 @@
+import type { Capsule } from '../host/capsule.ts';
+export declare const placedAt: (places: readonly string[], line: string) => string | undefined;
+export declare function touchedBy(root: string, places: readonly string[], lines: readonly string[], standing: readonly string[]): readonly string[];
+/** A selected world can execute only its explicit capsule offers. Dependency aliases are host projections, not selections. */
+export declare const selectionLines: (fold: {
+    readonly root: string;
+    readonly standing: readonly string[];
+    readonly under?: string;
+}) => readonly string[];
+export declare function capsulesFor(standing: readonly string[], place: string, root?: string): readonly {
+    readonly capsule: Capsule;
+    readonly offer: string;
+}[];

package/dist/fold/reach.js

@@ -0,0 +1,65 @@
+import { selectedCapsules } from "../host/selected-capsules.js";
+import { basename } from "../host/io.js";
+import { matches } from '@lapxo/topos/wire';
+import { fieldOf } from "./claims.js";
+import { spoken, worldsIn } from "./places.js";
+import { wordOf, wordsOf } from "./wire.js";
+import { ownLock, ownRoot } from "../observe/runner.js";
+import { ownLockOf } from "./signed.js";
+const ROOT = '.';
+const WORLD = '\0';
+/**
+ * Who reads a line: the place its scope's first step names, or the one place its needs lie in but bound; every place for
+ * a line an own lock speaks, the published place bound is measured over, a line publish/takes carries into every place,
+ * a view, and a line whose needs are bound's own modules; the one place a later step of its scope names; and the root
+ * alone, where the places join, for every other line: no place's pages read it.
+ */
+function ownerIn(root, places, standing) {
+    const own = basename(ownRoot());
+    const words = new Set(spoken(root).map((one) => one.line));
+    const views = `${wordOf(standing, 'families', 'view')}/`;
+    const takes = ownLock().filter((line) => fieldOf(line, 'scope') === 'publish/takes').flatMap((line) => fieldOf(line, 'value').split('|').filter(Boolean));
+    return (line) => {
+        const scope = fieldOf(line, 'scope');
+        if (words.has(line))
+            return undefined;
+        const steps = scope.split('/');
+        if (places.includes(steps[0] ?? ''))
+            return steps[0];
+        const heads = new Set(fieldOf(line, 'needs').split('|').filter(Boolean).map((need) => need.split('/')[0] ?? ''));
+        const head = [...heads][0] ?? '';
+        if (heads.size === 1 && head !== own && places.includes(head))
+            return head;
+        if (scope.startsWith(views))
+            return wordsOf(standing, 'views/world').includes(scope.slice(views.length)) ? WORLD : undefined;
+        if (takes.some((glob) => matches(glob, scope)))
+            return undefined;
+        const named = places.filter((one) => steps.slice(1).includes(one));
+        if (named.length)
+            return named.length === 1 ? named[0] : undefined;
+        return heads.size && [...heads].every((one) => one === own) ? undefined : ROOT;
+    };
+}
+export const placedAt = (places, line) => {
+    const [first = '', next = ''] = fieldOf(line, 'scope').split('/');
+    return places.includes(first) ? first : places.includes(next) ? next : undefined;
+};
+export function touchedBy(root, places, lines, standing) {
+    const owners = lines.map(ownerIn(root, places, standing));
+    if (owners.some((one) => one === undefined))
+        return places;
+    const worlds = owners.some((one) => one === WORLD) ? worldsIn(root) : [];
+    return [...new Set([...owners.filter((one) => one !== undefined && one !== ROOT && one !== WORLD), ...worlds])].sort();
+}
+/** A selected world can execute only its explicit capsule offers. Dependency aliases are host projections, not selections. */
+export const selectionLines = (fold) => {
+    const local = fold.under ? ownLockOf(fold.root, fold.under.replace(/\/$/, '')).filter((line) => fieldOf(line, 'scope').startsWith('uses/')) : [];
+    const qualified = fold.standing.filter((line) => fieldOf(line, 'scope').startsWith(`${fold.under ?? ''}uses/`));
+    return [...new Set([...local, ...qualified])].filter((line) => fieldOf(line, 'value') !== 'withdraw');
+};
+export function capsulesFor(standing, place, root) {
+    const prefix = place ? `${place}/` : '';
+    const pins = root === undefined ? standing.filter(line => fieldOf(line, 'scope').startsWith(`${prefix}uses/`) && fieldOf(line, 'value') !== 'withdraw')
+        : selectionLines({ root, standing, ...(prefix ? { under: prefix } : {}) });
+    return selectedCapsules(pins);
+}