@lapxo/bound 0.2.3 → 0.2.5

package/dist/cli/accept.js

@@ -1,558 +1,72 @@
-import { assertProspectiveRootClockSelection } from "../host/root-clock-source.js";
-import { hasContextualPlace, landContextualPlace } from "../host/contextual-place.js";
-import { commitLocalAct, intactLocalAct, committedLocalActs } from "../host/ports/local-act.js";
-import { withoutEffects } from "../host/read-only.js";
-import { admittedLine } from "../host/selected-topos.js";
-import { timing } from "../host/timing.js";
-import { admittedObjects } from "../host/objects.js";
-import { existsSync, rmdirSync, rmSync } from 'node:fs';
-import { dirname, join, basename } from 'node:path';
-import { closeReceipts, instrumentKeep, instrumentKept } from "../fold/closed.js";
-import { bytesDigest, fullDigest, instrumentOf, signaturesOf } from "../fold/digests.js";
-import { canonical, LOCK, parse, actIdentity, actResultProfile } from '@lapxo/topos/wire';
-import { fieldOf, isConfig, foldClaims, sayingOf, selfName } from "../fold/claims.js";
-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, 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";
-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 } from "../observe/runner.js";
-import { widenedWithoutWitness } from "../judge/widening.js";
-import { retractedTogether, withdrawal } from "../land/withdraw.js";
-import { isCeiling } from "../fold/configures.js";
-import { inertIn } from "../land/inert.js";
-import { landSaid } from "./pass.js";
-import { underTheLock, underTheRegions, underAuthorityRegions, underRootProjection } from "../land/act.js";
-import { openedBy } from "../fold/opened.js";
-import { touchedBy } from "../fold/reach.js";
-import { landOwned, ownedOf } from "../land/owned.js";
-import { layReleases } from "../host/release.js";
-import { foundableIn, placesIn } from "../fold/places.js";
-import { outsideTheirCapsule } from "../fold/own.js";
-import { lateFacts } from "../judge/late.js";
-import { paidOf } from "../fold/paid.js";
-import { aliasPinned } from "../land/alias.js";
-import { admitStandingPins } from "../land/standing-pin.js";
-import { coordinatesWithdrawn } from "../land/leaving.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";
-/** Admission reads an existing evidence snapshot; acquiring observations belongs to fold. */
-function admissionEvidence(root, signed, standing) {
-    return withoutEffects(() => {
-        const store = storeOf(root);
-        assertProspectiveRootClockSelection(root, signed);
-        const reads = !signed.some(isReaderLock) && signed.some(isCeiling);
-        const fold = reads ? coneOf(root, entryOf(root), signed.filter(isCeiling)) : { standing, observed: [], own: {}, kept: true };
-        const inert = inertIn(signed, { standing: fold.standing, ceiling: isCeiling, signsReader: !reads, observed: fold.observed, own: fold.own, epoch: epochOf([...lockLines(store), ...signed]) });
-        if (inert.length)
-            throw Error('REFUSE·inert no existing reading meets these ceilings; fold the declared inputs first');
-        const coordinates = coordinatesWithdrawn(root, store, signed, [...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 => {
-            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(' · ')}`);
-        return { coordinates, judged, fold };
-    });
-}
-/** One witness rule for prospective admission and the locked act. */
-function refusesWidening(signed, standing) {
-    const widened = widenedWithoutWitness(signed, standing, isCeiling, wordOf(standing, 'at-classes', 'witness'));
-    if (widened.length) {
-        for (const line of widened)
-            process.stderr.write(`WIDER    ${fieldOf(line, 'scope')} · ${fieldOf(line, 'value')}\n`);
-        process.stderr.write(`${selfName()}: REFUSE·widening nothing landed · a ceiling that admits more than it did gives back freedom the lock had spent: sign it under a witness that names what made the old ceiling wrong\n`);
-        return true;
-    }
-    return false;
-}
-/** Admission-only checks; observation and mutation belong to the later act. */
-function refusesAdmission(root, signed, standing) {
-    if (refusesWidening(signed, standing))
-        return true;
-    const store = storeOf(root);
-    const outside = outsideTheirCapsule(root, standing, signed);
-    for (const line of outside)
-        process.stderr.write(`OUTSIDE  ${fieldOf(line, 'scope')} · ${fieldOf(line, 'value')}\n`);
-    if (outside.length) {
-        process.stderr.write(`${selfName()}: REFUSE·outside nothing landed · a reader or a capsule lands in the capsule of its world, never in the wire or the instrument\n`);
-        return true;
-    }
-    const forks = forksJoinedBy(store, signed).filter(fork => forksItself(fork.lines) || fork.lines.filter(line => signed.includes(line)).length > 1);
-    if (forks.length) {
-        for (const fork of forks) {
-            process.stderr.write(`FORK     ${fork.key}\n`);
-            for (const line of fork.lines)
-                process.stderr.write(`  ${signed.includes(line) ? 'new ' : 'held'}  by=${fieldOf(line, 'by')} ${sideOf(line, lockLines(store))}\n`);
-        }
-        process.stderr.write(`${selfName()}: REFUSE·fork nothing landed · one signer never forks itself, and one act never forks itself: withdraw the held side in this batch, or sign the other reading under its own scope\n`);
-        return true;
-    }
-    const held = aliasPinned(root, signed);
-    if (held.length) {
-        for (const one of held)
-            process.stderr.write(`ALIAS    ${one.scope} · ${one.digest} · ${one.by.join(' ')}\n`);
-        process.stderr.write(`${selfName()}: REFUSE·alias nothing landed · an alias is withdrawn only when no pin names its digest\n`);
-        return true;
-    }
-    return false;
-}
-function refusesStandingPins(root, lines) {
-    try {
-        admitStandingPins(root, lines);
-        return false;
-    }
-    catch (error) {
-        process.stderr.write(`${selfName()}: ${error instanceof Error ? error.message : String(error)}\n`);
-        return true;
-    }
-}
-/** A batch signed as accept signs it: at the next epoch, by the key it names, each line read by the wire it would land under. */
-export async function signedBatch(root, args, files) {
-    const byFile = files.map((file) => [placesOfFile(file), claimLinesIn(file)]);
-    const proposed = byFile.flatMap(([, lines]) => lines);
-    if (!proposed.length) {
-        process.stderr.write(`${selfName()}: a batch is a file with claim lines\n`);
-        return { kind: 'exit', code: 2 };
-    }
-    const drafted = proposed.filter((line) => !fieldOf(line, 'sig'));
-    const bare = drafted.filter((line) => fieldOf(line, 'epoch') || !['', 'target'].includes(fieldOf(line, 'by')));
-    if (bare.length) {
-        for (const line of bare)
-            process.stderr.write(`BARE     ${fieldOf(line, 'scope')} · by=${fieldOf(line, 'by') || '∅'}${fieldOf(line, 'epoch') ? ` epoch=${fieldOf(line, 'epoch')}` : ''}\n`);
-        process.stderr.write(`${selfName()}: REFUSE·bare nothing landed · ${bare.length} lines name a signer or an epoch they were not signed with: a drafted line proposes by=target and sign signs it, a line a lane signed carries its sig\n`);
-        return { kind: 'exit', code: 1 };
-    }
-    const store = storeOf(root);
-    const destinations = [...new Set([...namedPlaces(args), ...byFile.flatMap(([heads]) => heads)])];
-    const rooted = lockStanding(store);
-    const stray = destinations.filter(one => !placesIn(root).includes(one) && !foundableIn(root, rooted, wordOf(rooted, 'families', 'region'), one));
-    if (stray.length) {
-        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 local = localActLines(root, destinations);
-    const base = { digest: fullDigest(store, local), places: destinations };
-    const epoch = epochOf(local) + 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'))));
-    if (stale.length) {
-        for (const one of stale)
-            process.stderr.write(`SIGNED   ${one}\n`);
-        process.stderr.write(`${selfName()}: REFUSE·signed nothing landed · ${stale.length} lines a lane signed stand at no epoch this act\n`);
-        return { kind: 'exit', code: 1 };
-    }
-    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)))
-        : 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 {
-                await admittedObjects(root, [...signedOwnerLines(store), ...proposed]);
-            }
-            catch (e) {
-                process.stderr.write(`${selfName()}: ${String(e)} · nothing landed\n`);
-                return { kind: 'exit', code: 1 };
-            }
-        }
-        return { kind: 'once', proposed };
-    }
-    const outdated = proposed.filter(line => fieldOf(line, 'sig') && isConfig(line) && Number(fieldOf(line, 'epoch')) !== epoch);
-    if (outdated.length) {
-        for (const line of outdated)
-            process.stderr.write(`SIGNED   ${fieldOf(line, 'scope')} · signed by ${fieldOf(line, 'by')} at epoch ${fieldOf(line, 'epoch')}, and this act lands at ${epoch}: sign it again\n`);
-        process.stderr.write(`${selfName()}: REFUSE·signed nothing landed · ${outdated.length} lines a lane signed stand at no epoch this act\n`);
-        return { kind: 'exit', code: 1 };
-    }
-    const keyFile = valueOf(args, FLAGS.keyFile);
-    const keyId = valueOf(args, FLAGS.key) ?? ownerOf(store);
-    const publicKey = drafted.length ? publicKeyOf(root, keyId) : undefined;
-    if (drafted.length && !publicKey) {
-        process.stderr.write(`${selfName()}: unknown key ${keyId} — name it in ${selfName()}.keys\n`);
-        return { kind: 'exit', code: 2 };
-    }
-    let signed = proposed.filter((line) => fieldOf(line, 'sig'));
-    if (drafted.length) {
-        let invoke;
-        try {
-            invoke = signerFor([...lockStanding(store), ...destinations.flatMap(place => ownLockOf(root, place))], keyId, valueOf(args, FLAGS.signer), keyFile);
-        }
-        catch (error) {
-            process.stderr.write(`${selfName()}: ${error instanceof Error ? error.message : 'REFUSE·signer unavailable'}\n`);
-            return { kind: 'exit', code: 1 };
-        }
-        const got = await signConsentLot(drafted, { epoch, by: keyId, algorithm: signaturesOf(store).era }, publicKey, signaturesOf(store).admitted, invoke);
-        if (got.kind === 'refuse') {
-            process.stderr.write(`${selfName()}: ${got.why}\n`);
-            return { kind: 'exit', code: 1 };
-        }
-        let index = 0;
-        signed = proposed.map(line => fieldOf(line, 'sig') ? line : got.lines[index++]);
-    }
-    const wireLines = [...signedOwnerLines(store), ...signed].flatMap((line) => {
-        const got = parse(line);
-        return got.kind === 'fact' ? [got.value.fields] : [];
-    });
-    for (const line of signed) {
-        const got = admittedLine(line, wireLines, Number(fieldOf(line, 'epoch')), foldClaims(signedOwnerLines(store)).standing.filter(one => fieldOf(one, 'scope').startsWith('uses/') && fieldOf(one, 'value') !== 'withdraw'));
-        if (got.kind !== 'fact') {
-            process.stderr.write(`${selfName()}: REFUSE·wire ${fieldOf(line, 'scope')} · ${got.why} · nothing landed\n`);
-            return { kind: 'exit', code: 1 };
-        }
-    }
-    if (refusesStandingPins(root, signed))
-        return { kind: 'exit', code: 1 };
-    const taken = retractedTogether(signed);
-    if (taken.length) {
-        for (const pair of taken) {
-            process.stderr.write(`WITHDRAW ${sayingOf(pair.withdraw)}\n`);
-            process.stderr.write(`NEW      ${sayingOf(pair.line)}\n`);
-        }
-        process.stderr.write(`${selfName()}: REFUSE·withdraw nothing landed · a withdraw matches a new line in this batch, so it takes that line too\n`);
-        return { kind: 'exit', code: 1 };
-    }
-    const authority = authorityFor([...lockLines(store), ...signed], rootSigner(root), signaturesOf(store).admitted);
-    const ownership = ownedOf(root, signed, line => authority.of(line).kind === 'admitted', by => authority.admitted.find(one => one.id === by)?.coverage ?? [], named, line => { const heads = byFile.flatMap(([heads, lines]) => lines.some(draft => sayingOf(draft) === sayingOf(line)) ? heads : []); return heads.length ? heads : undefined; });
-    if (ownership.nowhere.length) {
-        for (const line of ownership.nowhere)
-            process.stderr.write(`${selfName()}: REFUSE·signer ${keyId} uncovered ${fieldOf(line, 'scope')} · nothing signed for delivery\n`);
-        return { kind: 'exit', code: 1 };
-    }
-    if (ownership.forked.length) {
-        for (const one of ownership.forked)
-            process.stderr.write(`FORKED   ${one.place}/${LOCK} · ${one.key} · the lot would leave two standing claims where the lock had one\n`);
-        process.stderr.write(`${selfName()}: REFUSE·forked nothing landed · ${ownership.forked.length} claims an own lot would fork: a lot for many places lands the same lines at each, and lines meant for one place go in a lot of their own\n`);
-        return { kind: 'exit', code: 1 };
-    }
-    if (refusesAdmission(root, ownership.ledger, lockStanding(store)))
-        return { kind: 'exit', code: 1 };
-    if (signed.some(line => !isConfig(line))) {
-        try {
-            await admittedObjects(root, [...signedOwnerLines(store), ...signed], text => process.stdout.write(text + '\n'));
-        }
-        catch (e) {
-            process.stderr.write(`${selfName()}: ${e instanceof Error ? e.message : String(e)} · nothing landed\n`);
-            return { kind: 'exit', code: 1 };
-        }
-    }
-    try {
-        admissionEvidence(root, ownership.ledger, lockStanding(store));
-    }
-    catch (error) {
-        process.stderr.write(`${selfName()}: ${error instanceof Error ? error.message : String(error)} · nothing landed\n`);
-        return { kind: 'exit', code: 1 };
-    }
-    return { kind: 'signed', signed, epoch, base, ...(drafted.length ? { keyId } : {}) };
-}
-/**
- * accept is one act under the descent of its lines. Every place, then the root where they join, only when those lines
- * rest on every place; a line in one place's own lock is that place. It signs the batch at the epoch the lock
- * stands at, folds it, judges every take of it, and lands only when all of it holds. A batch refused lands nothing.
- * What a batch would move is read before it with `--as rank <batch>`. A cycle's lanes each sign
- * their batch with `bound sign` at the epoch the act lands at, and one land takes them all, each line in its signer's
- * ledger once it verifies against that signer: one signer never forks itself, and one act never forks itself.
- */
-export async function accept(root, args) {
-    const started = Date.now();
-    const contextFiles = positionalsOf(args);
-    if (contextFiles.length === 1 && hasContextualPlace(root) && !claimLinesIn(contextFiles[0]).length) {
-        if (namedPlaces(args).length || valueOf(args, FLAGS.key) || valueOf(args, FLAGS.keyFile) || valueOf(args, FLAGS.signer))
-            throw Error('REFUSE·contextual place accepts one already signed context envelope');
-        const result = await landContextualPlace(root, contextFiles[0]);
-        process.stdout.write(JSON.stringify({ profile: 'place-act-context@1', identity: result.identity, status: result.kind, context: result.context, receipts: result.receipts }) + '\n');
-        return 0;
-    }
-    const named = namedPlaces(args);
-    const placed = positionalsOf(args).reduce((all, file) => ((places) => (places.length ? claimLinesIn(file).reduce((got, line) => got.set(sayingOf(line), [...new Set([...(got.get(sayingOf(line)) ?? []), ...places])]), all) : all))(placesOfFile(file)), new Map());
-    const batch = await signedBatch(root, args, positionalsOf(args));
-    if (batch.kind === 'exit')
-        return batch.code;
-    if (batch.kind === 'once')
-        return underTheLock(storeOf(root), 'land', () => repaid(root, batch.proposed, started));
-    const store = storeOf(root);
-    const authority = authorityFor([...lockLines(store), ...batch.signed], rootSigner(root), signaturesOf(store).admitted);
-    const owned = ownedOf(root, batch.signed, (line) => authority.of(line).kind === 'admitted', (by) => authority.admitted.find((one) => one.id === by)?.coverage ?? [], named, (line) => placed.get(sayingOf(line)));
-    if (owned.nowhere.length) {
-        for (const line of owned.nowhere)
-            process.stderr.write(`NOWHERE  ${fieldOf(line, 'scope')} · ${((got) => (got.kind === 'admitted' ? 'admitted' : got.why))(authority.of(line))}, and ${named.length ? `no place of ${named.join(', ')} takes it` : 'no one own lock it covers takes it: name the places with --place'}\n`);
-        process.stderr.write(`${selfName()}: REFUSE·nowhere nothing landed · ${owned.nowhere.length} lines neither the ledger nor an own lock admits: a line is landed signed where it stands, never written in bare\n`);
-        return 1;
-    }
-    const places = placesIn(root);
-    const pinned = [...new Set([...owned.own.keys(), ...named])];
-    const touched = pinned.length === 0 && owned.ledger.length ? touchedBy(root, places, owned.ledger, lockStanding(store)) : [];
-    const every = pinned.length === 0 && touched.length === places.length && places.length > 0;
-    const regions = (pinned.length ? pinned : every ? places : touched).filter((one) => places.includes(one));
-    const where = every ? 'every place · then the root, where the places join' : regions.length ? regions.map((one) => `${one}/`).join(' · ') : 'the root alone, where the places join';
-    process.stdout.write(`ACTS     ${where} · ${owned.ledger.length} lines to the ledger${[...owned.own].map(([place, lines]) => ` · ${lines.length} to ${place}'s own lock`).join('')} · before the lock\n`);
-    const asked = Date.now();
-    // Root-ledger writes may change grants or inherited policies. Child-only
-    // lots read that authority through publication, without excluding siblings.
-    const rootWrite = owned.ledger.length > 0 || every || regions.length === 0;
-    const enter = rootWrite ? underTheRegions : underAuthorityRegions;
-    return enter(store, rootWrite ? [...regions, ''] : regions, 'land', () => acceptNow(root, { ...batch, signed: owned.ledger, records: batch.signed }, started, owned, asked, regions));
-}
-async function acceptNow(root, batch, started, owned, asked = started, descent = []) {
-    const waited = Date.now() - asked;
-    if (waited > 60000)
-        process.stdout.write(`RED      wait ${Math.round(waited / 1000)} s for the lock before the act · a wait over a minute is a red\n`);
-    const spent = [`sign ${asked - started}`, `wait ${waited}`];
-    const took = timing(spent);
-    const { signed, epoch } = batch;
-    if (refusesStandingPins(root, batch.records ?? signed))
-        return 1;
-    const store = storeOf(root);
-    const currentBase = fullDigest(store, localActLines(root, batch.base.places));
-    if (currentBase !== batch.base.digest) {
-        process.stderr.write(`${selfName()}: REFUSE·base moved ${batch.base.digest} → ${currentBase} · nothing landed\n`);
-        return 1;
-    }
-    try {
-        assertProspectiveRootClockSelection(root, signed);
-    }
-    catch (error) {
-        process.stderr.write(`${selfName()}: ${error instanceof Error ? error.message : String(error)} · nothing landed\n`);
-        return 1;
-    }
-    if (signed.some(line => !isConfig(line))) {
-        try {
-            await admittedObjects(root, [...signedOwnerLines(store), ...signed]);
-        }
-        catch (e) {
-            process.stderr.write(`${selfName()}: ${e instanceof Error ? e.message : String(e)} · nothing landed\n`);
-            return 1;
-        }
-    }
-    const snapshot = took('lines', () => standingOf(root));
-    if (refusesAdmission(root, signed, snapshot.standing))
-        return 1;
-    let evidence;
-    try {
-        evidence = took('evidence', () => admissionEvidence(root, signed, snapshot.standing));
-    }
-    catch (error) {
-        process.stderr.write(`${selfName()}: ${error instanceof Error ? error.message : String(error)} · nothing landed\n`);
-        return 1;
-    }
-    const fold = evidence.fold;
-    const authority = took('authority', () => authorityFor([...lockLines(store), ...signed], rootSigner(root), signaturesOf(store).admitted));
-    for (const line of signed) {
-        const verdict = authority.of(line);
-        if (verdict.kind !== 'admitted') {
-            process.stderr.write(`${selfName()}: ${verdict.kind === 'refuse' ? verdict.why : `REFUSE·authority grey: ${verdict.why}`}\n`);
-            return 1;
-        }
-    }
-    const withdraws = signed.filter((line) => fieldOf(line, 'value') === 'withdraw');
-    const coordinates = evidence.coordinates;
-    const withdrawn = withdraws.length ? withdrawal(withdraws, lockLines(store)) : null;
-    const view = `${wordOf(fold.standing, 'families', 'view')}/`;
-    const lot = fullDigest(store, signed);
-    const tree = hasVouchedTree(store)
-        ? fullDigest(store, [...vouchedCoordinates(store)].sort(([a], [b]) => a.localeCompare(b)).map(([coordinate, digest]) => `${coordinate} ${digest}`))
-        : 'key' in fold && typeof fold.key === 'string' ? fold.key : fullDigest(store, fold.standing);
-    const cached = keptTakes(keptVerdict(store, tree, lot));
-    const judged = cached ?? evidence.judged;
-    if (!cached)
-        keepVerdict(store, tree, lot, judged.map(packTake));
-    const refused = judged.filter((one) => one.kind === 'refused' || (one.kind === 'judged' && one.verdict.kind === 'refuse'));
-    if (refused.length) {
-        for (const one of refused)
-            process.stdout.write(`REFUSE   take ${one.scope} · ${one.kind === 'judged' ? one.verdict.why : one.kind === 'refused' ? one.why : ''}\n`);
-        process.stderr.write(`${selfName()}: REFUSE·takes nothing landed · ${refused.length} takes refused: a batch lands whole or not at all\n`);
-        return 1;
-    }
-    const told = took('told', () => standingOf(root, undefined, signed));
-    for (const name of openedBy(descent, told.standing, signed))
-        process.stderr.write(`OPEN     ${name}\n`);
-    if (owned.own.size)
-        layReleases(store, root, told.standing, store);
-    const resultProfile = actResultProfile(snapshot.standing);
-    let landed = [];
-    if (resultProfile) {
-        const records = batch.records ?? signed;
-        const placements = [...(signed.length ? [{ place: '.', records: signed }] : []), ...[...owned.own].map(([place, records]) => ({ place: `${place}/${LOCK}`, records }))];
-        const digest = (bytes) => bytesDigest(store, new TextEncoder().encode(bytes));
-        const identity = actIdentity(records, { ...resultProfile, digest, placements, localEpoch: epoch });
-        const folder = writerFor(snapshot.standing, 'fold');
-        if (!folder)
-            throw Error('REFUSE·act native result requires a declared fold identity');
-        const receipt = canonical({ scope: resultProfile.scope, at: resultProfile.context, role: 'writes', form: 'alphabet', measure: 'digest', value: identity, by: folder, epoch: String(epoch) });
-        const bundle = { records: records.join('\n') + '\n', receipt: receipt + '\n', placements: placements.map(p => ({ place: p.place, records: p.records.join('\n') + '\n' })) };
-        await commitLocalAct(store, identity, descent, async () => bundle, intactLocalAct);
-        // Commitment precedes projections and conformance work. If either fails,
-        // this public identity still names the admitted act; it is never rollback.
-        process.stdout.write(`ACT ${identity} · epoch ${epoch} · admitted · conformance not asserted\n`);
-        for (const line of records)
-            process.stdout.write(line + '\n');
-        process.stdout.write(receipt + '\n');
-        landed = [{ at: 'committed act ' + identity, appended: records.length }];
-    }
-    else
-        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, resultProfile !== undefined);
-    return underRootProjection(store, 'projection', async () => {
-        landSaid(store, writerFor(told.standing, 'fold'), []);
-        for (const line of signed) {
-            const value = fieldOf(line, 'value');
-            if (!/^[a-z0-9-]+:[0-9a-f]{32,}$/.test(value))
-                continue;
-            for (const need of locationsOf(fieldOf(line, 'needs')).locations) {
-                const at = join(root, need);
-                const bytes = observeFile(at);
-                if (bytes === undefined)
-                    continue;
-                if (bytesDigest(store, bytes) === value)
-                    landBlob(store, value, bytes);
-            }
-        }
-        if (coordinates.taken.length) {
-            for (const path of coordinates.taken) {
-                if (existsSync(join(root, path)))
-                    rmSync(join(root, path), { recursive: true });
-                for (let dir = dirname(path); dir !== '.' && existsSync(join(root, dir)) && !entriesIn(join(root, dir)).length; dir = dirname(dir))
-                    rmdirSync(join(root, dir));
-            }
-            landCoordinates(store, new Map(), coordinates.taken, `withdraw:epoch-${epoch}`);
-            for (const path of coordinates.taken)
-                process.stdout.write(`GONE     ${path} · withdrawn by its line\n`);
-        }
-        for (const one of judged)
-            landTake(root, one, []);
-        const standingAsked = [...signed, ...fold.standing].filter((line) => fieldOf(line, 'role') === 'demands' && fieldOf(line, 'value') !== 'withdraw');
-        const paidScopes = new Set(paidOf(store, standingAsked, fold.observed, view).paid.map((line) => fieldOf(line, 'scope')));
-        const late = lateFacts(store, [...signed, ...fold.standing], paidScopes);
-        if (late.length) {
-            land(store, 'judge', late);
-            for (const line of late)
-                if (fieldOf(line, 'measure') !== 'cone')
-                    process.stdout.write(`LATE     ${fieldOf(line, 'scope')} · answered from the landed cone\n`);
-        }
-        if (signed.some((line) => fieldOf(line, 'scope').startsWith(`${basename(ownRoot())}/`) && !fieldOf(line, 'scope').split('/').slice(1, -1).includes('uses'))) {
-            const code = instrumentOf(store, entryOf(root), told.standing, root, ownLock());
-            if (instrumentKept(store) !== code) {
-                const open = await closeReceipts(root, store);
-                instrumentKeep(store, code);
-                process.stderr.write(`open by instrument · ${open.length}\n`);
-            }
-        }
-        const rendered = took('render', () => renderInto(root, store));
-        process.stdout.write(`RENDER 0\n`);
-        const own = new Set([...owned.own.values()].flat()).size;
-        const perLine = Math.round((Date.now() - started) / Math.max(1, signed.length + own));
-        const folder = writerFor(fold.standing, 'fold');
-        const beat = (ms, at) => canonical({ scope: 'beat/accept', role: 'writes', form: 'interval', measure: 'ms', value: `${ms}..${ms}`, by: folder ?? '', at: `place:${at}` });
-        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 · 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`);
-            for (const line of withdrawn.inexact)
-                process.stdout.write(`INEXACT  ${fieldOf(line, 'scope')} · its scale is not distributive: what the others hold is not what they held without it\n`);
-        }
-        return 0;
-    });
-}
-/**
- * A batch landed twice is one: nothing of it lands again. What it left unpaid is judged again, the way it would be now:
- * each of its demands the fold counts unpaid is taken, and the takes land only when all of it holds.
- */
-function repaid(root, proposed, started) {
-    const store = storeOf(root);
-    const prior = committedLocalActs(store).find(act => { const lines = act.bundle.records.trimEnd().split('\n'); return lines.length === proposed.length && lines.every((line, i) => line === proposed[i]); });
-    if (prior) {
-        process.stdout.write(`ACT ${prior.identity} · epoch ${fieldOf(prior.bundle.receipt.trim(), 'epoch')} · admitted · replay\n` + prior.bundle.records + prior.bundle.receipt);
-    }
-    const asked = new Set(proposed.filter((line) => fieldOf(line, 'role') === 'demands').map((line) => fieldOf(line, 'scope')));
-    const view = `${wordOf(foldClaims(signedOwnerLines(store)).standing, 'families', 'view')}/`;
-    const standingAsked = signedDemands(store).filter((line) => asked.has(fieldOf(line, 'scope')) && !fieldOf(line, 'scope').startsWith(view));
-    const owed = paidOf(store, standingAsked, [], view).missing;
-    if (!owed.length) {
-        process.stdout.write(`ONCE     ${proposed.length} lines · every one already landed and every demand of it paid: a batch landed twice is one, nothing landed\n`);
-        return 0;
-    }
-    const judged = owed.map((line) => judgeDemand(root, line));
-    process.stdout.write(`ONCE     ${proposed.length} lines · every one already landed · ${owed.length} of its demands unpaid, judged again\n`);
-    if (judged.every((one) => one.kind === 'owed')) {
-        for (const one of judged)
-            landTake(root, one, []);
-        return 0;
-    }
-    const refused = judged.filter((one) => one.kind === 'refused' || (one.kind === 'judged' && one.verdict.kind === 'refuse'));
-    if (refused.length) {
-        for (const one of refused)
-            process.stdout.write(`REFUSE   take ${one.scope} · ${one.kind === 'judged' ? one.verdict.why : one.kind === 'refused' ? one.why : ''}\n`);
-        process.stderr.write(`${selfName()}: REFUSE·takes nothing landed · ${refused.length} takes refused: what a batch left unpaid is paid whole or not at all\n`);
-        return 1;
-    }
-    const standing = standingOf(root);
-    for (const one of judged)
-        landTake(root, one, []);
-    landSaid(store, writerFor(standing.standing, 'fold'), []);
-    const unpaidStanding = standing.standing.filter((line) => fieldOf(line, 'role') === 'demands' && fieldOf(line, 'value') !== 'withdraw');
-    const paidScopes = new Set(paidOf(store, unpaidStanding, [], `${wordOf(standing.standing, 'families', 'view')}/`).paid.map((line) => fieldOf(line, 'scope')));
-    const late = lateFacts(store, standing.standing, paidScopes);
-    if (late.length) {
-        land(store, 'judge', late);
-        for (const line of late)
-            if (fieldOf(line, 'measure') !== 'cone')
-                process.stdout.write(`LATE     ${fieldOf(line, 'scope')} · answered from the landed cone\n`);
-    }
-    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 · readings · no encounters computed · ${Date.now() - started} ms\n`);
-    return 0;
-}
-function packTake(one) {
-    return one.kind === 'judged'
-        ? { kind: one.kind, scope: one.scope, demand: one.demand, locations: one.locations, before: [...one.before], after: [...one.after], verdict: one.verdict, ignored: [...one.ignored] }
-        : one;
-}
-function keptTakes(raw) {
-    if (raw === undefined)
-        return undefined;
-    const out = [];
-    for (const one of raw) {
-        if (one === null || typeof one !== 'object' || !('kind' in one) || !('scope' in one))
-            return undefined;
-        const row = one;
-        if (row.kind !== 'judged') {
-            out.push(row);
-            continue;
-        }
-        out.push({
-            kind: 'judged', scope: row.scope, demand: row.demand, locations: row.locations,
-            before: new Map(row.before), after: new Map(row.after), verdict: row.verdict, ignored: new Map(row.ignored), started: Date.now(),
-        });
-    }
-    return out;
-}
+var _e=Object.defineProperty;var F=(n,r)=>_e(n,"name",{value:r,configurable:!0});import{BoundRefusal as $e}from"../host/refusals.js";import{assertHostNotCancelled as oe}from"../host/host-controls.js";import{library11_authorityAtEpoch as He}from"../vendor/runtime.js";import{requireEffects as qe}from"../host/read-only.js";import{hostOutput as o}from"../host/call-context.js";import{assertProspectiveRootClockSelection as ke}from"../host/root-clock-source.js";import{hasContextualPlace as ze,landContextualPlace as Ve}from"../host/contextual-place.js";import{commitLocalAct as Je,intactLocalAct as Xe,committedLocalActs as Qe}from"../host/ports/local-act.js";import{withoutEffects as Ye}from"../host/read-only.js";import{admittedLine as Ze}from"../host/selected-topos.js";import{timing as en}from"../host/timing.js";import{admittedObjects as le}from"../host/objects.js";import{existsSync as ye,rmdirSync as nn,rmSync as tn}from"node:fs";import{dirname as Ee,join as H,basename as rn}from"node:path";import{closeReceipts as on,instrumentKeep as sn,instrumentKept as an}from"../fold/closed.js";import{bytesDigest as ve,fullDigest as Y,instrumentOf as dn,signaturesOf as I}from"../fold/digests.js";import{library11_canonical as be,library11_LOCK as fe,library11_parse as Se,library11_actIdentity as cn,library11_actResultProfile as Re}from"../vendor/runtime.js";import{fieldOf as t,isConfig as q,foldClaims as Fe,sayingOf as D,selfName as k}from"../fold/claims.js";import{isReaderLock as ln}from"../fold/observed.js";import{authorityFor as Z,publicKeyOf as xe,rootSigner as ee,writerFor as ie}from"../fold/signers.js";import{lockLines as C,lockStanding as z}from"../fold/keys.js";import{keepVerdict as fn,keptVerdict as un,land as se,landBlob as hn,ledgerLines as mn,storeOf as N}from"../land/ledger.js";import{signConsentLot as pn,verifiesOwnerLine as gn}from"../land/sign.js";import{signerFor as wn}from"../host/signing.js";import{appliedIn as $n,ownLockOf as kn}from"../fold/signed.js";import{wordOf as V}from"../fold/wire.js";import{hasVouchedTree as yn,landCoordinates as En,locationsOf as vn,vouchedCoordinates as bn}from"../land/vouched.js";import{entriesIn as Sn,observeFile as Rn}from"../observe/files.js";import{coneOf as Fn,standingOf as ue}from"./place.js";import{ownLock as xn,ownRoot as jn}from"../observe/runner.js";import{widenedWithoutWitness as On}from"../judge/widening.js";import{retractedTogether as Un,withdrawal as An}from"../land/withdraw.js";import{isCeiling as ae}from"../fold/configures.js";import{inertIn as Dn}from"../land/inert.js";import{landSaid as je}from"./pass.js";import{underTheLock as Ln,underTheRegions as Tn,underAuthorityRegions as Cn,underRootProjection as In}from"../land/act.js";import{openedBy as Nn}from"../fold/opened.js";import{touchedBy as Mn}from"../fold/reach.js";import{landOwned as Wn,ownedOf as Oe}from"../land/owned.js";import{layReleases as Pn}from"../host/release.js";import{foundableIn as Bn,placesIn as he}from"../fold/places.js";import{outsideTheirCapsule as Kn}from"../fold/own.js";import{lateFacts as Ue}from"../judge/late.js";import{paidOf as me}from"../fold/paid.js";import{aliasPinned as Gn}from"../land/alias.js";import{admitStandingPins as _n}from"../land/standing-pin.js";import{coordinatesWithdrawn as Hn}from"../land/leaving.js";import{ownerOf as qn,epochOf as Ae,localActLines as De,forksItself as zn,forksJoinedBy as Vn,renderInto as Le,sideOf as Jn,signedDemands as Xn,signedOwnerLines as J}from"./owner.js";import{claimLinesIn as pe,entryOf as Te,namedPlaces as ne,placesOfFile as Ce,positionalsOf as ge,valueOf as X}from"./args.js";import{FLAGS as Q}from"./names.js";import{judgeDemand as Ie,landTake as we}from"./takes.js";function Ne(n,r,c){return Ye(()=>{const i=N(n);ke(n,r);const S=!r.some(ln)&&r.some(ae),y=S?Fn(n,Te(n),r.filter(ae)):{standing:c,observed:[],own:{},kept:!0};if(Dn(r,{standing:y.standing,ceiling:ae,signsReader:!S,observed:y.observed,own:y.own,epoch:Ae([...C(i),...r])}).length)throw Error("REFUSE\xB7inert no existing reading meets these ceilings; fold the declared inputs first");const m=Hn(n,i,r,[...r,...c]);if(m.refused.length)throw Error(`REFUSE\xB7withdraw a file is still read: ${m.refused.map(d=>`${d.path} by ${d.by}`).join(" \xB7 ")}`);const l=`${V(c,"families","view")}/`,g=r.filter(d=>q(d)&&t(d,"role")==="demands"&&t(d,"value")!=="withdraw"&&!t(d,"scope").startsWith(l)).map(d=>{const h=t(d,"scope");return c.some($=>q($)&&t($,"role")==="demands"&&t($,"value")!=="withdraw"&&t($,"scope")===h&&t($,"form")===t(d,"form")&&t($,"measure")===t(d,"measure"))?Ie(n,d):{kind:"owed",scope:h,why:"new demand declared; no conformance reading is claimed"}}),f=g.filter(d=>d.kind==="refused"||d.kind==="judged"&&d.verdict.kind==="refuse");if(f.length)throw Error(`REFUSE\xB7takes ${f.map(d=>`${d.scope}: ${d.kind==="judged"?d.verdict.why:d.kind==="refused"?d.why:""}`).join(" \xB7 ")}`);return{coordinates:m,judged:g,fold:y}})}F(Ne,"admissionEvidence");function Qn(n,r){const c=On(n,r,ae,V(r,"at-classes","witness"));if(c.length){for(const i of c)o("error",`WIDER    ${t(i,"scope")} \xB7 ${t(i,"value")}
+`);return o("error",`${k()}: REFUSE\xB7widening nothing landed \xB7 a ceiling that admits more than it did gives back freedom the lock had spent: sign it under a witness that names what made the old ceiling wrong
+`),!0}return!1}F(Qn,"refusesWidening");function Me(n,r,c){if(Qn(r,c))return!0;const i=N(n),S=Kn(n,c,r);for(const m of S)o("error",`OUTSIDE  ${t(m,"scope")} \xB7 ${t(m,"value")}
+`);if(S.length)return o("error",`${k()}: REFUSE\xB7outside nothing landed \xB7 a reader or a capsule lands in the capsule of its world, never in the wire or the instrument
+`),!0;const y=Vn(i,r).filter(m=>zn(m.lines)||m.lines.filter(l=>r.includes(l)).length>1);if(y.length){for(const m of y){o("error",`FORK     ${m.key}
+`);for(const l of m.lines)o("error",`  ${r.includes(l)?"new ":"held"}  by=${t(l,"by")} ${Jn(l,C(i))}
+`)}return o("error",`${k()}: REFUSE\xB7fork nothing landed \xB7 one signer never forks itself, and one act never forks itself: withdraw the held side in this batch, or sign the other reading under its own scope
+`),!0}const w=Gn(n,r);if(w.length){for(const m of w)o("error",`ALIAS    ${m.scope} \xB7 ${m.digest} \xB7 ${m.by.join(" ")}
+`);return o("error",`${k()}: REFUSE\xB7alias nothing landed \xB7 an alias is withdrawn only when no pin names its digest
+`),!0}return!1}F(Me,"refusesAdmission");function We(n,r){try{return _n(n,r),!1}catch(c){return o("error",`${k()}: ${c instanceof Error?c.message:String(c)}
+`),!0}}F(We,"refusesStandingPins");async function Pe(n,r,c,i){const S=i?[[[],i.records]]:c.map(e=>[Ce(e),pe(e)]),y=S.flatMap(([,e])=>e);if(!y.length)return o("error",`${k()}: a batch is a file with claim lines
+`),{kind:"exit",code:2};const w=y.filter(e=>!t(e,"sig")),m=w.filter(e=>t(e,"epoch")||!["","target"].includes(t(e,"by")));if(m.length){for(const e of m)o("error",`BARE     ${t(e,"scope")} \xB7 by=${t(e,"by")||"\u2205"}${t(e,"epoch")?` epoch=${t(e,"epoch")}`:""}
+`);return o("error",`${k()}: REFUSE\xB7bare nothing landed \xB7 ${m.length} lines name a signer or an epoch they were not signed with: a drafted line proposes by=target and sign signs it, a line a lane signed carries its sig
+`),{kind:"exit",code:1}}const l=N(n),g=[...new Set([...ne(r),...S.flatMap(([e])=>e)])],f=z(l),d=g.filter(e=>!he(n).includes(e)&&!Bn(n,f,V(f,"families","region"),e));if(d.length)return o("error",`${k()}: REFUSE\xB7place nothing landed \xB7 ${d.join(", ")} is no place of the tree, and no line of the root founds it: --place names the own lock a line lands in
+`),{kind:"exit",code:2};const h=De(n,g),L={digest:Y(l,h),places:g},$=Ae(h)+1,x=y.filter(e=>t(e,"sig")).flatMap(e=>((p,b)=>b===void 0||!gn(e,b,I(l).admitted)?[`${t(e,"scope")} \xB7 the signature does not hold for ${p||"\u2205"}`]:[])(t(e,"by"),xe(n,t(e,"by"))));if(x.length){for(const e of x)o("error",`SIGNED   ${e}
+`);return o("error",`${k()}: REFUSE\xB7signed nothing landed \xB7 ${x.length} lines a lane signed stand at no epoch this act
+`),{kind:"exit",code:1}}const[s,T]=[ne(r),he(n)],M=new Set(C(l).map(D)),v=new Map(T.map(e=>[e,new Set($n(n,e).map(D))])),U=Z(C(l),ee(n),I(l).admitted),de=F(e=>!!t(e,"sig")&&U.of(e).kind==="admitted"&&mn(l,t(e,"by")).includes(e),"delivered"),te=F((e,p=s.length?s:S.flatMap(([b,j])=>j.includes(e)?b:[]))=>p.length?p.every(b=>v.get(b)?.has(D(e))):de(e)||M.has(D(e))||T.some(b=>v.get(b)?.has(D(e))),"held");if(y.every(e=>te(e))){if(y.some(e=>!q(e)))try{await le(n,[...J(l),...y])}catch(e){return o("error",`${k()}: ${String(e)} \xB7 nothing landed
+`),{kind:"exit",code:1}}return{kind:"once",proposed:y}}const K=y.filter(e=>t(e,"sig")&&q(e)&&Number(t(e,"epoch"))!==$);if(K.length){for(const e of K)o("error",`SIGNED   ${t(e,"scope")} \xB7 signed by ${t(e,"by")} at epoch ${t(e,"epoch")}, and this act lands at ${$}: sign it again
+`);return o("error",`${k()}: REFUSE\xB7signed nothing landed \xB7 ${K.length} lines a lane signed stand at no epoch this act
+`),{kind:"exit",code:1}}const re=i?void 0:X(r,Q.keyFile),A=i?.keyId??X(r,Q.key)??qn(l),G=w.length?xe(n,A):void 0;if(w.length&&!G)return o("error",`${k()}: unknown key ${A} \u2014 name it in ${k()}.keys
+`),{kind:"exit",code:2};let O=y.filter(e=>t(e,"sig"));if(i&&w.length){oe(i.signal);const e=Z(C(l),ee(n),I(l).admitted).admitted.find(p=>p.id===A);for(const p of w){const b=Se(p);if(b.kind!=="fact"||!e||He({...b.value.fields,by:A,epoch:String($)},e,$,t(p,"scope"),"authority").kind!=="admitted")throw new $e("host/receiver-authority","REFUSE\xB7host/receiver-authority")}}if(w.length){let e;try{e=wn([...z(l),...g.flatMap(j=>kn(n,j))],A,i?.signer.name??X(r,Q.signer),re,i?.signer)}catch(j){return o("error",`${k()}: ${j instanceof Error?j.message:"REFUSE\xB7signer unavailable"}
+`),{kind:"exit",code:1}}const p=await pn(w,{epoch:$,by:A,algorithm:I(l).era},G,I(l).admitted,e);if(p.kind==="refuse")return o("error",`${k()}: ${p.why}
+`),{kind:"exit",code:1};let b=0;O=y.map(j=>t(j,"sig")?j:p.lines[b++])}const W=[...J(l),...O].flatMap(e=>{const p=Se(e);return p.kind==="fact"?[p.value.fields]:[]});for(const e of O){const p=Ze(e,W,Number(t(e,"epoch")),Fe(J(l)).standing.filter(b=>t(b,"scope").startsWith("uses/")&&t(b,"value")!=="withdraw"));if(p.kind!=="fact")return o("error",`${k()}: REFUSE\xB7wire ${t(e,"scope")} \xB7 ${p.why} \xB7 nothing landed
+`),{kind:"exit",code:1}}if(We(n,O))return{kind:"exit",code:1};const P=Un(O);if(P.length){for(const e of P)o("error",`WITHDRAW ${D(e.withdraw)}
+`),o("error",`NEW      ${D(e.line)}
+`);return o("error",`${k()}: REFUSE\xB7withdraw nothing landed \xB7 a withdraw matches a new line in this batch, so it takes that line too
+`),{kind:"exit",code:1}}const a=Z([...C(l),...O],ee(n),I(l).admitted),E=Oe(n,O,e=>a.of(e).kind==="admitted",e=>a.admitted.find(p=>p.id===e)?.coverage??[],s,e=>{const p=S.flatMap(([b,j])=>j.some(B=>D(B)===D(e))?b:[]);return p.length?p:void 0});if(E.nowhere.length){for(const e of E.nowhere)o("error",`${k()}: REFUSE\xB7signer ${A} uncovered ${t(e,"scope")} \xB7 nothing signed for delivery
+`);return{kind:"exit",code:1}}if(E.forked.length){for(const e of E.forked)o("error",`FORKED   ${e.place}/${fe} \xB7 ${e.key} \xB7 the lot would leave two standing claims where the lock had one
+`);return o("error",`${k()}: REFUSE\xB7forked nothing landed \xB7 ${E.forked.length} claims an own lot would fork: a lot for many places lands the same lines at each, and lines meant for one place go in a lot of their own
+`),{kind:"exit",code:1}}if(Me(n,E.ledger,z(l)))return{kind:"exit",code:1};if(O.some(e=>!q(e)))try{await le(n,[...J(l),...O],e=>o("out",e+`
+`))}catch(e){return o("error",`${k()}: ${e instanceof Error?e.message:String(e)} \xB7 nothing landed
+`),{kind:"exit",code:1}}try{Ne(n,E.ledger,z(l))}catch(e){return o("error",`${k()}: ${e instanceof Error?e.message:String(e)} \xB7 nothing landed
+`),{kind:"exit",code:1}}return{kind:"signed",signed:O,epoch:$,base:L,...w.length?{keyId:A}:{}}}F(Pe,"signedBatch");async function er(n,r){const c=Date.now(),i=ge(r);if(i.length===1&&ze(n)&&!pe(i[0]).length){if(ne(r).length||X(r,Q.key)||X(r,Q.keyFile)||X(r,Q.signer))throw Error("REFUSE\xB7contextual place accepts one already signed context envelope");const m=await Ve(n,i[0]);return o("out",JSON.stringify({profile:"place-act-context@1",identity:m.identity,status:m.kind,context:m.context,receipts:m.receipts})+`
+`),0}const S=ne(r),y=ge(r).reduce((m,l)=>(g=>g.length?pe(l).reduce((f,d)=>f.set(D(d),[...new Set([...f.get(D(d))??[],...g])]),m):m)(Ce(l)),new Map),w=await Pe(n,r,ge(r));return Be(n,r,w,y,c)}F(er,"accept");async function nr(n,r){if(qe("Root lot admission"),oe(r.signal),!Re(z(N(n))))throw new $e("host/act","REFUSE\xB7Root host requires the admitted atomic result profile");const c=Date.now(),i=await Pe(n,[],[],r);return Be(n,[],i,new Map,c,r)}F(nr,"acceptRootRecords");async function Be(n,r,c,i,S,y){const w=ne(r);if(c.kind==="exit")return c.code;if(c.kind==="once")return Ln(N(n),"land",()=>Zn(n,c.proposed,S));const m=N(n),l=Z([...C(m),...c.signed],ee(n),I(m).admitted),g=Oe(n,c.signed,v=>l.of(v).kind==="admitted",v=>l.admitted.find(U=>U.id===v)?.coverage??[],w,v=>i.get(D(v)));if(g.nowhere.length){for(const v of g.nowhere)o("error",`NOWHERE  ${t(v,"scope")} \xB7 ${(U=>U.kind==="admitted"?"admitted":U.why)(l.of(v))}, and ${w.length?`no place of ${w.join(", ")} takes it`:"no one own lock it covers takes it: name the places with --place"}
+`);return o("error",`${k()}: REFUSE\xB7nowhere nothing landed \xB7 ${g.nowhere.length} lines neither the ledger nor an own lock admits: a line is landed signed where it stands, never written in bare
+`),1}const f=he(n),d=[...new Set([...g.own.keys(),...w])],h=d.length===0&&g.ledger.length?Mn(n,f,g.ledger,z(m)):[],L=d.length===0&&h.length===f.length&&f.length>0,$=(d.length?d:L?f:h).filter(v=>f.includes(v)),x=L?"every place \xB7 then the root, where the places join":$.length?$.map(v=>`${v}/`).join(" \xB7 "):"the root alone, where the places join";o("out",`ACTS     ${x} \xB7 ${g.ledger.length} lines to the ledger${[...g.own].map(([v,U])=>` \xB7 ${U.length} to ${v}'s own lock`).join("")} \xB7 before the lock
+`);const s=Date.now(),T=g.ledger.length>0||L||$.length===0;return(T?Tn:Cn)(m,T?[...$,""]:$,"land",()=>Yn(n,{...c,signed:g.ledger,records:c.signed},S,g,s,$,y))}F(Be,"finishAcceptance");async function Yn(n,r,c,i,S=c,y=[],w){const m=Date.now()-S;m>6e4&&o("out",`RED      wait ${Math.round(m/1e3)} s for the lock before the act \xB7 a wait over a minute is a red
+`);const l=[`sign ${S-c}`,`wait ${m}`],g=en(l),{signed:f,epoch:d}=r;if(We(n,r.records??f))return 1;const h=N(n),L=Y(h,De(n,r.base.places));if(L!==r.base.digest)return o("error",`${k()}: REFUSE\xB7base moved ${r.base.digest} \u2192 ${L} \xB7 nothing landed
+`),1;try{ke(n,f)}catch(a){return o("error",`${k()}: ${a instanceof Error?a.message:String(a)} \xB7 nothing landed
+`),1}if(f.some(a=>!q(a)))try{await le(n,[...J(h),...f])}catch(a){return o("error",`${k()}: ${a instanceof Error?a.message:String(a)} \xB7 nothing landed
+`),1}const $=g("lines",()=>ue(n));if(Me(n,f,$.standing))return 1;let x;try{x=g("evidence",()=>Ne(n,f,$.standing))}catch(a){return o("error",`${k()}: ${a instanceof Error?a.message:String(a)} \xB7 nothing landed
+`),1}const s=x.fold,T=g("authority",()=>Z([...C(h),...f],ee(n),I(h).admitted));for(const a of f){const E=T.of(a);if(E.kind!=="admitted")return o("error",`${k()}: ${E.kind==="refuse"?E.why:`REFUSE\xB7authority grey: ${E.why}`}
+`),1}const M=f.filter(a=>t(a,"value")==="withdraw"),v=x.coordinates,U=M.length?An(M,C(h)):null,de=`${V(s.standing,"families","view")}/`,te=Y(h,f),K=yn(h)?Y(h,[...bn(h)].sort(([a],[E])=>a.localeCompare(E)).map(([a,E])=>`${a} ${E}`)):"key"in s&&typeof s.key=="string"?s.key:Y(h,s.standing),re=nt(un(h,K,te)),A=re??x.judged;re||fn(h,K,te,A.map(et));const G=A.filter(a=>a.kind==="refused"||a.kind==="judged"&&a.verdict.kind==="refuse");if(G.length){for(const a of G)o("out",`REFUSE   take ${a.scope} \xB7 ${a.kind==="judged"?a.verdict.why:a.kind==="refused"?a.why:""}
+`);return o("error",`${k()}: REFUSE\xB7takes nothing landed \xB7 ${G.length} takes refused: a batch lands whole or not at all
+`),1}const O=g("told",()=>ue(n,void 0,f));for(const a of Nn(y,O.standing,f))o("error",`OPEN     ${a}
+`);i.own.size&&Pn(h,n,O.standing,h);const W=Re($.standing);let P=[];if(W){const a=r.records??f,E=[...f.length?[{place:".",records:f}]:[],...[...i.own].map(([u,R])=>({place:`${u}/${fe}`,records:R}))],p=cn(a,{...W,digest:F(u=>ve(h,new TextEncoder().encode(u)),"digest"),placements:E,localEpoch:d}),b=ie($.standing,"fold");if(!b)throw Error("REFUSE\xB7act native result requires a declared fold identity");const j=be({scope:W.scope,at:W.context,role:"writes",form:"alphabet",measure:"digest",value:p,by:b,epoch:String(d)}),B={records:a.join(`
+`)+`
+`,receipt:j+`
+`,placements:E.map(u=>({place:u.place,records:u.records.join(`
+`)+`
+`}))};oe(w?.signal),w?.prepared?.(p),oe(w?.signal);const _=await Je(h,p,y,async()=>B,Xe,w?.storage,w?.signal);w?.committed?.(p,_,_.kind),o("out",`ACT ${p} \xB7 epoch ${d} \xB7 admitted \xB7 conformance not asserted
+`);for(const u of a)o("out",u+`
+`);o("out",j+`
+`),P=[{at:"committed act "+p,appended:a.length}]}else P=g("land",()=>[...new Set(f.map(a=>t(a,"by")))].map(a=>se(h,a,f.filter(E=>t(E,"by")===a))));for(const[a,E]of i.own)Wn(n,a,E,W!==void 0);return In(h,"projection",async()=>{je(h,ie(O.standing,"fold"),[]);for(const u of f){const R=t(u,"value");if(/^[a-z0-9-]+:[0-9a-f]{32,}$/.test(R))for(const Ke of vn(t(u,"needs")).locations){const Ge=H(n,Ke),ce=Rn(Ge);ce!==void 0&&ve(h,ce)===R&&hn(h,R,ce)}}if(v.taken.length){for(const u of v.taken){ye(H(n,u))&&tn(H(n,u),{recursive:!0});for(let R=Ee(u);R!=="."&&ye(H(n,R))&&!Sn(H(n,R)).length;R=Ee(R))nn(H(n,R))}En(h,new Map,v.taken,`withdraw:epoch-${d}`);for(const u of v.taken)o("out",`GONE     ${u} \xB7 withdrawn by its line
+`)}for(const u of A)we(n,u,[]);const a=[...f,...s.standing].filter(u=>t(u,"role")==="demands"&&t(u,"value")!=="withdraw"),E=new Set(me(h,a,s.observed,de).paid.map(u=>t(u,"scope"))),e=Ue(h,[...f,...s.standing],E);if(e.length){se(h,"judge",e);for(const u of e)t(u,"measure")!=="cone"&&o("out",`LATE     ${t(u,"scope")} \xB7 answered from the landed cone
+`)}if(f.some(u=>t(u,"scope").startsWith(`${rn(jn())}/`)&&!t(u,"scope").split("/").slice(1,-1).includes("uses"))){const u=dn(h,Te(n),O.standing,n,xn());if(an(h)!==u){const R=await on(n,h);sn(h,u),o("error",`open by instrument \xB7 ${R.length}
+`)}}const p=g("render",()=>Le(n,h));o("out",`RENDER 0
+`);const b=new Set([...i.own.values()].flat()).size,j=Math.round((Date.now()-c)/Math.max(1,f.length+b)),B=ie(s.standing,"fold"),_=F((u,R)=>be({scope:"beat/accept",role:"writes",form:"interval",measure:"ms",value:`${u}..${u}`,by:B??"",at:`place:${R}`}),"beat");if(B!==void 0&&se(h,B,[_(j,"line"),_(1,s.kept?"kept":"folded"),_(Date.now()-c,"total")]),o("out",`FACT     signed ${f.length+b} \xB7 landed ${P.length?P.map(u=>`${u.appended} in ${u.at}`).join(" \xB7 "):"0"}${[...i.own].map(([u,R])=>` \xB7 ${R.length} in ${u}/${fe}`).join("")} \xB7 epoch ${d}
+TARGET   ${p.standing} claims \xB7 ${p.forks.length} forks \xB7 ${p.vacuous.length} vacuous \xB7 ${p.grey.length} grey \xB7 ${p.refused.length} refused \xB7 readings \xB7 no encounters computed \xB7 ${Date.now()-c} ms
+SPENT    ${l.join(" ms \xB7 ")} ms \xB7 ${f.length} lines
+`),U){o("out",`WITHDRAW ${U.taken.length} taken \xB7 ${U.exact.length} exact on distributive scales \xB7 ${U.open.length} on open scales, not computed
+`);for(const u of U.inexact)o("out",`INEXACT  ${t(u,"scope")} \xB7 its scale is not distributive: what the others hold is not what they held without it
+`)}return 0})}F(Yn,"acceptNow");function Zn(n,r,c){const i=N(n),S=Qe(i).find(s=>{const T=s.bundle.records.trimEnd().split(`
+`);return T.length===r.length&&T.every((M,v)=>M===r[v])});S&&o("out",`ACT ${S.identity} \xB7 epoch ${t(S.bundle.receipt.trim(),"epoch")} \xB7 admitted \xB7 replay
+`+S.bundle.records+S.bundle.receipt);const y=new Set(r.filter(s=>t(s,"role")==="demands").map(s=>t(s,"scope"))),w=`${V(Fe(J(i)).standing,"families","view")}/`,m=Xn(i).filter(s=>y.has(t(s,"scope"))&&!t(s,"scope").startsWith(w)),l=me(i,m,[],w).missing;if(!l.length)return o("out",`ONCE     ${r.length} lines \xB7 every one already landed and every demand of it paid: a batch landed twice is one, nothing landed
+`),0;const g=l.map(s=>Ie(n,s));if(o("out",`ONCE     ${r.length} lines \xB7 every one already landed \xB7 ${l.length} of its demands unpaid, judged again
+`),g.every(s=>s.kind==="owed")){for(const s of g)we(n,s,[]);return 0}const f=g.filter(s=>s.kind==="refused"||s.kind==="judged"&&s.verdict.kind==="refuse");if(f.length){for(const s of f)o("out",`REFUSE   take ${s.scope} \xB7 ${s.kind==="judged"?s.verdict.why:s.kind==="refused"?s.why:""}
+`);return o("error",`${k()}: REFUSE\xB7takes nothing landed \xB7 ${f.length} takes refused: what a batch left unpaid is paid whole or not at all
+`),1}const d=ue(n);for(const s of g)we(n,s,[]);je(i,ie(d.standing,"fold"),[]);const h=d.standing.filter(s=>t(s,"role")==="demands"&&t(s,"value")!=="withdraw"),L=new Set(me(i,h,[],`${V(d.standing,"families","view")}/`).paid.map(s=>t(s,"scope"))),$=Ue(i,d.standing,L);if($.length){se(i,"judge",$);for(const s of $)t(s,"measure")!=="cone"&&o("out",`LATE     ${t(s,"scope")} \xB7 answered from the landed cone
+`)}const x=Le(n,i);return o("out",`RENDER 0
+`),o("out",`TARGET   ${x.standing} claims \xB7 ${x.forks.length} forks \xB7 ${x.vacuous.length} vacuous \xB7 ${x.grey.length} grey \xB7 ${x.refused.length} refused \xB7 readings \xB7 no encounters computed \xB7 ${Date.now()-c} ms
+`),0}F(Zn,"repaid");function et(n){return n.kind==="judged"?{kind:n.kind,scope:n.scope,demand:n.demand,locations:n.locations,before:[...n.before],after:[...n.after],verdict:n.verdict,ignored:[...n.ignored]}:n}F(et,"packTake");function nt(n){if(n===void 0)return;const r=[];for(const c of n){if(c===null||typeof c!="object"||!("kind"in c)||!("scope"in c))return;const i=c;if(i.kind!=="judged"){r.push(i);continue}r.push({kind:"judged",scope:i.scope,demand:i.demand,locations:i.locations,before:new Map(i.before),after:new Map(i.after),verdict:i.verdict,ignored:new Map(i.ignored),started:Date.now()})}return r}F(nt,"keptTakes");export{er as accept,nr as acceptRootRecords,Pe as signedBatch};