@lapxo/bound 0.1.0

package/dist/observe/regions.d.ts

@@ -0,0 +1,29 @@
+export { selectionLines } from '../fold/reach.ts';
+import type { Declaration } from '@lapxo/topos/capsule';
+import type { Request } from '@lapxo/topos/contract';
+import type { Capsule } from '../host/capsule.ts';
+import type { PlaceFold } from '../cli/place.ts';
+type Asking = {
+    readonly name: string;
+    readonly at: number;
+};
+type Placed = Pick<PlaceFold, 'root' | 'store' | 'standing' | 'observed'> & {
+    readonly under?: string;
+    readonly second?: PlaceFold['second'];
+};
+/** A declared selector keeps its contract token while the host binds only offered, concretely named regions. */
+export declare function regionNames(reads: readonly string[], descriptions: readonly string[]): readonly string[];
+export declare const describedReceipts: () => readonly string[];
+/** Execution is supplied only by explicit capsule offers of the selected standing. */
+export declare function capsulesOf(fold: Placed): readonly Capsule[];
+export declare const declaredBy: (fold: Placed) => readonly string[];
+type Ask = (declaration: Declaration, one: Asking, verb: 'render' | 'read', shape: string) => Request | undefined;
+/**
+ * What a region of a capsule is handed: of the reads its line declares, every read of the place's lines, and each region
+ * a line of the instrument's lock describes, with its lines and its receipts; a region no line describes is not handed,
+ * and a region handed less than it declares is refused by its capsule, which is every capsule's no. Nothing is handed
+ * as a file: the lines are the place as its published lock holds them, and each region is read once for the fold,
+ * however many views ask it.
+ */
+export declare const askingOf: (fold: Placed) => Ask;
+export declare function capsuleReadingsOver(fold: Placed): readonly string[];

package/dist/observe/regions.js

@@ -0,0 +1,200 @@
+import { selectedCapsules } from "../host/selected-capsules.js";
+import { selectionLines } from "../fold/reach.js";
+export { selectionLines } from "../fold/reach.js";
+import { createHash } from 'node:crypto';
+import { basename, dirname, join, relative } from 'node:path';
+import { CAPSULE, LOCK, canonical, matches, PROTOCOL } from '@lapxo/topos/wire';
+import { handed, readsOf } from '@lapxo/topos/capsule';
+import { STATES } from '@lapxo/obligations';
+import { foldCeilings } from "../fold/ceilings.js";
+import { fieldOf, wireLinesOf as linesOf } from "../fold/claims.js";
+import { isCeiling } from "../fold/configures.js";
+import { keyFor } from "../fold/keys.js";
+import { casesHeld, placedReadings } from "../fold/observed.js";
+import { verdictsFor } from "../fold/paid.js";
+import { capsuleAt as isWorld, placesIn, spoken } from "../fold/places.js";
+import { rolesOf } from "../fold/roles.js";
+import { ownLockOf } from "../fold/signed.js";
+import { wordOn } from "../fold/wire.js";
+import { placesOf, viewsOf } from "../fold/views.js";
+import { zoomed } from "../fold/zoom.js";
+import { sourced } from "../land/vouched.js";
+import { coordinatesUnder, observeText } from "./files.js";
+import { ownLock } from "./runner.js";
+import { nameOf } from "../render/page.js";
+import { placeLines, takenFor } from "../fold/place-inputs.js";
+const fact = (scope, value, form = 'alphabet', measure = 'fact') => canonical({ scope, role: 'writes', form, measure, value, by: 'fold', at: 'place:fold' });
+const described = (local = []) => {
+    const lock = ownLock();
+    const measures = ['lines', 'receipts', 'reads', wordOn(lock, 'region-coordinate', lock), wordOn(lock, 'region-leaf', lock)];
+    const eligible = (line) => fieldOf(line, 'scope').startsWith('region/') && measures.includes(fieldOf(line, 'measure')) && fieldOf(line, 'value') !== 'withdraw';
+    const key = (line) => `${fieldOf(line, 'scope')} ${fieldOf(line, 'measure')}`;
+    const supplied = local.filter(eligible);
+    const overridden = new Set(supplied.map(key));
+    return [...lock.filter(eligible).filter((line) => !overridden.has(key(line))), ...supplied];
+};
+/** A declared selector keeps its contract token while the host binds only offered, concretely named regions. */
+export function regionNames(reads, descriptions) {
+    const names = [...new Set(descriptions.map((line) => fieldOf(line, 'scope')).filter((scope) => scope.startsWith('region/') && !/[?*]/.test(scope)))];
+    return names.filter((scope) => reads.some((read) => read.startsWith('region/') && matches(read, scope))).map((scope) => scope.slice('region/'.length));
+}
+export const describedReceipts = () => described().filter((line) => fieldOf(line, 'measure') === 'receipts')
+    .flatMap((line) => fieldOf(line, 'value').split('|').filter(Boolean));
+function factsOf(fold) {
+    const here = join(fold.root, fold.under ?? '');
+    const written = [...viewsOf(fold.standing).values()].flatMap((view) => ('regions' in view && view.shape && observeText(join(here, view.shape)) !== undefined ? [view.shape] : []));
+    return [fact('cases/held', String(casesHeld(fold.observed))), ...(fold.second ? [fact('second/verdict', fold.second.verdict)] : []),
+        ...[...new Set(written)].map((shape) => fact(`${sourced(fold.standing)}/${shape}`, 'present')), ...('ceilings' in fold ? [...readingsOf(fold), ...verdictOf(fold), ...(released(fold) ? [] : askedOf(fold))] : []), ...coordinatesOf(fold)];
+}
+/** The place's own ceilings as the fold reads them, one line a ceiling at the scope the place speaks it: the bound stays its line's. */
+function readingsOf(fold) {
+    const held = fold.standing.filter((line) => fieldOf(line, 'value') !== 'withdraw');
+    const ceilings = held.filter((line) => isCeiling(line) && (!fold.under || takenFor(held, `${nameOf(fold)}/`)(line)));
+    const read = foldCeilings({ standing: fold.standing, ceilings, observed: fold.observed, own: fold.own, epoch: fold.epoch }).readings;
+    const spans = (got) => got.map((one) => (one.split(' ').at(-1) ?? '').split('..').map(Number)).filter((span) => span.every(Number.isFinite));
+    return ceilings.flatMap((line) => ((got) => (got === undefined ? [] : [canonical({ scope: fieldOf(fold.under ? zoomed(line, nameOf(fold)) : line, 'scope'), role: 'reads', measure: fieldOf(line, 'measure'), by: 'fold', at: 'place:fold',
+            ...(spans(got).length === got.length ? { form: 'interval', value: `${Math.min(...spans(got).map((span) => span[0]))}..${Math.max(...spans(got).map((span) => span.at(-1)))}` } : { form: 'alphabet', value: [...new Set(got)].join('|') }) })]))(read.get(fieldOf(line, 'scope'))));
+}
+const released = (fold) => fold.standing.some((line) => [`publish/${nameOf(fold)}/bootstrap`, 'publish/bootstrap'].includes(fieldOf(line, 'scope')) && fieldOf(line, 'value') !== 'withdraw');
+const pinnersOf = (fold) => [...new Set(fold.standing.filter((line) => fieldOf(line, 'value') !== 'withdraw')
+        .flatMap((line) => ((steps) => (steps.length === 3 && steps[1] === 'uses' && steps[2] === nameOf(fold) ? [steps[0]] : []))(fieldOf(line, 'scope').split('/'))))];
+const capsuleOf = (fold) => [CAPSULE, LOCK].map((file) => linesOf(observeText(join(fold.root, fold.under ?? '', file))))
+    .find((lines) => lines.some((line) => fieldOf(line, 'scope').startsWith('capsule/'))) ?? [];
+const coordinatesOf = (fold) => ((here, role) => (!isWorld(fold.root, (fold.under ?? '').replace(/\/$/, '')) || (fold.under === undefined && !released(fold)) ? []
+    : coordinatesUnder(here, here, (dir) => dir === '' || (!basename(dir).startsWith('.') && role(relative(dirname(fold.store), join(here, dir))) !== 'foreign'))
+        .map((file) => fact(`coordinate/${file}`, neededBy(fold.standing, fold.under ?? '', file) ? 'needed' : 'present'))))(join(fold.root, fold.under ?? ''), rolesOf(fold.store));
+const neededBy = (standing, under, file) => standing.some((line) => fieldOf(line, 'value') !== 'withdraw' && fieldOf(line, 'measure') !== 'reader'
+    && fieldOf(line, 'needs').split('|').some((need) => !['', './', under].includes(need) && (need === `${under}${file}` || (need.endsWith('/') && `${under}${file}`.startsWith(need)) || matches(need, `${under}${file}`))));
+function askedOf(fold) {
+    const at = (place) => ((lines) => ((views) => new Set(views.filter((view) => placesOf(lines, view).includes(`${place}/`) || (!placesOf(lines, view).length
+        && observeText(join(fold.root, place, view.shape)) !== undefined && !views.some((other) => other.shape === view.shape && placesOf(lines, other).includes(`${place}/`)))).flatMap((view) => view.regions.map((one) => one.name))))([...viewsOf(lines).values()].flatMap((view) => ('regions' in view && view.shape ? [view] : []))))([...ownLockOf(fold.root, place, true), ...fold.standing]);
+    return fold.under ? [...new Set(capsuleOf(fold).filter((line) => fieldOf(line, 'scope').startsWith('region/') && fieldOf(line, 'role') === 'render').map((line) => fieldOf(line, 'scope').slice('region/'.length)))]
+        .map((name) => ((n) => fact(`asked/${name}`, `${n}..${n}`, 'interval', 'count'))(pinnersOf(fold).map(at).filter((names) => names.has(name)).length)) : [];
+}
+/** The place's verdict line as counts: what the fold lands, forks and refuses, each of the object's four states, and the ceilings it meets. */
+function verdictOf(fold) {
+    const states = Object.values(verdictsFor(fold));
+    const named = (line) => ((cut) => [line.slice(0, cut < 0 ? line.length : cut).trim(), line.slice(cut < 0 ? line.length : cut + 3).trim() || line])(line.indexOf(' · '));
+    const here = (fold.under ?? '').replace(/\/$/, '');
+    const others = new Set(here ? placesIn(fold.root).filter((place) => place !== here) : []);
+    const mine = (scope) => {
+        if (!here)
+            return true;
+        if (scope === here || scope.startsWith(`${here}/`))
+            return true;
+        const head = scope.split('/')[0] ?? '';
+        return !others.has(head);
+    };
+    return [['claims', fold.claims], ['forks', fold.forks.length + (fold.second.verdict === 'forks' ? 1 : 0)], ['refused', fold.refused.length], ['vacuous', fold.vacuous], ['history', fold.history.length],
+        ['met', fold.ceilings.read], ['short', fold.ceilings.short.length], ['over', fold.ceilings.over.length], ...STATES.map((one) => [one, states.filter((state) => state === one).length])].map(([name, n]) => fact(`verdict/${name}`, `${n}..${n}`, 'interval', 'count'))
+        .concat(fold.ceilings.short.filter((one) => mine(named(one)[0])).map((one) => (([scope, reading]) => fact(`unpaid/${scope}`, reading))(named(one))))
+        .concat(fold.ceilings.over.filter((one) => mine(named(one)[0])).map((one) => (([scope, reading]) => fact(`outside/${scope}`, reading))(named(one))))
+        .concat(fold.ceilings.unread.filter(mine).map((scope) => fact(`unpaid/${scope}`, 'unread')))
+        .concat(fold.missing.filter((line) => mine(fieldOf(line, 'scope'))).map((line) => fact(`unpaid/${fieldOf(line, 'scope')}`, 'unpaid')))
+        .concat([
+        fact('walk/read', `${fold.own['walk-read'] ?? 0}..${fold.own['walk-read'] ?? 0}`, 'interval', 'count'),
+        fact('walk/ms', `${fold.own['walk-ms'] ?? 0}..${fold.own['walk-ms'] ?? 0}`, 'interval', 'count'),
+    ]);
+}
+function regionOf(fold, name, lines, facts) {
+    const here = fold.under ?? '';
+    const said = (measure) => handed([`region/${name}`], lines).filter((fields) => fields['measure'] === measure)
+        .flatMap((fields) => (fields['value'] ?? '').split('|').filter(Boolean));
+    const globs = said('receipts');
+    const placed = placedReadings(fold.observed).filter((one) => one.place.startsWith(here) && globs.some((glob) => matches(glob, one.question)))
+        .map((one) => canonical({ scope: one.question, role: 'reads', form: 'alphabet', measure: one.measure, value: one.value, by: one.by, evidence: one.at, at: `place:${one.place.slice(here.length).replace(/^\.\/$/, '')}` }));
+    const role = rolesOf(fold.store);
+    const walked = coordinatesUnder(join(fold.root, here), fold.root, (dir) => dir === '' || (!basename(dir).startsWith('.') && role(relative(dirname(fold.store), join(fold.root, dir))) !== 'foreign'));
+    const named = wordOn(fold.standing, 'region-coordinate', ownLock());
+    const files = said(named).flatMap((glob) => walked.filter((file) => matches(glob, file.slice(here.length)) || matches(glob, file)));
+    const saidLines = files.flatMap((file) => {
+        if (basename(file) === 'TARGET.bound' || basename(file) === 'receipts.bound')
+            return [];
+        const lock = linesOf(observeText(join(fold.root, file)));
+        return lock.length ? [canonical({ scope: 'said/lines', role: 'reads', form: 'alphabet', measure: 'lines', value: lock.join('\n'), by: 'reader', at: `place:${file}` })] : [];
+    });
+    return {
+        lines: said('lines').flatMap((coordinate) => linesOf(observeText(join(fold.root, here, coordinate)))),
+        receipts: [...placed, ...saidLines, ...(globs.length ? facts() : []).filter((line) => globs.some((glob) => matches(glob, fieldOf(line, 'scope'))))],
+    };
+}
+/** A local selection belongs to its own lock; tree-qualified selections retain their explicit owner. */
+const heldCapsules = new WeakMap();
+/** Execution is supplied only by explicit capsule offers of the selected standing. */
+export function capsulesOf(fold) {
+    const cached = heldCapsules.get(fold);
+    if (cached !== undefined)
+        return cached;
+    const got = selectedCapsules(selectionLines(fold)).map(one => one.capsule);
+    heldCapsules.set(fold, got);
+    return got;
+}
+export const declaredBy = (fold) => [...new Set(capsulesOf(fold).flatMap((capsule) => capsule.declaration.renders))];
+const asks = new WeakMap();
+/**
+ * What a region of a capsule is handed: of the reads its line declares, every read of the place's lines, and each region
+ * a line of the instrument's lock describes, with its lines and its receipts; a region no line describes is not handed,
+ * and a region handed less than it declares is refused by its capsule, which is every capsule's no. Nothing is handed
+ * as a file: the lines are the place as its published lock holds them, and each region is read once for the fold,
+ * however many views ask it.
+ */
+export const askingOf = (fold) => asks.get(fold) ?? asks.set(fold, handing(fold)).get(fold);
+function handing(fold) {
+    const capsule = linesOf(observeText(join(fold.root, fold.under ?? '', CAPSULE))).filter((line) => fieldOf(line, 'scope').startsWith('region/'));
+    const seen = handed(['**'], fold.under ? placeLines(fold) : fold.standing);
+    const lines = described(seen.map((fields) => canonical(fields)));
+    let held;
+    const facts = () => (held ?? (held = factsOf(fold)));
+    const regions = new Map();
+    const region = (name) => regions.get(name) ?? regions.set(name, regionOf(fold, name, lines, facts)).get(name);
+    return (declaration, one, verb, shape) => {
+        const declared = readsOf(declaration, one.name);
+        if (declared === undefined)
+            return undefined;
+        const reads = declared.filter((read) => !read.startsWith('region/') || handed([read], lines).length > 0 || (matches(read, 'region/capsule') && capsule.length > 0));
+        const names = [...new Set([...regionNames(reads, lines), ...(capsule.length && reads.some((read) => matches(read, 'region/capsule')) ? ['capsule'] : [])])];
+        return { protocol: PROTOCOL, verb, rootScope: fold.under ?? '', files: [], region: one.name, at: one.at, shape, name: nameOf(fold) || basename(fold.root),
+            lines: seen
+                .filter((fields) => reads.some((read) => matches(read, fields['scope'] ?? ''))).map((fields) => canonical(fields)), reads,
+            regions: Object.fromEntries(names.map((name) => [name, name === 'capsule' && capsule.length ? { lines: capsule, receipts: [] } : region(name)])) };
+    };
+}
+const read = new WeakMap();
+function capsuleReadings(fold) {
+    const place = fold.under || './';
+    const known = read.get(fold.observed) ?? read.set(fold.observed, new Map()).get(fold.observed);
+    return known.get(place) ?? known.set(place, readingsAt(fold, place)).get(place);
+}
+function readingsAt(fold, place) {
+    const asking = askingOf(fold);
+    const speaker = keyFor(fold.store, 'read');
+    return capsulesOf(fold).flatMap((capsule) => {
+        const writing = new Set(capsule.lines.filter((line) => fieldOf(line, 'scope').startsWith('region/') && fieldOf(line, 'measure') === 'writes').map((line) => fieldOf(line, 'scope').slice('region/'.length)));
+        const receipts = Object.keys(capsule.declaration.writes).filter((name) => capsule.declaration.writes[name] === 'receipt' && !writing.has(name)).sort();
+        const requests = receipts.flatMap((name) => ((request) => (request === undefined ? [] : [request]))(asking(capsule.declaration, { name, at: 3 }, 'read', '')));
+        const answers = capsule.ask(requests);
+        const refused = requests.filter((_, i) => answers[i]?.kind !== 'fact');
+        if (refused.length)
+            throw new Error(`REFUSE·capsule ${capsule.digest} · ${place} · ${refused.length} of ${requests.length} regions: ${refused.map((one) => one.region).join(' ')} · ${answers[requests.indexOf(refused[0])]?.why ?? 'no answer'}`);
+        return requests.flatMap((request, i) => {
+            const said = answers[i];
+            if (said?.kind !== 'fact')
+                return [];
+            const digest = createHash('sha256').update(JSON.stringify(request)).digest('hex');
+            const at = `place:sha256:${digest}`;
+            const by = `${speaker}:${capsule.digest.slice(7, 19)}`;
+            const line = (row) => canonical({ scope: row.scope, role: row.role, form: row.bound.kind === 'interval' ? 'interval' : 'alphabet', measure: row.measure,
+                value: row.bound.kind === 'interval' ? `${row.bound.lo ?? 0}..${row.bound.hi ?? 0}` : (row.bound.values ?? []).join('|'), by, at });
+            return [canonical({ scope: place, role: 'writes', form: 'alphabet', measure: 'observed', value: digest.slice(0, 16), by, at }),
+                ...(said.claims ?? []).map(line)];
+        });
+    });
+}
+export function capsuleReadingsOver(fold) {
+    if (fold.under)
+        return capsuleReadings(fold);
+    const said = spoken(fold.root);
+    const places = [...new Set(fold.standing.flatMap((line) => /^([^/]+)\/uses\//.exec(fieldOf(line, 'scope'))?.[1] ?? []))];
+    return [...capsuleReadings(fold), ...places.flatMap((place) => capsuleReadings({ ...fold, under: `${place}/`,
+            standing: [...new Set([...said.filter((one) => one.place === place).map((one) => one.line), ...fold.standing])] }))];
+}

package/dist/observe/run.d.ts

@@ -0,0 +1,30 @@
+export type Kind = 'js' | 'process';
+/** The kinds this host starts. A reader of any other kind is signed and stays potential: nothing here runs it. */
+export declare const runs: (kind: string) => kind is Kind;
+interface Row {
+    readonly scope: string;
+    readonly measure: string;
+    readonly role: string;
+    readonly bound: {
+        readonly kind: string;
+        readonly values?: readonly string[];
+        readonly lo?: number;
+        readonly hi?: number;
+    };
+}
+interface Input {
+    readonly place: string;
+    readonly text?: string;
+    readonly held?: readonly (readonly [string, string])[];
+    readonly region?: string;
+}
+/** The host end of the contract, beside the command that started this process: a module runs in a process of its own. */
+export declare const hostOf: () => string;
+/**
+ * A reader runs as a process of its own, started by the runtime from the module its lock names, in the root its places
+ * are named from: the instrument loads no capsule into itself. It is asked through the one contract, each place with
+ * the file it is handed or alone when it reads the place by running it, as the region it was matched for when its
+ * capsule reads with several, and answers one list of claims per place.
+ */
+export declare function runReader(module: string, root: string, inputs: readonly Input[]): readonly (readonly Row[])[];
+export {};

package/dist/observe/run.js

@@ -0,0 +1,34 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { PROTOCOL } from '@lapxo/topos/wire';
+import { responsesOf } from '@lapxo/topos/contract';
+import { processOf, readerOf } from "./runner.js";
+/** The kinds this host starts. A reader of any other kind is signed and stays potential: nothing here runs it. */
+export const runs = (kind) => kind === 'js' || kind === 'process';
+/** The host end of the contract, beside the command that started this process: a module runs in a process of its own. */
+export const hostOf = () => processOf('host');
+/**
+ * A reader runs as a process of its own, started by the runtime from the module its lock names, in the root its places
+ * are named from: the instrument loads no capsule into itself. It is asked through the one contract, each place with
+ * the file it is handed or alone when it reads the place by running it, as the region it was matched for when its
+ * capsule reads with several, and answers one list of claims per place.
+ */
+export function runReader(module, root, inputs) {
+    if (!inputs.length)
+        return [];
+    const requests = inputs.map((input) => ({
+        protocol: PROTOCOL, verb: 'read', rootScope: input.place, files: input.text === undefined ? [] : [{ place: input.place, text: input.text }], ...(input.held ? { held: input.held } : {}),
+        ...(input.region ? { region: input.region } : {}),
+    }));
+    const reader = readerOf(module);
+    if (!existsSync(reader.path))
+        throw new Error(`REFUSE·reader ${module} unavailable; its declared capability needs an admitted provider`);
+    const ran = spawnSync(process.execPath, [...reader.flags, hostOf(), reader.path, module], { cwd: root, input: JSON.stringify(requests), encoding: 'utf8', maxBuffer: 1 << 28 });
+    if (ran.error)
+        throw Object.assign(new Error(`${module}: reader process failed: ${ran.error.message}`), { cause: ran.error });
+    if (ran.status !== 0)
+        throw new Error(`${module}: reader exited ${ran.status ?? `with signal ${ran.signal}`}\n${ran.stderr ?? ''}${ran.stdout ?? ''}`);
+    if (ran.stderr)
+        process.stderr.write(ran.stderr);
+    return responsesOf(ran.stdout ?? '', inputs.length).map((answer) => (answer.claims ?? []));
+}

package/dist/observe/runner.d.ts

@@ -0,0 +1,16 @@
+export declare const ownRoot: () => string;
+export declare const ownStore: () => string;
+export declare const ownLock: () => readonly string[];
+export declare const sourceOf: () => string;
+export declare function processOf(name: string, folder?: string): string;
+/**
+ * A reader's code is what the bundler takes of it: its module and every file that module imports, wherever it lies, as
+ * one blob of the tree's store named by the digest of its bytes. The files the bundler read, at the stamps they had, key
+ * the blob, so it is built again only when one of them moved, and a helper a step above the module is one of them.
+ */
+export declare function bundleOf(module: string): string | undefined;
+/** A reader run by a blob is a blob itself: its bundle, with everything it imports but the compiler. */
+export declare function readerOf(module: string): {
+    readonly path: string;
+    readonly flags: readonly string[];
+};

package/dist/observe/runner.js

@@ -0,0 +1,83 @@
+import { spawnSync } from 'node:child_process';
+import { sha } from "../host/hash.js";
+import { existsSync, mkdirSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fieldOf } from "../fold/claims.js";
+import { observeFile, observeText } from "./files.js";
+import { ownLockOf } from "../fold/signed.js";
+import { landBlob } from "../land/ledger.js";
+import { EXTENSION, LOCK, publicLock } from '@lapxo/topos/wire';
+import { foldClaims, isWire } from "../fold/claims.js";
+const self = () => process.argv[1] ?? '';
+const fromBlob = () => extname(existsSync(self()) ? realpathSync(self()) : self()) === '';
+/**
+ * Where the instrument lies and what it is run from: from source or compiled modules, bound is two steps above this runner module; as a blob, the command is a blob of the tree's store, named by the digest bound's own lock names for
+ * it, and bound lies beside that store. Other processes use the same runtime directory and extension; only source readers receive source conditions. A name that resolves to no blob beside it is refused by name
+ * before anything is started, never handed to the runtime as the store's own directory.
+ */
+// Blob bundles have no module URL; source and compiled modules carry their own entry location.
+const moduleAt = fromBlob() ? undefined : fileURLToPath(import.meta.url);
+const runtimeAt = moduleAt === undefined ? '' : resolve(dirname(moduleAt), '..');
+const runtimeExtension = moduleAt === undefined ? '' : extname(moduleAt);
+export const ownRoot = () => (fromBlob() ? join(resolve(dirname(self()), '..', '..', '..'), 'bound') : resolve(runtimeAt, '..'));
+export const ownStore = () => join(ownRoot(), '..', EXTENSION);
+/** The colocated public artifact is read without an unrelated parent's authority store. */
+// An act is judged by the instrument it started with, even when that act changes its colocated lock.
+let instrumentLock;
+export const ownLock = () => {
+    if (instrumentLock !== undefined)
+        return instrumentLock;
+    const lines = (observeText(join(ownRoot(), LOCK)) ?? '').split('\n').filter(isWire);
+    const published = publicLock(lines);
+    instrumentLock = published === undefined ? ownLockOf(join(ownRoot(), '..'), basename(ownRoot()), true) : foldClaims(published).standing;
+    return instrumentLock;
+};
+export const sourceOf = () => (fromBlob() ? join(ownRoot(), 'src', 'cli', 'verb.ts') : self());
+export function processOf(name, folder) {
+    if (!fromBlob())
+        return join(runtimeAt, folder ?? 'cli', `${name}${runtimeExtension}`);
+    const named = ownLock().find((line) => fieldOf(line, 'scope') === `runner/${name}`);
+    const blob = fieldOf(named ?? '', 'value').replace(/^[^:]*:/, '');
+    if (!blob || !existsSync(join(dirname(self()), blob))) {
+        throw new Error(`${basename(ownRoot())}: REFUSE·alias runner/${name} resolves to no blob: ${named === undefined ? 'no signed line of the instrument\'s own lock names it' : `${fieldOf(named, 'value')} is not beside ${basename(self())}`}`);
+    }
+    return join(dirname(self()), blob);
+}
+/**
+ * A reader's code is what the bundler takes of it: its module and every file that module imports, wherever it lies, as
+ * one blob of the tree's store named by the digest of its bytes. The files the bundler read, at the stamps they had, key
+ * the blob, so it is built again only when one of them moved, and a helper a step above the module is one of them.
+ */
+export function bundleOf(module) {
+    const tree = join(ownRoot(), '..');
+    const named = fieldOf(ownLock().find((line) => fieldOf(line, 'scope') === 'host/bundler') ?? '', 'value');
+    const bundler = named && existsSync(join(tree, named)) ? join(tree, named) : '';
+    if (!bundler)
+        return undefined;
+    const store = join(tree, EXTENSION);
+    const stamp = (coordinate) => ((at) => (at === undefined ? '' : `${at.mtimeMs} ${at.size}`))(statSync(join(tree, coordinate), { throwIfNoEntry: false }));
+    const index = join(store, 'cas', 'built', sha(`bundle ${module}`));
+    const held = JSON.parse(observeText(index) ?? 'null');
+    if (held !== null && existsSync(join(store, 'cas', 'blobs', held.blob)) && held.inputs.every(([coordinate, was]) => stamp(coordinate) === was))
+        return held.blob;
+    const [meta, out] = [`${index}.${process.pid}.json`, `${index}.${process.pid}.js`];
+    mkdirSync(dirname(index), { recursive: true });
+    const built = spawnSync(bundler, [module, '--bundle', '--platform=node', '--format=cjs', '--external:typescript', '--log-level=error', `--metafile=${meta}`, `--outfile=${out}`], { cwd: tree });
+    const inputs = Object.keys(JSON.parse(observeText(meta) ?? '{}').inputs ?? {}).sort();
+    const bytes = observeFile(out);
+    rmSync(meta, { force: true });
+    rmSync(out, { force: true });
+    if (built.status !== 0 || bytes === undefined || !bytes.length || !inputs.length)
+        return undefined;
+    const hex = sha(bytes);
+    landBlob(store, `sha256:${hex}`, bytes);
+    writeFileSync(index, `${JSON.stringify({ blob: hex, inputs: inputs.map((coordinate) => [coordinate, stamp(coordinate)]) })}\n`);
+    return hex;
+}
+/** A reader run by a blob is a blob itself: its bundle, with everything it imports but the compiler. */
+export function readerOf(module) {
+    const source = { path: module, flags: runtimeExtension === '.ts' ? ['--disable-warning=ExperimentalWarning', '--disable-warning=MODULE_TYPELESS_PACKAGE_JSON'] : [] };
+    const hex = fromBlob() ? bundleOf(module) : undefined;
+    return hex === undefined ? source : { path: join(ownStore(), 'cas', 'blobs', hex), flags: [] };
+}

package/dist/render/capsule.d.ts

@@ -0,0 +1,24 @@
+import type { PlaceFold } from '../cli/place.ts';
+type Asking = {
+    readonly name: string;
+    readonly at: number;
+};
+type Viewed = {
+    readonly asking: readonly Asking[];
+    readonly shape: string;
+};
+export declare const capsuleRegions: (fold: PlaceFold, asking: readonly Asking[], shape?: string) => ReadonlyMap<string, readonly string[]>;
+/**
+ * A region this instrument does not render is rendered by a capsule: one the place uses by the digest of its lock and
+ * its bytes, or else one the instrument carries. What the views of one fold ask of each capsule is asked at once; a
+ * region one capsule answered is not asked of another, and one it refused or never answered is named and asked of the
+ * next only when no region was offered. A refusal from an offered region stops the request; it never selects another implementation.
+ */
+export declare const capsuleViews: (fold: PlaceFold, views: readonly Viewed[]) => readonly ReadonlyMap<string, readonly string[]>[];
+type Answer = {
+    readonly lines: readonly string[];
+    readonly by: string;
+};
+/** What each capsule answered a view's regions with, the capsule by its digest, and whether the place's pin chose it. */
+export declare function capsuleAnswers(fold: PlaceFold, views: readonly Viewed[]): readonly ReadonlyMap<string, Answer>[];
+export {};

package/dist/render/capsule.js

@@ -0,0 +1,30 @@
+import { matches } from '@lapxo/topos/wire';
+import { askingOf, capsulesOf } from "../observe/regions.js";
+export const capsuleRegions = (fold, asking, shape = '') => capsuleViews(fold, [{ asking, shape }])[0] ?? new Map();
+/**
+ * A region this instrument does not render is rendered by a capsule: one the place uses by the digest of its lock and
+ * its bytes, or else one the instrument carries. What the views of one fold ask of each capsule is asked at once; a
+ * region one capsule answered is not asked of another, and one it refused or never answered is named and asked of the
+ * next only when no region was offered. A refusal from an offered region stops the request; it never selects another implementation.
+ */
+export const capsuleViews = (fold, views) => capsuleAnswers(fold, views).map((answers) => new Map([...answers].map(([name, answer]) => [name, answer.lines])));
+/** What each capsule answered a view's regions with, the capsule by its digest, and whether the place's pin chose it. */
+export function capsuleAnswers(fold, views) {
+    const outs = views.map(() => new Map());
+    if (!views.some((view) => view.asking.length))
+        return outs;
+    const asking = askingOf(fold);
+    for (const capsule of capsulesOf(fold)) {
+        const asked = views.flatMap((view, i) => view.asking.filter((one) => capsule.declaration.renders.some((glob) => matches(glob, one.name)) && !outs[i].has(one.name))
+            .flatMap((one) => ((request) => (request === undefined ? [] : [{ i, one, request }]))(asking(capsule.declaration, one, 'render', view.shape))));
+        const answers = capsule.ask(asked.map((one) => one.request));
+        asked.forEach(({ i, one, request }, at) => {
+            const said = answers[at];
+            if (said?.kind === 'fact')
+                outs[i].set(one.name, { lines: ((got) => got.lines ?? got.leaf ?? [])(said), by: capsule.digest });
+            else
+                throw new Error(`REFUSE·capsule ${capsule.digest} · ${request.rootScope}${one.name} · ${said?.why ?? 'no answer'}`);
+        });
+    }
+    return outs;
+}

package/dist/render/field.d.ts

@@ -0,0 +1,9 @@
+import type { PlaceFold } from '../cli/place.ts';
+/**
+ * The field of a place at resolution N: every bound placed at the place or at none, in the state its poles give, and
+ * every coordinate cut to its first N steps in the worst state it holds. Interval poles with no value in common
+ * conflict, as two signers on one key do; an alphabet that permits none is a ceiling like any other. A value read
+ * outside the poles is forbidden; a bound nothing read, a reader that refused and a demand unpaid are required; the
+ * rest is free. It is read off the region summaries and the landed readings, and no reader runs.
+ */
+export declare function field(fold: PlaceFold, at: number): readonly string[];

package/dist/render/field.js

@@ -0,0 +1,46 @@
+import { fieldOf } from "../fold/claims.js";
+import { placesIn } from "../fold/places.js";
+import { placedAt } from "../fold/reach.js";
+import { polesOf, rankOf, unpackRegions } from "../fold/region.js";
+import { INTERVALS } from '@lapxo/topos/forms';
+const WORST = ['CONFLICT', 'FORBIDDEN', 'REQUIRED', 'FREE'];
+const empty = (ceiling) => ceiling !== undefined && 'lo' in ceiling && !INTERVALS.inhabited(ceiling);
+/**
+ * The field of a place at resolution N: every bound placed at the place or at none, in the state its poles give, and
+ * every coordinate cut to its first N steps in the worst state it holds. Interval poles with no value in common
+ * conflict, as two signers on one key do; an alphabet that permits none is a ceiling like any other. A value read
+ * outside the poles is forbidden; a bound nothing read, a reader that refused and a demand unpaid are required; the
+ * rest is free. It is read off the region summaries and the landed readings, and no reader runs.
+ */
+export function field(fold, at) {
+    if (fold.regions === undefined)
+        return ['GREY     field · this fold carries no region summaries; it is read again at the next fold'];
+    const regions = unpackRegions(fold.regions);
+    const places = placesIn(fold.root);
+    const place = fold.under?.replace(/\/$/, '');
+    const here = (line) => place === undefined || [place, undefined].includes(placedAt(places, line));
+    const own = { ...fold.own, unread: fold.ceilings.unread.length + fold.ceilings.vacuous.length };
+    const poles = new Map();
+    const states = [
+        ...regions.bounds.filter((bound) => here(bound.line)).map((bound) => {
+            const ceiling = (poles.get(bound.region) ?? poles.set(bound.region, polesOf(regions, bound.region)).get(bound.region)).get(`${bound.question} ${bound.measure}`)?.ceiling;
+            const got = rankOf(regions, bound, own);
+            return [fieldOf(bound.line, 'scope'), empty(ceiling) ? 'CONFLICT' : got.bars || got.sums ? 'FORBIDDEN' : got.met ? 'FREE' : 'REQUIRED'];
+        }),
+        ...fold.missing.filter(here).map((line) => [fieldOf(line, 'scope'), 'REQUIRED']),
+        ...fold.forks.flatMap((fork) => fork.lines.slice(0, 1)).filter(here).map((line) => [fieldOf(line, 'scope'), 'CONFLICT']),
+    ];
+    const cells = new Map();
+    for (const [scope, state] of states) {
+        const cell = scope.split('/').slice(0, Math.max(1, at)).join('/');
+        const held = cells.get(cell);
+        cells.set(cell, { state: held !== undefined && WORST.indexOf(held.state) < WORST.indexOf(state) ? held.state : state, bounds: (held?.bounds ?? 0) + 1 });
+    }
+    const ordered = [...cells].sort((a, b) => WORST.indexOf(a[1].state) - WORST.indexOf(b[1].state) || a[0].localeCompare(b[0]));
+    return [
+        '## field', '', '```',
+        `FIELD    @${at} · ${cells.size} cells · ${states.length} bounds · ${WORST.map((state) => `${state} ${ordered.filter(([, one]) => one.state === state).length}`).join(' · ')}`,
+        ...ordered.map(([cell, one]) => `FIELD    ${cell} · ${one.state} · ${one.bounds} bounds`),
+        '```',
+    ];
+}

package/dist/render/names.d.ts

@@ -0,0 +1,3 @@
+/** The regions bound renders itself, by name: a view that asks any other is answered by a capsule that declares it, or refused whole. */
+export declare const REGION_NAMES: readonly ["receipts", "help", "lines", "red", "forks", "programs", "why", "sign", "take", "history", "field"];
+export type RegionName = (typeof REGION_NAMES)[number];

package/dist/render/names.js

@@ -0,0 +1,4 @@
+/** The regions bound renders itself, by name: a view that asks any other is answered by a capsule that declares it, or refused whole. */
+export const REGION_NAMES = [
+    'receipts', 'help', 'lines', 'red', 'forks', 'programs', 'why', 'sign', 'take', 'history', 'field',
+];

package/dist/render/open.d.ts

@@ -0,0 +1,27 @@
+export interface OpenCell {
+    readonly scope: string;
+    readonly ceiling: string;
+    readonly bits: number | null;
+    readonly freedom: string;
+    readonly states: readonly string[];
+    readonly origins: readonly string[];
+    readonly rank: number;
+    readonly cone: string;
+}
+/**
+ * What is open, as cells, taken once when the tree is folded and read by the view rather than taken again at every
+ * render. A line of the lock with more than one bit still free is a question this tree has not answered; a cell with
+ * one legal state is applied and not open; a cell a reading has already answered is applied whatever its width; a
+ * cell standing on one origin with a closer already named is asked and not open. A cell says of itself that it is a
+ * decision: a ceiling in force is not a question because it is wide, and a lock with no decision in it is a lock with
+ * nothing open, which the render says by saying nothing. What each state would be worth is rendered beside it, and a quantity this instrument cannot yet take is
+ * rendered grey with the name of what would take it, never as a number it invented.
+ */
+export declare function openCells(input: {
+    readonly store: string;
+    readonly standing: readonly string[];
+    readonly observed: readonly string[];
+    readonly grey: readonly string[];
+    readonly epoch: number;
+}): readonly OpenCell[];
+export declare const openCards: (open: readonly OpenCell[]) => readonly string[];

package/dist/render/open.js

@@ -0,0 +1,61 @@
+import { fieldOf } from "../fold/claims.js";
+import { alphabet } from '@lapxo/topos/wire';
+import { declaredConfig as declared } from '@lapxo/topos/forms';
+import { bytesDigest } from "../fold/digests.js";
+/**
+ * What is open, as cells, taken once when the tree is folded and read by the view rather than taken again at every
+ * render. A line of the lock with more than one bit still free is a question this tree has not answered; a cell with
+ * one legal state is applied and not open; a cell a reading has already answered is applied whatever its width; a
+ * cell standing on one origin with a closer already named is asked and not open. A cell says of itself that it is a
+ * decision: a ceiling in force is not a question because it is wide, and a lock with no decision in it is a lock with
+ * nothing open, which the render says by saying nothing. What each state would be worth is rendered beside it, and a quantity this instrument cannot yet take is
+ * rendered grey with the name of what would take it, never as a number it invented.
+ */
+export function openCells(input) {
+    const { store, standing, observed } = input;
+    const rests = new Map();
+    const asked = new Set();
+    for (const line of standing) {
+        for (const name of fieldOf(line, 'restsOn').split('|').filter(Boolean))
+            rests.set(name, (rests.get(name) ?? 0) + 1);
+        for (const need of fieldOf(line, 'needs').split('|').filter(Boolean))
+            asked.add(need);
+    }
+    const by = new Map();
+    for (const line of [...standing, ...observed]) {
+        const at = fieldOf(line, 'scope');
+        by.set(at, (by.get(at) ?? new Set()).add(fieldOf(line, 'by')));
+    }
+    const grey = new Set(input.grey.map((line) => fieldOf(line, 'scope')));
+    const answered = new Set(observed.map((line) => fieldOf(line, 'scope')));
+    const asDecision = standing.filter((line) => fieldOf(line, 'shape') === 'decision' && fieldOf(line, 'value') !== 'withdraw');
+    const held = asDecision.length ? asDecision : [];
+    const out = [];
+    for (const line of held) {
+        const scope = fieldOf(line, 'scope');
+        const value = fieldOf(line, 'value');
+        const freedom = declared(line);
+        const bits = freedom.bits;
+        if (freedom.kind === 'inactive' || (bits !== null && bits < 1))
+            continue;
+        if (answered.has(scope) || (grey.has(scope) && asked.has(scope)))
+            continue;
+        const needs = fieldOf(line, 'needs');
+        out.push({
+            scope,
+            ceiling: value,
+            bits,
+            freedom: freedom.kind,
+            states: freedom.kind === 'finite' && freedom.form === 'alphabet' ? [...new Set(alphabet(value).members)] : [],
+            origins: [...(by.get(scope) ?? new Set())].sort(),
+            rank: rests.get(scope) ?? 0,
+            cone: needs ? bytesDigest(store, new TextEncoder().encode(needs)).replace(/^[^:]*:/, '').slice(0, 8) : '',
+        });
+    }
+    return out.sort((a, b) => b.rank - a.rank || (b.bits ?? 0) - (a.bits ?? 0) || a.scope.localeCompare(b.scope));
+}
+export const openCards = (open) => open.flatMap((cell) => [
+    `OPEN     ${cell.scope} · cone ${cell.cone || 'grey · a demand would name it'} · ceiling ${cell.ceiling}`
+        + ` · origins ${cell.origins.length} ${cell.origins.join(' ')} · ${cell.bits === null ? `unknown freedom (${cell.freedom})` : `${cell.bits.toFixed(1)} bits`}`,
+    ...cell.states.map((state) => `CANDIDATE ${state} · rank ${cell.rank}`),
+]);

package/dist/render/page.d.ts

@@ -0,0 +1,3 @@
+import type { PlaceFold } from '../cli/place.ts';
+export declare const secondName: () => string;
+export declare const nameOf: (fold: Pick<PlaceFold, "standing" | "under">) => string;