@lapxo/bound 0.1.0

package/dist/fold/claims.js

@@ -0,0 +1,107 @@
+import { basename } from "../host/io.js";
+import { contracts, exclusive, point, region } from '@lapxo/obligations/field';
+import { ENVELOPE, PROTOCOL, recordKind, signedBytes, parse } from '@lapxo/topos/wire';
+export { CAPSULE, EXTENSION, LOCK, RECEIPTS } from '@lapxo/topos/wire';
+import { ownRoot } from "../observe/runner.js";
+const decoded = new Map();
+/** Field access uses the Topos wire parser; decoding is shared for this CLI process. */
+function wireFields(line) {
+    const held = decoded.get(line);
+    if (held !== undefined)
+        return held;
+    const got = parse(line);
+    const fields = got.kind === 'fact' ? got.value.fields : {};
+    decoded.set(line, fields);
+    return fields;
+}
+export const fieldOf = (line, name) => wireFields(line)[name] ?? '';
+export const fieldsOf = (line) => ({ ...wireFields(line) });
+export function selfName() { return basename(ownRoot()); }
+export function isWire(line) { return line.startsWith(PROTOCOL); }
+export const wireLinesOf = (text) => (text ?? '').split('\n').filter(isWire);
+export const isConfig = (line) => { const k = recordKind(line); return k.kind === 'fact' && k.value === 'config'; };
+export const sayingOf = (line) => !isConfig(line) ? ((p) => p.kind === 'fact' ? signedBytes(p.value.fields) : line)(parse(line)) : Object.entries(fieldsOf(line)).filter(([k]) => !ENVELOPE.has(k)).sort(([a], [b]) => (a < b ? -1 : 1)).map(([k, v]) => `${k}=${v}`).join(' ');
+/** One key per claim: scope, role and measure; what a line says, its envelope set aside, is one however often it landed. */
+export function claimKey(line) {
+    const f = fieldsOf(line);
+    return `${f['scope'] ?? ''} ${f['role'] ?? ''} ${f['measure'] ?? ''}`;
+}
+function contentOf(fields, at = true) {
+    return Object.keys(fields)
+        .filter((k) => !ENVELOPE.has(k) && k !== 'value' && (at || k !== 'at'))
+        .sort()
+        .map((k) => `${k}=${fields[k]}`)
+        .join(' ');
+}
+function regionsOf(line) {
+    return (fieldsOf(line)['needs'] ?? '').split('|').filter(Boolean).map((need) => region(need));
+}
+function contracted(line, sides, receipts) {
+    const scope = fieldsOf(line)['scope'] ?? '';
+    const mine = exclusive(regionsOf(line), sides.filter((other) => other !== line).map(regionsOf));
+    const touched = receipts.filter((r) => r.scope === scope).flatMap((r) => r.moved.map((coordinate) => point(coordinate)));
+    return contracts(mine, touched);
+}
+function retracts(withdraw, line) {
+    return Object.keys(withdraw)
+        .filter((k) => !ENVELOPE.has(k) && k !== 'value')
+        .every((k) => line[k] === withdraw[k]);
+}
+export function foldClaims(lines, receipts, _placed = false) {
+    const groups = new Map();
+    for (const line of lines.filter(isConfig)) {
+        const key = claimKey(line);
+        const group = groups.get(key) ?? [];
+        if (!group.includes(line))
+            group.push(line);
+        groups.set(key, group);
+    }
+    const standing = [...new Set(lines.filter(line => !isConfig(line)))];
+    const retracted = [];
+    const spent = [];
+    const vacuous = [];
+    const forks = [];
+    for (const [key, group] of groups) {
+        const parsed = group.map((line) => ({ line, fields: fieldsOf(line) }));
+        const withdraws = parsed.filter((p) => p.fields['value'] === 'withdraw');
+        const claims = parsed.filter((p) => p.fields['value'] !== 'withdraw');
+        const stands = new Set(claims.flatMap((p, i) => withdraws.some(w => retracts(w.fields, p.fields)) ? [] : [String(i)]));
+        retracted.push(...claims.filter((_, i) => !stands.has(String(i))).map((p) => p.line));
+        const kept = claims.filter((_, i) => stands.has(String(i)));
+        if (!kept.length) {
+            const lastByContent = new Map();
+            for (const w of withdraws)
+                lastByContent.set(contentOf(w.fields), w.line);
+            const shownWithdraws = [...lastByContent.values()];
+            standing.push(...shownWithdraws);
+            spent.push(...withdraws.map((w) => w.line).filter((line) => !shownWithdraws.includes(line)));
+            continue;
+        }
+        spent.push(...withdraws.map((w) => w.line));
+        const epochOf = (p) => Number(p.fields['epoch']) || 0;
+        const latestOf = new Map();
+        const who = (p) => `${p.fields['by'] ?? ''} ${contentOf(p.fields)}`;
+        for (const p of kept)
+            latestOf.set(who(p), Math.max(latestOf.get(who(p)) ?? 0, epochOf(p)));
+        const revised = kept.filter((p) => epochOf(p) < (latestOf.get(who(p)) ?? 0));
+        spent.push(...revised.map((p) => p.line));
+        // Epoch revisions are host history. Distinct origins remain separate inscriptions.
+        const values = kept.filter(p => !revised.includes(p));
+        const bySigner = new Map();
+        for (const p of values) {
+            const by = p.fields['by'] ?? '';
+            const identity = who(p);
+            const sayings = bySigner.get(identity) ?? new Set();
+            sayings.add(sayingOf(p.line));
+            bySigner.set(identity, sayings);
+            if (sayings.size > 1)
+                throw Error(`REFUSE·document ${key} · ${by} has two live inscriptions without withdrawal`);
+        }
+        const shown = [...new Set(values.map(p => p.line))];
+        const resting = receipts && shown.length > 1 ? shown.filter((line) => !contracted(line, shown, receipts)) : shown;
+        vacuous.push(...shown.filter((line) => !resting.includes(line)));
+        standing.push(...resting);
+    }
+    const accounted = new Set([...standing, ...retracted, ...spent, ...vacuous]);
+    return { standing, superseded: [...new Set([...spent, ...lines.filter((l) => !accounted.has(l))])], retracted, forks, vacuous };
+}

package/dist/fold/closed.d.ts

@@ -0,0 +1,15 @@
+export declare const idleCount: () => number;
+export declare const noteIdle: () => void;
+export declare const actSeconds: () => number;
+export declare const receiptsSeen: () => {
+    readonly count: number;
+    readonly ms: number;
+};
+/** File-fold identity uses public inputs; admission history stays in its separate ledger guard. */
+export declare function fileRegionDigest(root: string, place: string, region: string, algorithm: string, inputs?: readonly string[]): string;
+export declare const instrumentKept: (store: string) => string;
+export declare function instrumentKeep(store: string, id: string): void;
+export declare function receiptPlaces(root: string, store: string): readonly string[];
+export declare function closeReceipts(root: string, store: string, semantic?: ReadonlyMap<string, string>): Promise<readonly string[]>;
+/** One comparison. A place meets its receipt; the root meets when every receipt it names meets. */
+export declare function meets(root: string, store: string, place: string): boolean;

package/dist/fold/closed.js

@@ -0,0 +1,168 @@
+import { dirname, existsSync, join, mkdirSync, relative, resolve, statSync, writeFileSync } from "../host/io.js";
+import { canonical, LOCK, parse, roleAt, roleClaimsOf } from '@lapxo/topos/wire';
+import { RECEIPTS, fieldOf, isWire } from "./claims.js";
+import { bytesDigest as hashBytes, fullDigest as hashFull } from "../host/digest.js";
+import { worldAt } from "./places.js";
+import { ownLockOf } from "./signed.js";
+import { viewsOf } from "./views.js";
+import { storeAt, storeOf } from "../land/ledger.js";
+import { coordinatesUnder, observeFile, observeText } from "../observe/files.js";
+import { carriedFrom } from "./resolved.js";
+import { takenFor } from "../fold/place-inputs.js";
+/** A region is closed when the digest of its bytes is the one its receipt names. Folding a closed region is idle: idleCount is how many were already closed, actSeconds how long this act has run, receiptsSeen how many receipts were read and how long that took. */
+let idle = 0;
+const began = Date.now();
+let seen = { count: 0, ms: 0 };
+export const idleCount = () => idle;
+export const noteIdle = () => {
+    idle += 1;
+};
+export const actSeconds = () => Math.max(0, Math.round((Date.now() - began) / 1000));
+export const receiptsSeen = () => seen;
+const algorithmIn = (text) => text.match(/(?:value=|place:)([a-z0-9]+):[0-9a-f]{64}/)?.[1] ?? '';
+const lockStamp = (root, place) => {
+    const name = place.replace(/\/$/, '');
+    try {
+        const st = statSync(join(root, name, LOCK));
+        return `${st.mtimeMs}:${st.size}`;
+    }
+    catch {
+        return 'none';
+    }
+};
+function filesOf(root, place, region, inputs) {
+    const step = region.replace(/^receipts\//, '').replace(/\/$/, '');
+    const here = join(root, place);
+    const name = place.replace(/\/$/, '');
+    const own = existsSync(join(here, LOCK)) ? [name ? `${name}/${LOCK}` : LOCK] : [];
+    const receipt = `${name ? `${name}/` : ''}${RECEIPTS}`;
+    const claims = roleClaimsOf((observeText(join(here, LOCK)) ?? '').split('\n').filter(isWire).flatMap(line => {
+        const record = parse(line);
+        return record.kind === 'fact' ? [record.value.fields] : [];
+    }));
+    const owned = coordinatesUnder(join(here, step), root).filter(rel => roleAt(relative(here, join(root, rel)), claims) !== 'foreign');
+    // Foreign worlds are not the place's tree. Retain the external files actually handed to its readers.
+    const observed = inputs.filter(line => fieldOf(line, 'measure') === 'observed').flatMap(line => {
+        const coordinate = fieldOf(line, 'scope');
+        const at = resolve(here, coordinate);
+        const local = relative(here, at);
+        if (local === '..' || local.startsWith('../') || resolve(at) === resolve(here))
+            return [];
+        if (step !== '.' && step !== '' && local !== step && !local.startsWith(`${step}/`))
+            return [];
+        return existsSync(at) && statSync(at).isFile() ? [relative(root, at)] : [];
+    });
+    return [...new Set([...owned, ...observed, ...own])].filter(rel => rel !== receipt && !rel.split('/').some(part => part === '.bound' || part === '.cache' || part === '.git'));
+}
+const rooted = new Map();
+function rootLines(root, place) {
+    const name = place.replace(/\/$/, '');
+    if (!name)
+        return [];
+    const key = `${root}\0${name}\0${lockStamp(root, '')}`;
+    const held = rooted.get(key);
+    if (held !== undefined)
+        return held;
+    const standing = (observeText(join(root, LOCK)) ?? '').split('\n').filter(isWire);
+    // Authority validates admission separately; it is not a rendered file input.
+    const lines = standing.filter((line) => fieldOf(line, 'value') !== 'withdraw' && !fieldOf(line, 'scope').startsWith('keys/'));
+    const take = takenFor(lines, `${name}/`, worldAt(root, name) ? { own: ownLockOf(root, name), tree: viewsOf(standing) } : undefined);
+    const got = lines.filter(take).map((line) => `root ${line}`);
+    rooted.set(key, got);
+    return got;
+}
+/** File-fold identity uses public inputs; admission history stays in its separate ledger guard. */
+export function fileRegionDigest(root, place, region, algorithm, inputs = []) {
+    const files = filesOf(root, place, region, inputs);
+    return hashFull([...files.map((rel) => `${relative(join(root, place), join(root, rel))} ${hashBytes(observeFile(join(root, rel)) ?? new Uint8Array(), algorithm)}`), ...rootLines(root, place)], algorithm);
+}
+function namedReceipts(root, store) {
+    const text = observeText(join(root, RECEIPTS));
+    const carried = carriedFrom(store, (text ?? '').split('\n').filter(isWire));
+    const out = new Map();
+    for (const line of carried ?? []) {
+        if (!isWire(line) || fieldOf(line, 'measure') !== 'digest')
+            continue;
+        const place = /^write\/([^/]+)\/receipts\.bound$/.exec(fieldOf(line, 'scope'))?.[1];
+        if (place)
+            out.set(place, fieldOf(line, 'value'));
+    }
+    return out;
+}
+function ownBytes(root) {
+    return (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(line => isWire(line) && fieldOf(line, 'measure') === 'bytes');
+}
+function bytesMeet(root, place) {
+    const shipped = (observeText(join(root, place, RECEIPTS)) ?? '').split('\n').filter(isWire);
+    const inputs = carriedFrom(storeOf(root), shipped) ?? [];
+    const lines = shipped.filter(line => fieldOf(line, 'measure') === 'bytes');
+    const algorithm = algorithmIn(lines.join('\n'));
+    return lines.length > 0 && algorithm !== '' && lines.map((line) => fieldOf(line, 'value')).join('\n') === lines.map((line) => fileRegionDigest(root, place, fieldOf(line, 'scope'), algorithm, inputs)).join('\n');
+}
+const stampAt = (store) => storeAt(store, 'cas', 'instrument');
+export const instrumentKept = (store) => (observeText(stampAt(store)) ?? '').trim();
+export function instrumentKeep(store, id) {
+    mkdirSync(dirname(stampAt(store)), { recursive: true });
+    writeFileSync(stampAt(store), `${id}\n`);
+}
+export function receiptPlaces(root, store) {
+    const children = [...namedReceipts(root, store).keys()];
+    return ownBytes(root).length ? ['', ...children] : children;
+}
+function rewritePlace(root, place) {
+    const at = join(root, place, RECEIPTS);
+    const text = observeText(at) ?? '';
+    const algorithm = algorithmIn(text);
+    if (algorithm === '')
+        return;
+    const kept = text.split('\n').filter((line) => line === '' || !isWire(line) || fieldOf(line, 'measure') !== 'bytes');
+    const regions = kept.filter((line) => isWire(line) && fieldOf(line, 'measure') === 'count' && fieldOf(line, 'scope').startsWith('receipts/'));
+    const bytes = regions.map((line) => {
+        const scope = fieldOf(line, 'scope');
+        const inputs = carriedFrom(storeOf(root), kept.filter(isWire)) ?? [];
+        const now = fileRegionDigest(root, place, scope, algorithm, inputs);
+        return canonical({ scope, role: 'writes', form: 'alphabet', measure: 'bytes', value: now, at: `place:${now}`, by: fieldOf(line, 'by') || 'bound' });
+    });
+    writeFileSync(at, `${[...kept.filter((line) => line !== ''), ...bytes].join('\n')}\n`);
+}
+export async function closeReceipts(root, store, semantic) {
+    if (semantic) {
+        const lines = (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(isWire);
+        return [...semantic].filter(([scope, digest]) => !lines.some(line => fieldOf(line, 'scope') === scope && fieldOf(line, 'measure') === 'bytes' && fieldOf(line, 'value') === digest)).map(([scope]) => scope);
+    }
+    const open = receiptPlaces(root, store).filter((place) => !meets(root, store, `${place}/`));
+    for (const place of open) {
+        rewritePlace(root, place);
+        await new Promise((resolve) => { setImmediate(resolve); });
+    }
+    return open;
+}
+/** One comparison. A place meets its receipt; the root meets when every receipt it names meets. */
+export function meets(root, store, place) {
+    const name = place.replace(/\/$/, '');
+    if (name === '') {
+        const at = Date.now();
+        const named = namedReceipts(root, store);
+        const own = ownBytes(root);
+        const carried = own.length ? carriedFrom(store, (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(isWire)) : undefined;
+        const ownClosed = own.length > 0 && carried !== undefined && carried.length > 0 && bytesMeet(root, '');
+        const closed = (own.length > 0 ? ownClosed : named.size > 0) && [...named].every(([one, expected]) => {
+            const bytes = observeFile(join(root, one, RECEIPTS));
+            const algorithm = expected.split(':')[0];
+            return bytes !== undefined && hashBytes(bytes, algorithm) === expected && meets(root, store, `${one}/`);
+        });
+        seen = { count: named.size + (own.length > 0 ? 1 : 0), ms: Date.now() - at };
+        return closed;
+    }
+    const lines = (observeText(join(root, place, RECEIPTS)) ?? '').split('\n').filter((line) => isWire(line) && fieldOf(line, 'measure') === 'bytes');
+    const lock = existsSync(join(root, name, LOCK));
+    if (lines.length > 0)
+        return bytesMeet(root, place);
+    if (lock)
+        return false;
+    const expected = namedReceipts(root, store).get(name);
+    const file = expected !== undefined ? observeFile(join(root, place, RECEIPTS)) : undefined;
+    const algorithm = file === undefined ? '' : algorithmIn(new TextDecoder().decode(file));
+    const closed = file !== undefined && algorithm !== '' && hashBytes(file, algorithm) === expected;
+    return closed;
+}

package/dist/fold/configures.d.ts

@@ -0,0 +1,4 @@
+/** Every reads line that configures nothing is a ceiling: a bound some reading has to meet. */
+export declare function isCeiling(line: string): boolean;
+/** A demand that names no place asks nothing of the tree: it tells a render what to write, and no take pays it. */
+export declare function asksThePlace(line: string): boolean;

package/dist/fold/configures.js

@@ -0,0 +1,22 @@
+import { isWireClaim, parse } from '@lapxo/topos/wire';
+import { fieldOf, isConfig } from "./claims.js";
+import { isReaderLock } from "./observed.js";
+import { isRoleLock } from "./roles.js";
+import { isSignerLock } from "./signers.js";
+function isEffectLock(line) {
+    const got = parse(line);
+    return got.kind === 'fact' && got.value.fields['measure'] === 'effect';
+}
+/** A lock line the instrument itself consumes — an effect it runs, a reader it loads, a role it walks by, a signer it admits, the wire it reads by. */
+function configures(line) {
+    const got = parse(line);
+    return isEffectLock(line) || isReaderLock(line) || isRoleLock(line) || isSignerLock(line) || (got.kind === 'fact' && isWireClaim(got.value.fields));
+}
+/** Every reads line that configures nothing is a ceiling: a bound some reading has to meet. */
+export function isCeiling(line) {
+    return isConfig(line) && fieldOf(line, 'role') === 'reads' && fieldOf(line, 'value') !== 'withdraw' && !configures(line);
+}
+/** A demand that names no place asks nothing of the tree: it tells a render what to write, and no take pays it. */
+export function asksThePlace(line) {
+    return fieldOf(line, 'role') === 'demands' && fieldOf(line, 'needs') !== '';
+}

package/dist/fold/digests.d.ts

@@ -0,0 +1,29 @@
+export declare const algorithmCost: () => number;
+/**
+ * The signature algorithms this tree admits, and the one it signs with now: each carries its era after its name, the
+ * wire's `era` line names the one that is current, and every other is history, read and never written again. A wire
+ * that names no era signs with the one that carries a digest, which is how the first era was named.
+ */
+export declare function signaturesOf(store: string, told?: readonly string[]): {
+    readonly admitted: readonly string[];
+    readonly era: string;
+};
+export declare function eraOf(standing: readonly string[]): {
+    readonly admitted: readonly string[];
+    readonly era: string;
+};
+export declare const bytesDigest: (store: string, bytes: Uint8Array) => string;
+export declare const fullDigest: (store: string, input: string | readonly string[]) => string;
+export declare function coordinateDigest(store: string, at: string): string | undefined;
+export declare function memoized(store: string, key: string, compute: () => string): string;
+/**
+ * The digest of the instrument itself: the entry module and everything it imports, by their bytes, and the source of
+ * every region its lock says it depends on, followed as far as those regions depend — code it runs as much as its own.
+ * A region its own lock names a release for, laid where it needs it, is that release by digest: what it runs, never a
+ * sibling rebuilt beside it.
+ * A fold is a function of its points and the instrument is one of them, so a fold kept by another bound is another
+ * origin's fold — readable as history, never as this instrument's own state.
+ */
+export declare function instrumentOf(store: string, entry: string, standing?: readonly string[], root?: string, releases?: readonly string[]): string;
+export declare function instrumentDigest(store: string, entry: string, standing?: readonly string[], root?: string, releases?: readonly string[]): string;
+export declare function instrumentCoordinates(store: string, entry: string, standing?: readonly string[], root?: string, releases?: readonly string[]): ReadonlyMap<string, string>;

package/dist/fold/digests.js

@@ -0,0 +1,211 @@
+import { appendFileSync, dirname, join, mkdirSync, readdirSync, relative, resolve } from "../host/io.js";
+import { bytesDigest as bytesWith, fullDigest as fullWith } from "../host/digest.js";
+import { coordinatesUnder, observeFile, observeText, stampOf } from "../observe/files.js";
+import { releaseOf, signedLockLines } from "./keys.js";
+import { EXTENSION, fieldOf, foldClaims, selfName } from "./claims.js";
+import { wireLine } from "./wire.js";
+import { publicLock, LOCK } from '@lapxo/topos/wire';
+import { builtinModules, createRequire } from 'node:module';
+const held = new Map();
+let algorithmMs = 0;
+export const algorithmCost = () => algorithmMs;
+/**
+ * The algorithm this tree digests with: the one its wire names, read from the lock and told to the port, which keeps
+ * none of its own. A lock that names no algorithm is a tree nothing can be digested in, and it is refused as one.
+ */
+function namedAlgorithm(store) {
+    const needle = 'scope=wire/digest-algorithms';
+    const older = 'scope=audit/wire/digest-algorithms';
+    let best = -1;
+    let name = '';
+    const release = releaseOf(store);
+    if (release) {
+        const said = release.find((line) => (fieldOf(line, 'scope') === 'wire/digest-algorithms' || fieldOf(line, 'scope') === 'audit/wire/digest-algorithms') && fieldOf(line, 'value') !== 'withdraw');
+        return said === undefined ? undefined : fieldOf(said, 'value').split('|').filter(Boolean)[0]?.split(':')[0];
+    }
+    if (!existsLedger(store)) {
+        const text = observeText(join(dirname(store), LOCK));
+        const lines = text?.split('\n').filter(line => line.startsWith('bound-lock/'));
+        const published = lines === undefined ? undefined : publicLock(lines);
+        const contract = published === undefined ? undefined : wireLine(published, 'digest-algorithms');
+        return contract === undefined ? undefined : fieldOf(contract, 'value').split('|')[0]?.split(':')[0];
+    }
+    for (const entry of readdirSync(join(store, 'ledger'), { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(EXTENSION))
+            continue;
+        const text = observeText(join(store, 'ledger', entry.name)) ?? '';
+        let from = 0;
+        while (from < text.length) {
+            const at = (() => {
+                const next = text.indexOf(needle, from);
+                const was = text.indexOf(older, from);
+                if (next < 0)
+                    return was;
+                if (was < 0)
+                    return next;
+                return Math.min(next, was);
+            })();
+            if (at < 0)
+                break;
+            const start = text.lastIndexOf('\n', at) + 1;
+            const end = text.indexOf('\n', at);
+            const line = text.slice(start, end < 0 ? undefined : end);
+            from = end < 0 ? text.length : end + 1;
+            if (!line.includes(' sig='))
+                continue;
+            const epoch = Number(fieldOf(line, 'epoch')) || 0;
+            if (epoch < best)
+                continue;
+            best = epoch;
+            const value = fieldOf(line, 'value');
+            name = value === 'withdraw' ? '' : (value.split('|').filter(Boolean)[0]?.split(':')[0] ?? '');
+        }
+    }
+    return name || undefined;
+}
+function existsLedger(store) {
+    try {
+        return readdirSync(join(store, 'ledger')).length > 0;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function algorithmOf(store) {
+    const mine = held.get(store);
+    if (mine !== undefined)
+        return mine;
+    const first = namedAlgorithm(store);
+    if (first === undefined)
+        throw new Error(`${selfName()}: REFUSE·runtime the lock names no \`wire/digest-algorithms\`: nothing can be digested here`);
+    held.set(store, first);
+    return first;
+}
+/**
+ * The signature algorithms this tree admits, and the one it signs with now: each carries its era after its name, the
+ * wire's `era` line names the one that is current, and every other is history, read and never written again. A wire
+ * that names no era signs with the one that carries a digest, which is how the first era was named.
+ */
+export function signaturesOf(store, told = []) {
+    return eraOf(foldClaims([...signedLockLines(store, told), ...told]).standing);
+}
+export function eraOf(standing) {
+    const said = wireLine(standing, 'signature-algorithms');
+    const admitted = (said === undefined ? [] : fieldOf(said, 'value').split('|')).filter(Boolean);
+    const current = wireLine(standing, 'era');
+    const era = (current === undefined ? undefined : admitted.find((one) => one.endsWith(`:${fieldOf(current, 'value')}`))) ?? admitted.find((one) => one.includes(':'));
+    if (era === undefined)
+        throw new Error(`${selfName()}: REFUSE·runtime the lock names no signature algorithm by digest: nothing can be signed here`);
+    return { admitted, era };
+}
+export const bytesDigest = (store, bytes) => bytesWith(bytes, algorithmOf(store));
+export const fullDigest = (store, input) => fullWith(input, algorithmOf(store));
+const stamped = new Map();
+const memoOf = (store) => stamped.get(store) ?? stamped.set(store, new Map((observeText(join(store, 'cas', `stamps${EXTENSION}`)) ?? '')
+    .split('\n').flatMap((row) => (row.indexOf('\t') > 0 ? [[row.slice(0, row.indexOf('\t')), row.slice(row.indexOf('\t') + 1)]] : [])))).get(store);
+export function coordinateDigest(store, at) {
+    const stamp = stampOf(at);
+    if (stamp?.kind !== 'file')
+        return stamp === undefined ? undefined : bytesDigest(store, observeFile(at) ?? new Uint8Array());
+    const key = `${at} ${stamp.stamp}`;
+    const memo = memoOf(store);
+    const held = memo.get(key);
+    if (held !== undefined)
+        return held;
+    const digest = bytesDigest(store, observeFile(at) ?? new Uint8Array());
+    memo.set(key, digest);
+    mkdirSync(join(store, 'cas'), { recursive: true });
+    appendFileSync(join(store, 'cas', `stamps${EXTENSION}`), `${key}\t${digest}\n`);
+    return digest;
+}
+export function memoized(store, key, compute) {
+    const memo = memoOf(store);
+    const held = memo.get(key);
+    if (held !== undefined)
+        return held;
+    const value = compute();
+    memo.set(key, value);
+    mkdirSync(join(store, 'cas'), { recursive: true });
+    appendFileSync(join(store, 'cas', `stamps${EXTENSION}`), `${key}\t${value}\n`);
+    return value;
+}
+const imported = new Map();
+const importsOf = (store, at, digest) => {
+    const key = `imports ${fullDigest(store, importsOf.toString())} ${digest}`;
+    const memo = memoOf(store);
+    const held = imported.get(digest) ?? memo.get(key)?.split('|').filter(Boolean);
+    if (held !== undefined)
+        return held;
+    const found = [...new TextDecoder().decode(observeFile(at) ?? new Uint8Array()).matchAll(/(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)['"]([^'"]*)['"]/g)].map((m) => m[1] ?? '');
+    imported.set(digest, found);
+    memo.set(key, found.join('|'));
+    appendFileSync(join(store, 'cas', `stamps${EXTENSION}`), `${key}\t${found.join('|')}\n`);
+    return found;
+};
+/**
+ * The digest of the instrument itself: the entry module and everything it imports, by their bytes, and the source of
+ * every region its lock says it depends on, followed as far as those regions depend — code it runs as much as its own.
+ * A region its own lock names a release for, laid where it needs it, is that release by digest: what it runs, never a
+ * sibling rebuilt beside it.
+ * A fold is a function of its points and the instrument is one of them, so a fold kept by another bound is another
+ * origin's fold — readable as history, never as this instrument's own state.
+ */
+export function instrumentOf(store, entry, standing = [], root = dirname(resolve(entry)), releases = []) {
+    return instrumentDigest(store, entry, standing, root, releases).replace(/^[^:]*:/, '').slice(0, 12);
+}
+export function instrumentDigest(store, entry, standing = [], root = dirname(resolve(entry)), releases = []) {
+    const seen = instrumentCoordinates(store, entry, standing, root, releases);
+    return bytesDigest(store, new TextEncoder().encode([...seen.values()].sort().join('\n')));
+}
+export function instrumentCoordinates(store, entry, standing = [], root = dirname(resolve(entry)), releases = []) {
+    const seen = new Map();
+    const walk = (at) => {
+        if (seen.has(at))
+            return;
+        const digest = coordinateDigest(store, at);
+        if (digest === undefined)
+            return;
+        seen.set(at, digest);
+        for (const one of importsOf(store, at, digest)) {
+            if (one.startsWith('node:') || builtinModules.includes(one))
+                continue;
+            if (one.startsWith('.'))
+                walk(resolve(dirname(at), one));
+            else
+                walk(createRequire(at).resolve(one));
+        }
+    };
+    walk(resolve(entry));
+    const deps = standing.filter((line) => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'value') !== 'withdraw')
+        .map((line) => ({ region: fieldOf(line, 'scope').slice('dep/'.length).replace(/\*+$/, ''), on: fieldOf(line, 'value').split('|').filter((one) => one && one !== 'none') }));
+    const released = new Map(releases.filter((line) => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'role') === 'reads' && fieldOf(line, 'needs') && fieldOf(line, 'value') !== 'withdraw')
+        .map((line) => [fieldOf(line, 'scope').slice('dep/'.length), fieldOf(line, 'value')]));
+    const reached = new Set();
+    const follow = (region) => {
+        for (const name of deps.find((dep) => dep.region === region)?.on ?? []) {
+            if (released.has(name)) {
+                seen.set(`release:${name}`, released.get(name));
+                continue;
+            }
+            for (const next of deps.filter((dep) => dep.region.startsWith(`${name}/`) && !reached.has(dep.region))) {
+                reached.add(next.region);
+                for (const coordinate of coordinatesUnder(resolve(root, next.region), root))
+                    walk(resolve(root, coordinate));
+                follow(next.region);
+            }
+        }
+    };
+    follow(deps.find((dep) => relative(root, resolve(entry)).startsWith(dep.region))?.region);
+    const home = relative(root, resolve(entry)).split('/')[0] ?? '';
+    for (const line of standing.filter((one) => fieldOf(one, 'scope').startsWith(`${home}/process/`) && fieldOf(one, 'kind') === 'process' && fieldOf(one, 'value') !== 'withdraw')) {
+        for (const need of fieldOf(line, 'needs').split('|').filter(Boolean))
+            walk(resolve(root, need));
+    }
+    for (const line of releases.filter(one => fieldOf(one, 'scope').startsWith('process/') && fieldOf(one, 'kind') === 'process' && fieldOf(one, 'value') !== 'withdraw')) {
+        for (const need of fieldOf(line, 'needs').split('|').filter(Boolean))
+            walk(resolve(root, need));
+    }
+    return seen;
+}

package/dist/fold/evidence.d.ts

@@ -0,0 +1,32 @@
+import type { VerdictObservation } from '@lapxo/topos/authority';
+/** The instrument maps an abstract relation to its declared snapshot vocabulary. Topos has no actor or origin policy. */
+export interface SnapshotInput {
+    readonly declared: boolean;
+    readonly expected: {
+        readonly set?: string;
+        readonly standing: string;
+        readonly epoch: number;
+    };
+    readonly statement?: {
+        readonly admitted: boolean;
+        readonly set: string;
+        readonly standing: string;
+        readonly epoch: number;
+    };
+    readonly priorDisagreement?: boolean;
+    readonly comparison?: {
+        readonly admitted: boolean;
+        readonly set: string;
+        readonly verdict: 'agrees' | 'forks';
+        readonly epoch: number;
+    };
+}
+export declare function snapshotVerdict(input: SnapshotInput): {
+    verdict: "none" | "grey" | "agrees" | "forks" | "stale";
+    external: boolean;
+    epoch: number;
+};
+/** This selector belongs to the instrument, not the SDK's abstract evidence contract. */
+export declare function attestationObservations(configuration: readonly Readonly<Record<string, string>>[], result: {
+    readonly verdict: string;
+}): readonly VerdictObservation[];

package/dist/fold/evidence.js

@@ -0,0 +1,22 @@
+import { compareEvidence } from '@lapxo/topos/authority';
+export function snapshotVerdict(input) {
+    const statement = input.declared ? input.statement : undefined;
+    const comparison = input.comparison;
+    const result = compareEvidence({
+        expected: { reference: input.expected.set, value: input.expected.standing },
+        ...(statement ? { statement: { admitted: statement.admitted, reference: statement.set, value: statement.standing } } : {}),
+        ...(comparison ? { comparison: { admitted: comparison.admitted, reference: comparison.set, equal: comparison.verdict === 'agrees' } } : {}),
+    });
+    const words = { absent: 'none', unadmitted: 'grey', unresolved: 'stale', stale: 'stale', equal: 'agrees', different: 'forks' };
+    return { verdict: words[result.relation], external: result.relation !== 'absent' && (input.priorDisagreement === true || result.relation === 'different'),
+        epoch: result.source === 'comparison' ? comparison.epoch : statement?.epoch ?? 0 };
+}
+/** This selector belongs to the instrument, not the SDK's abstract evidence contract. */
+export function attestationObservations(configuration, result) {
+    const values = [...new Set(configuration.filter(f => ['wire/attestation-result', 'audit/wire/attestation-result'].includes(f.scope ?? '') && f.value !== 'withdraw').map(f => f.value))];
+    if (!values.length)
+        return [];
+    if (values.length !== 1 || !values[0] || /[|=\s\\*]/.test(values[0]) || values[0].startsWith('/') || values[0].split('/').some(s => !s || s === '.' || s === '..'))
+        throw Error('REFUSE·authority conflicting or invalid attestation result coordinate');
+    return [{ coordinate: values[0], value: result.verdict }];
+}

package/dist/fold/fold-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fold/fold-worker.js

@@ -0,0 +1,13 @@
+import { parentPort, workerData } from "../host/io.js";
+import { foldPlace, standingOf } from "../cli/place.js";
+import { renderedOf, unrendered, viewOf } from "../render/view.js";
+const data = workerData;
+const standing = standingOf(data.root, data.place || undefined, data.told);
+const fold = foldPlace(data.root, data.entry, data.place || undefined, false, { standing, observed: data.observed });
+parentPort?.postMessage({
+    place: data.place,
+    texts: data.views.map((view) => {
+        const missing = unrendered(fold, view);
+        return { shape: view.shape, missing, text: missing.length ? '' : viewOf(fold, view), said: missing.length ? [] : renderedOf(fold, view) };
+    }),
+});