@lapxo/bound 0.1.4 → 0.1.5

package/dist/cli/accept.js

@@ -11,7 +11,7 @@ import { fieldOf, isConfig, foldClaims, sayingOf, selfName } from "../fold/claim
 import { isReaderLock } from "../fold/observed.js";
 import { authorityFor, publicKeyOf, rootSigner, writerFor } from "../fold/signers.js";
 import { lockLines, lockStanding } from "../fold/keys.js";
-import { keepVerdict, keptVerdict, land, landBlob, storeOf } from "../land/ledger.js";
+import { keepVerdict, keptVerdict, land, landBlob, ledgerLines, storeOf } from "../land/ledger.js";
 import { signConsentLot, verifiesOwnerLine } from "../land/sign.js";
 import { signerFor } from "../host/signing.js";
 import { appliedIn, ownLockOf } from "../fold/signed.js";
@@ -19,7 +19,7 @@ import { wordOf } from "../fold/wire.js";
 import { hasVouchedTree, landCoordinates, locationsOf, vouchedCoordinates } from "../land/vouched.js";
 import { entriesIn, observeFile } from "../observe/files.js";
 import { coneOf, standingOf } from "./place.js";
-import { ownLock, ownRoot, ownStore } from "../observe/runner.js";
+import { ownLock, ownRoot } from "../observe/runner.js";
 import { widenedWithoutWitness } from "../judge/widening.js";
 import { retractedTogether, withdrawal } from "../land/withdraw.js";
 import { isCeiling } from "../fold/configures.js";
@@ -36,7 +36,7 @@ import { lateFacts } from "../judge/late.js";
 import { paidOf } from "../fold/paid.js";
 import { aliasPinned } from "../land/alias.js";
 import { coordinatesWithdrawn } from "../land/leaving.js";
-import { ownerOf, epochOf, forksItself, forksJoinedBy, renderInto, sideOf, signedDemands, signedOwnerLines } from "./owner.js";
+import { ownerOf, epochOf, localActLines, forksItself, forksJoinedBy, renderInto, sideOf, signedDemands, signedOwnerLines } from "./owner.js";
 import { claimLinesIn, entryOf, namedPlaces, placesOfFile, positionalsOf, valueOf } from "./args.js";
 import { FLAGS } from "./names.js";
 import { judgeDemand, landTake } from "./takes.js";
@@ -53,7 +53,15 @@ function admissionEvidence(root, signed, standing) {
         if (coordinates.refused.length)
             throw Error(`REFUSE·withdraw a file is still read: ${coordinates.refused.map(one => `${one.path} by ${one.by}`).join(' · ')}`);
         const view = `${wordOf(standing, 'families', 'view')}/`;
-        const judged = signed.filter(one => isConfig(one) && fieldOf(one, 'role') === 'demands' && fieldOf(one, 'value') !== 'withdraw' && !fieldOf(one, 'scope').startsWith(view)).map(one => judgeDemand(root, one));
+        const judged = signed.filter(one => isConfig(one) && fieldOf(one, 'role') === 'demands' && fieldOf(one, 'value') !== 'withdraw' && !fieldOf(one, 'scope').startsWith(view)).map(one => {
+            const scope = fieldOf(one, 'scope');
+            const alreadyDemanded = standing.some(held => isConfig(held) && fieldOf(held, 'role') === 'demands'
+                && fieldOf(held, 'value') !== 'withdraw' && fieldOf(held, 'scope') === scope
+                && fieldOf(held, 'form') === fieldOf(one, 'form') && fieldOf(held, 'measure') === fieldOf(one, 'measure'));
+            // Declaring an obligation is not a claim to have discharged it.
+            return alreadyDemanded ? judgeDemand(root, one)
+                : { kind: 'owed', scope, why: 'new demand declared; no conformance reading is claimed' };
+        });
         const refused = judged.filter(one => one.kind === 'refused' || (one.kind === 'judged' && one.verdict.kind === 'refuse'));
         if (refused.length)
             throw Error(`REFUSE·takes ${refused.map(one => `${one.scope}: ${one.kind === 'judged' ? one.verdict.why : one.kind === 'refused' ? one.why : ''}`).join(' · ')}`);
@@ -126,7 +134,7 @@ export async function signedBatch(root, args, files) {
         process.stderr.write(`${selfName()}: REFUSE·place nothing landed · ${stray.join(', ')} is no place of the tree, and no line of the root founds it: --place names the own lock a line lands in\n`);
         return { kind: 'exit', code: 2 };
     }
-    const epoch = epochOf([...lockLines(store), ...destinations.flatMap((place) => appliedIn(root, place))]) + 1;
+    const epoch = epochOf(localActLines(root, destinations)) + 1;
     const stale = proposed.filter((line) => fieldOf(line, 'sig')).flatMap((line) => ((by, key) => (key === undefined || !verifiesOwnerLine(line, key, signaturesOf(store).admitted)
         ? [`${fieldOf(line, 'scope')} · the signature does not hold for ${by || '∅'}`]
         : []))(fieldOf(line, 'by'), publicKeyOf(root, fieldOf(line, 'by'))));
@@ -139,9 +147,13 @@ export async function signedBatch(root, args, files) {
     const [named, places] = [namedPlaces(args), placesIn(root)];
     const inLock = new Set(lockLines(store).map(sayingOf));
     const inPlace = new Map(places.map((place) => [place, new Set(appliedIn(root, place).map(sayingOf))]));
+    const deliveryAuthority = authorityFor(lockLines(store), rootSigner(root), signaturesOf(store).admitted);
+    const delivered = (line) => Boolean(fieldOf(line, 'sig'))
+        && deliveryAuthority.of(line).kind === 'admitted'
+        && ledgerLines(store, fieldOf(line, 'by')).includes(line);
     const held = (line, at = named.length ? named : byFile.flatMap(([heads, lines]) => (lines.includes(line) ? heads : []))) => at.length
         ? at.every((place) => inPlace.get(place)?.has(sayingOf(line)))
-        : inLock.has(sayingOf(line)) || places.some((place) => inPlace.get(place)?.has(sayingOf(line)));
+        : delivered(line) || inLock.has(sayingOf(line)) || places.some((place) => inPlace.get(place)?.has(sayingOf(line)));
     if (proposed.every((line) => held(line))) {
         if (proposed.some(line => !isConfig(line))) {
             try {
@@ -335,7 +347,7 @@ async function acceptNow(root, batch, started, owned, asked = started, descent =
     for (const name of openedBy(descent, told.standing, signed))
         process.stderr.write(`OPEN     ${name}\n`);
     if (owned.own.size)
-        layReleases(store, ownRoot(), ownLock(), ownStore());
+        layReleases(store, root, told.standing, store);
     const landed = took('land', () => [...new Set(signed.map((line) => fieldOf(line, 'by')))].map((by) => land(store, by, signed.filter((line) => fieldOf(line, 'by') === by))));
     for (const [place, lines] of owned.own)
         landOwned(root, place, lines);
@@ -392,7 +404,7 @@ async function acceptNow(root, batch, started, owned, asked = started, descent =
     if (folder !== undefined)
         land(store, folder, [beat(perLine, 'line'), beat(1, fold.kept ? 'kept' : 'folded'), beat(Date.now() - started, 'total')]);
     process.stdout.write(`FACT     signed ${signed.length + own} · landed ${landed.length ? landed.map((one) => `${one.appended} in ${one.at}`).join(' · ') : '0'}${[...owned.own].map(([place, lines]) => ` · ${lines.length} in ${place}/${LOCK}`).join('')} · epoch ${epoch}\n`
-        + `TARGET   ${rendered.standing} claims · ${rendered.forks.length} forks · ${rendered.vacuous.length} vacuous · ${rendered.grey.length} grey · ${rendered.refused.length} refused · ${Date.now() - started} ms\n`
+        + `TARGET   ${rendered.standing} claims · ${rendered.forks.length} forks · ${rendered.vacuous.length} vacuous · ${rendered.grey.length} grey · ${rendered.refused.length} refused · readings · no encounters computed · ${Date.now() - started} ms\n`
         + `SPENT    ${spent.join(' ms · ')} ms · ${signed.length} lines\n`);
     if (withdrawn) {
         process.stdout.write(`WITHDRAW ${withdrawn.taken.length} taken · ${withdrawn.exact.length} exact on distributive scales · ${withdrawn.open.length} on open scales, not computed\n`);
@@ -444,7 +456,7 @@ function repaid(root, proposed, started) {
     }
     const rendered = renderInto(root, store);
     process.stdout.write(`RENDER 0\n`);
-    process.stdout.write(`TARGET   ${rendered.standing} claims · ${rendered.forks.length} forks · ${rendered.vacuous.length} vacuous · ${rendered.grey.length} grey · ${rendered.refused.length} refused · ${Date.now() - started} ms\n`);
+    process.stdout.write(`TARGET   ${rendered.standing} claims · ${rendered.forks.length} forks · ${rendered.vacuous.length} vacuous · ${rendered.grey.length} grey · ${rendered.refused.length} refused · readings · no encounters computed · ${Date.now() - started} ms\n`);
     return 0;
 }
 function packTake(one) {

package/dist/cli/owner.d.ts

@@ -14,6 +14,8 @@ export declare function historyOf(root: string, store: string, demands: readonly
 };
 export declare function signedDemands(store: string, root?: string): string[];
 export declare function forkedScopes(store: string): Set<string>;
+/** Import receipts are local acts; foreign evidence and sender epochs never enter this input. */
+export declare function localActLines(root: string, placed?: readonly string[]): readonly string[];
 export declare function epochOf(lines: readonly string[]): number;
 export declare function targetFile(root: string): string;
 export declare function renderInto(root: string, store: string): {

package/dist/cli/owner.js

@@ -1,8 +1,10 @@
+import { fileURLToPath } from 'node:url';
+import { ingressReceipts } from "../host/ports/ingress.js";
 import { readOnly } from "../host/read-only.js";
 import { keyFor, lockLines, releaseOf, signedLockLines } from "../fold/keys.js";
 import { existsSync, renameSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { bytesDigest, fullDigest, memoized, signaturesOf } from "../fold/digests.js";
+import { bytesDigest, fullDigest, memoized, signaturesOf, instrumentDigest } from "../fold/digests.js";
 import { claimKey, isConfig, fieldOf, foldClaims, LOCK, selfName } from "../fold/claims.js";
 import { asksThePlace } from "../fold/configures.js";
 import { receiptsIn } from "../fold/receipts.js";
@@ -10,6 +12,7 @@ import { authorityFor, releaseSigner, rootSigner } from "../fold/signers.js";
 import { storeRoot } from "../host/ports/store.js";
 import { blobAt, landBlob, ledgerLines, storeOf } from "../land/ledger.js";
 import { observeText } from "../observe/files.js";
+import { appliedIn } from "../fold/signed.js";
 import { everLanded, inside, locationsOf } from "../land/vouched.js";
 import { renderTarget } from "../render/target.js";
 export const ownerOf = (store, told = []) => keyFor(store, 'authorize', told);
@@ -47,6 +50,18 @@ export function forkedScopes(store) {
     const lines = signedOwnerLines(store);
     return new Set(foldClaims(lines, forkReceipts(store, lines)).forks.flatMap((f) => f.lines.map((line) => fieldOf(line, 'scope'))));
 }
+/** Import receipts are local acts; foreign evidence and sender epochs never enter this input. */
+export function localActLines(root, placed = []) {
+    const store = storeOf(root), local = lockLines(store), receipts = ingressReceipts(store);
+    if (receipts.length) {
+        const authority = authorityFor(local, rootSigner(root), signaturesOf(store).admitted);
+        for (const receipt of receipts) {
+            if (fieldOf(receipt, 'scope') !== 'receipts' || fieldOf(receipt, 'role') !== 'writes' || fieldOf(receipt, 'form') !== 'alphabet' || fieldOf(receipt, 'measure') !== 'digest' || authority.of(receipt).kind !== 'admitted')
+                throw Error('REFUSE·ingress local import receipt is not admitted');
+        }
+    }
+    return [...local, ...receipts, ...placed.flatMap(place => appliedIn(root, place))];
+}
 export function epochOf(lines) {
     return lines.reduce((top, line) => Math.max(top, Number(fieldOf(line, 'epoch')) || 0), 0);
 }
@@ -92,7 +107,7 @@ export function renderedLock(root, store, told = []) {
     }
     const anchor = [join(storeRoot(root), `${selfName()}.keys`), join(storeOf(root), `${selfName()}.keys`)].map((at) => observeText(at) ?? '').join('\n');
     const judged = ledgerLines(store, 'judge');
-    const key = `lock ${fullDigest(store, [new Date().toISOString().slice(0, 10), anchor, `${judged.length} ${judged.at(-1) ?? ''}`, ...owned])}`;
+    const key = `lock ${fullDigest(store, [instrumentDigest(store, fileURLToPath(import.meta.url), [], root), new Date().toISOString().slice(0, 10), anchor, `${judged.length} ${judged.at(-1) ?? ''}`, ...owned])}`;
     const held = memoized(store, key, () => {
         const bytes = new TextEncoder().encode(JSON.stringify(render()));
         const digest = bytesDigest(store, bytes);

package/dist/cli/pass.js

@@ -6,9 +6,9 @@ import { foldPlace, standingOf } from "./place.js";
 import { fieldOf, selfName } from "../fold/claims.js";
 import { observedClaims } from "../fold/observed.js";
 import { layReleases, resolvedOf } from "../host/release.js";
-import { ownLock, ownRoot, ownStore, processOf } from "../observe/runner.js";
+import { ownLock, ownRoot, processOf } from "../observe/runner.js";
 import { landLaid } from "../fold/laid.js";
-import { actSeconds, idleCount, instrumentKeep, instrumentKept, meets, noteIdle, receiptPlaces, receiptsSeen } from "../fold/closed.js";
+import { actSeconds, closeReceipts, idleCount, instrumentKeep, instrumentKept, meets, noteIdle, receiptPlaces, receiptsSeen } from "../fold/closed.js";
 import { algorithmCost, instrumentOf, instrumentDigest } from "../fold/digests.js";
 import { writerFor } from "../fold/signers.js";
 import { defaulted, placesOf, viewsOf } from "../fold/views.js";
@@ -24,6 +24,7 @@ import { releasePolicyLines } from "../fold/release-policy.js";
 import { carriedFrom } from "../fold/resolved.js";
 import { wireLine } from "../fold/wire.js";
 import { isWire, RECEIPTS } from "../fold/claims.js";
+import { withoutEffects } from "../host/read-only.js";
 /**
  * The pass of a place, in one process: the releases its instrument names are laid out first, its readers observe
  * once, each place a view writes in is folded once, the places before the root whose door reads them, and every coordinate a
@@ -74,7 +75,7 @@ async function checked(root, entry, under) {
 export async function pass(root, entry, under, check) {
     if (check) {
         // Verification reads existing evidence; it grants no admission authority.
-        return emptyLedger(storeOf(root)) ? checked(root, entry, under) : underTheLock(storeOf(root), 'check', () => checked(root, entry, under));
+        return withoutEffects(() => emptyLedger(storeOf(root)) ? checked(root, entry, under) : underTheLock(storeOf(root), 'check', () => checked(root, entry, under)));
     }
     if (!under && emptyLedger(storeOf(root))) {
         sayStranger(root);
@@ -85,8 +86,11 @@ export async function pass(root, entry, under, check) {
         const swept = await sweep(root, entry, under, check, []);
         for (const coordinate of check ? swept.written : [])
             process.stdout.write(`DIFFERS  ${coordinate}\n`);
+        // Byte seals describe the completed render pass, not its intermediate outputs.
+        if (!swept.written.length)
+            await closeReceipts(root, storeOf(root));
         const closed = meets(root, storeOf(root), under ?? '') && !swept.written.length;
-        const fold = foldPlace(root, entry, under, false, { standing: swept.standingAt.get(under ?? '') ?? standingOf(root, under), observed: swept.observed.length ? swept.observed : observedClaims(root, storeOf(root), { wait: false }), free: true });
+        const fold = foldPlace(root, entry, under, false, { standing: swept.standingAt.get(under ?? '') ?? standingOf(root, under), observed: swept.settled ? [] : swept.observed.length ? swept.observed : observedClaims(root, storeOf(root), { wait: false }), free: !swept.settled });
         for (const line of releasePolicyLines(fold.release))
             process.stdout.write(`${line}\n`);
         if (closed) {
@@ -140,14 +144,15 @@ async function sweep(root, entry, under, check, told, journal, given, keep, reac
             process.stderr.write(`CLOSED   ${under} · lock ${lock} ms · hash ${hash} ms\n`);
         const seconds = actSeconds();
         process.stderr.write(`COST     act ${seconds} s\n`);
-        return { same: 0, written: [], places: under === undefined ? read.count : 1, observed: [], standingAt: new Map(), folds: new Map(), said: [] };
+        return { same: 0, written: [], places: under === undefined ? read.count : 1, observed: [], standingAt: new Map(), folds: new Map(), said: [], settled: true };
     }
-    layReleases(store, ownRoot(), ownLock(), ownStore());
+    const lock = standingOf(root, undefined, told);
+    // A place asks for its own mounts; the instrument catalog is not a consumer dependency.
+    layReleases(store, root, lock.standing, store);
     const descent = reach ?? (under ? [under.replace(/\/$/, '')] : undefined);
     const limited = descent !== undefined;
     const observed = given ?? observedClaims(root, store, { wait: true, ...(descent !== undefined ? { reach: descent } : {}) });
-    const lock = standingOf(root, undefined, told);
-    landLaid(store, ownRoot(), ownLock(), writerFor(lock.standing, 'fold'));
+    landLaid(store, root, lock.standing, writerFor(lock.standing, 'fold'));
     const shaped = (standing) => [...viewsOf(standing).values()].flatMap((view) => ('regions' in view && view.shape ? [view] : []));
     const views = shaped(lock.standing);
     const tree = viewsOf(lock.lock);
@@ -264,8 +269,8 @@ async function sweep(root, entry, under, check, told, journal, given, keep, reac
     }
     const said = [...answered.values()].flat();
     if (!check && journal === undefined)
-        landSaid(store, writerFor(lock.standing, 'fold'), [...resolvedOf(store, ownRoot(), ownLock(), ownStore()), ...said]);
-    return { same, written, places: places.length + (under ? 0 : 1), observed, standingAt, folds, said: journal === undefined ? [] : said };
+        landSaid(store, writerFor(lock.standing, 'fold'), [...resolvedOf(store, root, lock.standing, store), ...said]);
+    return { same, written, places: places.length + (under ? 0 : 1), observed, standingAt, folds, said: journal === undefined ? [] : said, settled: false };
 }
 function drawParallel(jobs) {
     const out = new Map();

package/dist/cli/place.js

@@ -7,7 +7,7 @@ import { basename, join } from 'node:path';
 import { observeText } from "../observe/files.js";
 import { placesOf, viewsOf } from "../fold/views.js";
 import { prerender, viewOf } from "../render/view.js";
-import { meets } from "../fold/closed.js";
+import { meets, instrumentKept } from "../fold/closed.js";
 import { foldPoints, keepFold, keptPlace } from "../fold/kept.js";
 import { openCells } from "../render/open.js";
 import { boundOf, packRegions, regionsNamed, regionsOf, unlikeReplay } from "../fold/region.js";
@@ -165,6 +165,13 @@ function inheritedOf(root, standing) {
 export function coneOf(root, entry, ceilings, descent) {
     const store = storeOf(root);
     const { standing, rendered } = standingOf(root);
+    // Admission consumes the verified completed fold; it does not ask providers again.
+    // Receipt bytes, reader history and instrument identity must all still agree.
+    if (meets(root, store, '') && instrumentKept(store) === instrumentOf(store, entry, standing, root, ownLock())) {
+        const held = keptPlace(store);
+        if (held !== undefined)
+            return { standing, observed: held.observed, own: held.own, kept: true };
+    }
     const named = regionsNamed(standing);
     const reach = descent !== undefined && descent.length ? [...descent] : [...new Set(ceilings.map((line) => boundOf(named, line).region))];
     const read = observedClaims(root, store, { wait: false, ...(reach.includes('') ? {} : { reach }) });

package/dist/cli/verb.js

@@ -10,6 +10,7 @@ import { objectFold } from "../fold/object.js";
 import { OBJECT_VIEW } from '@lapxo/topos/wire';
 import { toposStanding } from '@lapxo/topos/standing';
 import { wireAt, parse as parseWire } from '@lapxo/topos/wire';
+import { lockStanding } from "../fold/keys.js";
 import { ownLock } from "../observe/runner.js";
 import { signedOwnerLines } from "./owner.js";
 import { existsSync, lstatSync, mkdirSync, writeFileSync } from 'node:fs';
@@ -42,6 +43,9 @@ import { ownerOf, renderInto, signedDemands, targetFile } from "./owner.js";
 import { claimLinesIn, entryOf, namedPlaces, positionalsOf, valueOf } from "./args.js";
 import { EXIT, FLAGS, NAMED_VIEWS, helpLines } from "./names.js";
 import { accept, signedBatch } from "./accept.js";
+import { renderWalk, landWalk, foreignWalkLines } from "../host/walk.js";
+import { isWalkHeader } from '@lapxo/topos/walk';
+import { ingressBundles, ingressReceipts } from "../host/ports/ingress.js";
 /** The first land of a lock: TARGET.bound into an empty owner ledger, then the sources that lock names. */
 async function firstLand(root, args) {
     const started = Date.now();
@@ -184,6 +188,17 @@ async function view(root, under, asked, told = [], coord, key, includePolicy = t
         process.stderr.write(`${selfName()}: the owner ledger is empty; land it before rendering a view\n`);
         return EXIT.refuse;
     }
+    if (name === 'evidence' && !under && !told.length && ingressBundles(storeOf(root)).length) {
+        const declared = viewsOf(lockStanding(storeOf(root))).get(name);
+        if (!declared || declared.shape || !declared.regions.some(region => region.name === 'evidence'))
+            throw Error('REFUSE·view foreign evidence requires a declared evidence view');
+        const received = await foreignWalkLines(root), authority = authorityFor(lockLines(storeOf(root)), rootSigner(root), signaturesOf(storeOf(root)).admitted);
+        const local = [...new Set(authority.admitted.flatMap(key => ledgerLines(storeOf(root), key.id)))].filter(line => authority.of(line).kind === 'admitted');
+        for (const line of [...new Set([...local, ...ingressReceipts(storeOf(root)), ...received])])
+            process.stdout.write(line + '\n');
+        process.stdout.write('FACT authenticated histories · readings · no encounters computed\n');
+        return EXIT.closed;
+    }
     const at = Date.now();
     const place = under?.replace(/\/$/, '');
     const released = releaseOf(storeOf(root));
@@ -367,6 +382,12 @@ async function landVerb(root, rest) {
     process.once('uncaughtException', (error) => die(error instanceof Error ? error.message : String(error)));
     process.once('unhandledRejection', (error) => die(error instanceof Error ? error.message : String(error)));
     try {
+        const proposed = batch.flatMap(claimLinesIn);
+        if (proposed.some(isWalkHeader)) {
+            for (const line of await landWalk(root, proposed, valueOf(rest, FLAGS.key), valueOf(rest, FLAGS.keyFile), valueOf(rest, FLAGS.signer)))
+                process.stdout.write(line + '\n');
+            return EXIT.closed;
+        }
         return await accept(root, rest);
     }
     catch (error) {
@@ -395,7 +416,7 @@ function foldFile(at) {
         process.stdout.write(`${line}\n`);
     for (const fork of folded.forks)
         process.stdout.write(`FORK     ${fork.key}${fork.state ? ` · ${fork.state}` : ''}\n`);
-    process.stdout.write(`FACT     ${folded.standing.length} standing · ${folded.forks.length} forks · ${basename(at)}\n`);
+    process.stdout.write(`FACT     ${folded.standing.length} standing · ${folded.forks.length} forks · ${basename(at)} · readings · no encounters computed\n`);
     return EXIT.closed;
 }
 function foldVerb(root, rest) {
@@ -429,6 +450,19 @@ async function foldResolved(root, under, argv) {
     // Public content is authenticated by its digest, independently of owner history.
     // A named view does not request mounting every release of the instrument.
     const receiptCheck = as === undefined && argv.includes(FLAGS.check);
+    if (as?.split('@')[0] === 'walk') {
+        if (argv.includes(FLAGS.check))
+            throw Error('REFUSE·walk check does not initiate or sign an exchange');
+        if (under || inputs.length > 1)
+            throw Error('REFUSE·walk one place and one authenticated peer inventory per fold');
+        const depth = as.split('@')[1];
+        if (depth !== undefined && (!/^(0|[1-9][0-9]*)$/.test(depth) || !Number.isSafeInteger(Number(depth))))
+            throw Error('REFUSE·walk invalid resolution');
+        const peer = inputs.length ? claimLinesIn(inputs[0]) : [];
+        for (const line of await renderWalk(root, depth === undefined ? undefined : Number(depth), peer, valueOf(argv, FLAGS.key), valueOf(argv, FLAGS.keyFile), valueOf(argv, FLAGS.signer)))
+            process.stdout.write(line + '\n');
+        return EXIT.closed;
+    }
     if (as === OBJECT_VIEW) {
         const inputs = positionalsOf(argv).filter(one => existsSync(resolve(one)) && !lstatSync(resolve(one)).isDirectory());
         if (inputs.length > 1)

package/dist/fold/claims.js

@@ -38,7 +38,11 @@ function regionsOf(line) {
 }
 function contracted(line, sides, receipts) {
     const scope = fieldsOf(line)['scope'] ?? '';
-    const mine = exclusive(regionsOf(line), sides.filter((other) => other !== line).map(regionsOf));
+    const named = regionsOf(line);
+    // File receipts can discharge only declared file regions. No region is not an empty proof.
+    if (named.length === 0)
+        return false;
+    const mine = exclusive(named, 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);
 }

package/dist/fold/closed.js

@@ -1,6 +1,8 @@
+import { actCosts } from "../host/act-cost.js";
+import { verifiedReadingReceipts } from "../host/reading-closures.js";
 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 { byBytes, canonical, LOCK, parse, publicationOf, roleAt, roleClaimsOf } from '@lapxo/topos/wire';
+import { RECEIPTS, fieldOf, foldClaims, isConfig, 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";
@@ -9,15 +11,14 @@ 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. */
+/** 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 the largest measured act or unpartitioned host work, 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 actSeconds = () => actCosts.seconds();
 export const receiptsSeen = () => seen;
 const algorithmIn = (text) => text.match(/(?:value=|place:)([a-z0-9]+):[0-9a-f]{64}/)?.[1] ?? '';
 const lockStamp = (root, place) => {
@@ -55,6 +56,14 @@ function filesOf(root, place, region, inputs) {
     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 publicConfiguration(lines) {
+    if (!lines.length || !lines.every(isConfig))
+        return lines;
+    const folded = foldClaims(lines);
+    if (folded.forks.length)
+        throw Error('REFUSE·receipt disputed configuration standing');
+    return publicationOf(folded.standing.filter(line => fieldOf(line, 'value') !== 'withdraw'));
+}
 function rootLines(root, place) {
     const name = place.replace(/\/$/, '');
     if (!name)
@@ -63,7 +72,7 @@ function rootLines(root, place) {
     const held = rooted.get(key);
     if (held !== undefined)
         return held;
-    const standing = (observeText(join(root, LOCK)) ?? '').split('\n').filter(isWire);
+    const standing = publicConfiguration((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);
@@ -73,8 +82,20 @@ function rootLines(root, place) {
 }
 /** 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);
+    const files = [...filesOf(root, place, region, inputs)].sort(byBytes);
+    const own = join(root, place, LOCK);
+    const bytesOf = (rel) => {
+        const at = join(root, rel), bytes = observeFile(at) ?? new Uint8Array();
+        if (resolve(at) !== resolve(own))
+            return bytes;
+        const lines = new TextDecoder().decode(bytes).split('\n').filter(isWire);
+        // Object history keeps its own contract. Configuration's public identity is
+        // the existing Topos publication projection, not its admission envelopes.
+        if (!lines.length || !lines.every(isConfig))
+            return bytes;
+        return new TextEncoder().encode(publicConfiguration(lines).join('\n') + '\n');
+    };
+    return hashFull([...files.map((rel) => `${relative(join(root, place), join(root, rel))} ${hashBytes(bytesOf(rel), algorithm)}`), ...rootLines(root, place)], algorithm);
 }
 function namedReceipts(root, store) {
     const text = observeText(join(root, RECEIPTS));
@@ -89,13 +110,15 @@ function namedReceipts(root, store) {
     }
     return out;
 }
+// Only the instrument's file seals describe file-region bytes. Reader receipts keep their own semantic identity.
+const fileSeal = (line) => isWire(line) && fieldOf(line, 'measure') === 'bytes' && fieldOf(line, 'by') === 'bound';
 function ownBytes(root) {
-    return (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(line => isWire(line) && fieldOf(line, 'measure') === 'bytes');
+    return (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(fileSeal);
 }
 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 lines = shipped.filter(fileSeal);
     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');
 }
@@ -115,8 +138,8 @@ function rewritePlace(root, place) {
     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 kept = text.split('\n').filter((line) => line === '' || !fileSeal(line));
+    const regions = kept.filter((line) => isWire(line) && fieldOf(line, 'measure') === 'count' && fieldOf(line, 'by') === 'bound' && fieldOf(line, 'scope').startsWith('receipts/'));
     const bytes = regions.map((line) => {
         const scope = fieldOf(line, 'scope');
         const inputs = carriedFrom(storeOf(root), kept.filter(isWire)) ?? [];
@@ -146,11 +169,19 @@ export function meets(root, store, place) {
         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]) => {
+        let 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}/`);
         });
+        if (closed && carried) {
+            const algorithm = algorithmIn(own.join('\n'));
+            const readings = verifiedReadingReceipts(store, carried, text => hashFull(text, algorithm));
+            if (readings === undefined)
+                closed = false;
+            else if (readings)
+                process.stderr.write(`RECEIPTS ${readings} read · 0 opened · reading closures\n`);
+        }
         seen = { count: named.size + (own.length > 0 ? 1 : 0), ms: Date.now() - at };
         return closed;
     }

package/dist/fold/digests.js

@@ -7,6 +7,7 @@ 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';
+import { moduleImports } from "../host/adapters/modules/javascript.js";
 const held = new Map();
 let algorithmMs = 0;
 export const algorithmCost = () => algorithmMs;
@@ -110,6 +111,8 @@ export function coordinateDigest(store, at) {
     const stamp = stampOf(at);
     if (stamp?.kind !== 'file')
         return stamp === undefined ? undefined : bytesDigest(store, observeFile(at) ?? new Uint8Array());
+    if (readOnly())
+        return bytesDigest(store, observeFile(at) ?? new Uint8Array());
     const key = `${at} ${stamp.stamp}`;
     const memo = memoOf(store);
     const held = memo.get(key);
@@ -140,10 +143,10 @@ 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);
+    const held = imported.get(digest) ?? (readOnly() ? undefined : 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] ?? '');
+    const found = moduleImports(new TextDecoder().decode(observeFile(at) ?? new Uint8Array()), at);
     imported.set(digest, found);
     memo.set(key, found.join('|'));
     if (!readOnly())