@lapxo/bound 0.2.4 → 0.2.6

package/dist/cli/accept.js

@@ -1,590 +1,61 @@
-import { BoundRefusal } from "../host/refusals.js";
-import { assertHostNotCancelled as notCancelled } from "../host/host-controls.js";
-import { authorityAtEpoch } from '@lapxo/topos/wire';
-import { requireEffects } from "../host/read-only.js";
-import { hostOutput } from "../host/call-context.js";
-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)
-            hostOutput('error', `WIDER    ${fieldOf(line, 'scope')} · ${fieldOf(line, 'value')}\n`);
-        hostOutput('error', `${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)
-        hostOutput('error', `OUTSIDE  ${fieldOf(line, 'scope')} · ${fieldOf(line, 'value')}\n`);
-    if (outside.length) {
-        hostOutput('error', `${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) {
-            hostOutput('error', `FORK     ${fork.key}\n`);
-            for (const line of fork.lines)
-                hostOutput('error', `  ${signed.includes(line) ? 'new ' : 'held'}  by=${fieldOf(line, 'by')} ${sideOf(line, lockLines(store))}\n`);
-        }
-        hostOutput('error', `${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)
-            hostOutput('error', `ALIAS    ${one.scope} · ${one.digest} · ${one.by.join(' ')}\n`);
-        hostOutput('error', `${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) {
-        hostOutput('error', `${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, host) {
-    const byFile = host ? [[[], host.records]] : files.map((file) => [placesOfFile(file), claimLinesIn(file)]);
-    const proposed = byFile.flatMap(([, lines]) => lines);
-    if (!proposed.length) {
-        hostOutput('error', `${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)
-            hostOutput('error', `BARE     ${fieldOf(line, 'scope')} · by=${fieldOf(line, 'by') || '∅'}${fieldOf(line, 'epoch') ? ` epoch=${fieldOf(line, 'epoch')}` : ''}\n`);
-        hostOutput('error', `${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) {
-        hostOutput('error', `${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)
-            hostOutput('error', `SIGNED   ${one}\n`);
-        hostOutput('error', `${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) {
-                hostOutput('error', `${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)
-            hostOutput('error', `SIGNED   ${fieldOf(line, 'scope')} · signed by ${fieldOf(line, 'by')} at epoch ${fieldOf(line, 'epoch')}, and this act lands at ${epoch}: sign it again\n`);
-        hostOutput('error', `${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 = host ? undefined : valueOf(args, FLAGS.keyFile);
-    const keyId = host?.keyId ?? valueOf(args, FLAGS.key) ?? ownerOf(store);
-    const publicKey = drafted.length ? publicKeyOf(root, keyId) : undefined;
-    if (drafted.length && !publicKey) {
-        hostOutput('error', `${selfName()}: unknown key ${keyId} — name it in ${selfName()}.keys\n`);
-        return { kind: 'exit', code: 2 };
-    }
-    let signed = proposed.filter((line) => fieldOf(line, 'sig'));
-    if (host && drafted.length) {
-        notCancelled(host.signal);
-        const selected = authorityFor(lockLines(store), rootSigner(root), signaturesOf(store).admitted).admitted.find(s => s.id === keyId);
-        for (const line of drafted) {
-            const parsed = parse(line);
-            if (parsed.kind !== 'fact' || !selected || authorityAtEpoch({ ...parsed.value.fields, by: keyId, epoch: String(epoch) }, selected, epoch, fieldOf(line, 'scope'), 'authority').kind !== 'admitted')
-                throw new BoundRefusal('host/receiver-authority', 'REFUSE·host/receiver-authority');
-        }
-    }
-    if (drafted.length) {
-        let invoke;
-        try {
-            invoke = signerFor([...lockStanding(store), ...destinations.flatMap(place => ownLockOf(root, place))], keyId, host?.signer.name ?? valueOf(args, FLAGS.signer), keyFile, host?.signer);
-        }
-        catch (error) {
-            hostOutput('error', `${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') {
-            hostOutput('error', `${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') {
-            hostOutput('error', `${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) {
-            hostOutput('error', `WITHDRAW ${sayingOf(pair.withdraw)}\n`);
-            hostOutput('error', `NEW      ${sayingOf(pair.line)}\n`);
-        }
-        hostOutput('error', `${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)
-            hostOutput('error', `${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)
-            hostOutput('error', `FORKED   ${one.place}/${LOCK} · ${one.key} · the lot would leave two standing claims where the lock had one\n`);
-        hostOutput('error', `${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 => hostOutput('out', text + '\n'));
-        }
-        catch (e) {
-            hostOutput('error', `${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) {
-        hostOutput('error', `${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]);
-        hostOutput('out', 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));
-    return finishAcceptance(root, args, batch, placed, started);
-}
-/** Root host boundary, sharing signing, wire, coverage, takes and publication
- * with accept(). No file is manufactured for a batch of already-owned bytes. */
-export async function acceptRootRecords(root, host) {
-    requireEffects('Root lot admission');
-    notCancelled(host.signal);
-    if (!actResultProfile(lockStanding(storeOf(root))))
-        throw new BoundRefusal('host/act', 'REFUSE·Root host requires the admitted atomic result profile');
-    const started = Date.now(), batch = await signedBatch(root, [], [], host);
-    return finishAcceptance(root, [], batch, new Map(), started, host);
-}
-async function finishAcceptance(root, args, batch, placed, started, host) {
-    const named = namedPlaces(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)
-            hostOutput('error', `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`);
-        hostOutput('error', `${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';
-    hostOutput('out', `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, host));
-}
-async function acceptNow(root, batch, started, owned, asked = started, descent = [], host) {
-    const waited = Date.now() - asked;
-    if (waited > 60000)
-        hostOutput('out', `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) {
-        hostOutput('error', `${selfName()}: REFUSE·base moved ${batch.base.digest} → ${currentBase} · nothing landed\n`);
-        return 1;
-    }
-    try {
-        assertProspectiveRootClockSelection(root, signed);
-    }
-    catch (error) {
-        hostOutput('error', `${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) {
-            hostOutput('error', `${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) {
-        hostOutput('error', `${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') {
-            hostOutput('error', `${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)
-            hostOutput('out', `REFUSE   take ${one.scope} · ${one.kind === 'judged' ? one.verdict.why : one.kind === 'refused' ? one.why : ''}\n`);
-        hostOutput('error', `${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))
-        hostOutput('error', `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' })) };
-        notCancelled(host?.signal);
-        host?.prepared?.(identity);
-        notCancelled(host?.signal);
-        const committed = await commitLocalAct(store, identity, descent, async () => bundle, intactLocalAct, host?.storage, host?.signal);
-        host?.committed?.(identity, committed, committed.kind);
-        // Commitment precedes projections and conformance work. If either fails,
-        // this public identity still names the admitted act; it is never rollback.
-        hostOutput('out', `ACT ${identity} · epoch ${epoch} · admitted · conformance not asserted\n`);
-        for (const line of records)
-            hostOutput('out', line + '\n');
-        hostOutput('out', 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)
-                hostOutput('out', `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')
-                    hostOutput('out', `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);
-                hostOutput('error', `open by instrument · ${open.length}\n`);
-            }
-        }
-        const rendered = took('render', () => renderInto(root, store));
-        hostOutput('out', `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')]);
-        hostOutput('out', `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) {
-            hostOutput('out', `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)
-                hostOutput('out', `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) {
-        hostOutput('out', `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) {
-        hostOutput('out', `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));
-    hostOutput('out', `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)
-            hostOutput('out', `REFUSE   take ${one.scope} · ${one.kind === 'judged' ? one.verdict.why : one.kind === 'refused' ? one.why : ''}\n`);
-        hostOutput('error', `${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')
-                hostOutput('out', `LATE     ${fieldOf(line, 'scope')} · answered from the landed cone\n`);
-    }
-    const rendered = renderInto(root, store);
-    hostOutput('out', `RENDER 0\n`);
-    hostOutput('out', `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 ze=Object.defineProperty;var S=(n,t)=>ze(n,"name",{value:t,configurable:!0});import{readingWitnessAdmission as He}from"../host/native/reading-witness-admission.js";import{BoundRefusal as I}from"../host/refusals.js";import{assertHostNotCancelled as de}from"../host/host-controls.js";import{library14_authorityAtEpoch as Ve}from"../vendor/runtime.js";import{requireEffects as Je}from"../host/read-only.js";import{hostOutput as s}from"../host/call-context.js";import{assertProspectiveRootClockSelection as ye}from"../host/root-clock-source.js";import{hasContextualPlace as Xe,landContextualPlace as Qe}from"../host/contextual-place.js";import{commitLocalAct as Ye,intactLocalAct as Ze,committedLocalActs as en}from"../host/ports/local-act.js";import{withoutEffects as nn}from"../host/read-only.js";import{admittedLine as tn}from"../host/selected-topos.js";import{timing as rn}from"../host/timing.js";import{admittedObjects as ue}from"../host/objects.js";import{existsSync as ve,rmdirSync as on,rmSync as sn}from"node:fs";import{dirname as Ee,join as H,basename as dn}from"node:path";import{closeReceipts as an,instrumentKeep as cn,instrumentKept as ln}from"../fold/closed.js";import{bytesDigest as be,fullDigest as Z,instrumentOf as fn,signaturesOf as N}from"../fold/digests.js";import{library14_canonical as Se,library14_LOCK as Re,library14_parse as xe,library14_actIdentity as un,library14_actResultProfile as Fe}from"../vendor/runtime.js";import{fieldOf as o,isConfig as V,foldClaims as je,sayingOf as C,selfName as y}from"../fold/claims.js";import{isReaderLock as mn}from"../fold/observed.js";import{authorityFor as ee,publicKeyOf as Oe,rootSigner as ne,writerFor as ae}from"../fold/signers.js";import{lockLines as M,lockStanding as G}from"../fold/keys.js";import{keepVerdict as hn,keptVerdict as gn,land as ce,landBlob as pn,ledgerLines as wn,storeOf as L}from"../land/ledger.js";import{signConsentLot as kn,verifiesOwnerLine as $n}from"../land/sign.js";import{signerFor as yn}from"../host/signing.js";import{appliedIn as vn,ownLockOf as En,withOwnPreview as bn}from"../fold/signed.js";import{wordOf as J}from"../fold/wire.js";import{hasVouchedTree as Sn,landCoordinates as Rn,locationsOf as xn,vouchedCoordinates as Fn}from"../land/vouched.js";import{entriesIn as jn,observeFile as On}from"../observe/files.js";import{coneOf as An,standingOf as me}from"./place.js";import{ownLock as Cn,ownRoot as Dn}from"../observe/runner.js";import{widenedWithoutWitness as Un}from"../judge/widening.js";import{retractedTogether as Ln,withdrawal as Tn}from"../land/withdraw.js";import{isCeiling as le}from"../fold/configures.js";import{inertIn as In}from"../land/inert.js";import{landSaid as Ae}from"./pass.js";import{currentActSignal as he,underTheLock as Nn,underTheRegions as Mn,underAuthorityRegions as Pn,underRootProjection as Wn,underRootAuthority as Bn}from"../land/act.js";import{openedBy as Gn}from"../fold/opened.js";import{touchedBy as Kn}from"../fold/reach.js";import{landOwned as _n,ownedOf as Ce}from"../land/owned.js";import{layReleases as qn}from"../host/release.js";import{foundableIn as zn,placesIn as ge}from"../fold/places.js";import{outsideTheirCapsule as Hn}from"../fold/own.js";import{lateFacts as De}from"../judge/late.js";import{paidOf as pe}from"../fold/paid.js";import{aliasPinned as Vn}from"../land/alias.js";import{admitStandingPins as Ue}from"../land/standing-pin.js";import{coordinatesWithdrawn as Jn}from"../land/leaving.js";import{ownerOf as Xn,epochOf as Le,localActLines as Te,forksItself as Qn,forksJoinedBy as Yn,renderInto as Ie,signedDemands as Zn,signedOwnerLines as te}from"./owner.js";import{claimLinesIn as we,entryOf as Ne,namedPlaces as ie,placesOfFile as Me,positionalsOf as ke,valueOf as X}from"./args.js";import{FLAGS as Q}from"./names.js";import{judgeDemand as Pe,landTake as $e}from"./takes.js";function et(n,t,d,r){if(!Number.isSafeInteger(r))throw new I("admission/clock","REFUSE\xB7admission clock is required");return nn(()=>{const m=L(n);ye(n,t);const p=!t.some(mn)&&t.some(le),u=p?An(n,Ne(n),t.filter(le)):{standing:d,observed:[],own:{},kept:!0};if(In(t,{standing:u.standing,ceiling:le,signsReader:!p,observed:u.observed,own:u.own,epoch:Le([...M(m),...t])}).length)throw new I("admission/inert","REFUSE\xB7inert no existing reading meets these ceilings; fold the declared inputs first");const f=Jn(n,m,t,[...t,...d]);if(f.refused.length)throw new I("admission/withdraw",`REFUSE\xB7withdraw a file is still read: ${f.refused.map(i=>`${i.path} by ${i.by}`).join(" \xB7 ")}`);const h=`${J(G(m),"families","view")}/`,a=t.filter(i=>V(i)&&o(i,"role")==="demands"&&o(i,"value")!=="withdraw"&&!o(i,"scope").startsWith(h)).map(i=>{const j=o(i,"scope");return d.some(E=>V(E)&&o(E,"role")==="demands"&&o(E,"value")!=="withdraw"&&o(E,"scope")===j&&o(E,"form")===o(i,"form")&&o(E,"measure")===o(i,"measure"))?Pe(n,i,{now:r}):{kind:"owed",scope:j,why:"new demand declared; no conformance reading is claimed"}}),g=a.filter(i=>i.kind==="refused"||i.kind==="judged"&&i.verdict.kind==="refuse");if(g.length)throw new I("admission/takes",`REFUSE\xB7takes ${g.map(i=>`${i.scope}: ${i.kind==="judged"?i.verdict.why:i.kind==="refused"?i.why:""}`).join(" \xB7 ")}`);return{coordinates:f,judged:a,fold:u}})}S(et,"admissionEvidence");function We(n,t,d,r){try{return{kind:"fact",evidence:et(n,t,d,r)}}catch(m){return{kind:"refuse",code:m instanceof I?m.code:"admission/evidence",diagnostic:m instanceof Error?m.message:String(m)}}}S(We,"admissionEvidenceResult");function nt(n,t,d){return n.every(d)?[]:n.filter(r=>o(r,"sig")&&V(r)&&Number(o(r,"epoch"))!==t)}S(nt,"configurationEpochCheck");function tt(n,t,d=[],r){const m=L(n),p=te(m),u=je(p).standing,k=[...p,...t].flatMap(g=>{const i=xe(g);return i.kind==="fact"?[i.value.fields]:[]});for(const g of t){const i=tn(g,k,Number(o(g,"epoch")),u.filter(j=>o(j,"scope").startsWith("uses/")&&o(j,"value")!=="withdraw"));if(i.kind!=="fact")return{kind:"refuse",code:"wire",evidence:[g,i],diagnostic:i.why}}try{Ue(n,t)}catch(g){return{kind:"refuse",code:"standing-pin",evidence:t,diagnostic:g instanceof Error?g.message:String(g)}}const f=Ln(t);if(f.length)return{kind:"refuse",code:"withdraw",evidence:f,diagnostic:"a withdrawal takes a new line in the same batch"};const h=ee([...M(m),...t],ne(n),N(m).admitted),a=bn(n,()=>Ce(n,t,g=>h.of(g).kind==="admitted",g=>h.admitted.find(i=>i.id===g)?.coverage??[],d,r));return a.nowhere.length?{kind:"refuse",code:"signer",evidence:a.nowhere,diagnostic:"the requested records are not covered at their selected destination"}:a.forked.length?{kind:"refuse",code:"forked",evidence:a.forked,diagnostic:"the lot would fork a selected own lock"}:{kind:"fact",ownership:a}}S(tt,"configurationAdmissionGuards");function it(n,t,d,r=d,m="."){const p=He(n,t,d,r,m);if(p.kind==="ask")return p;if(p.kind==="refuse")return{kind:"refuse",code:p.code,evidence:p.evidence,diagnostic:p.why};const u=Un(t,d,le,J(r,"at-classes","witness"));return u.length?{kind:"ask",code:"widening",evidence:u,needs:u.map(k=>"witness:"+o(k,"scope"))}:{kind:"fact",evidence:p.evidence}}S(it,"admissionWideningChecks");function rt(n,t,d){const r=it(n,t,d);if(r.kind!=="fact")return r;const m=L(n),p=Hn(n,d,t);if(p.length)return{kind:"refuse",code:"outside",evidence:p,diagnostic:"a reader or capsule lands in its own world"};const u=Yn(m,t).filter(f=>Qn(f.lines)||f.lines.filter(h=>t.includes(h)).length>1);if(u.length)return{kind:"refuse",code:"fork",evidence:u,diagnostic:"one signer and one act cannot fork themselves"};const k=Vn(n,t);return k.length?{kind:"refuse",code:"alias",evidence:k,diagnostic:"an alias is still named by a pin"}:{kind:"fact",evidence:r.evidence}}S(rt,"admissionChecks");function Be(n,t,d){const r=rt(n,t,d);if(r.kind==="fact")return!1;if(r.kind==="ask"&&r.code==="reading-witness")s("error",`${y()}: REFUSE\xB7reading-witness ${r.needs.join(" \xB7 ")} \xB7 nothing landed
+`);else if(r.kind==="ask"){for(const m of r.evidence)s("error",`WIDER    ${o(m,"scope")} \xB7 ${o(m,"value")}
+`);s("error",`${y()}: 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
+`)}else s("error",`${y()}: REFUSE\xB7${r.code} nothing landed \xB7 ${r.diagnostic}
+`);return!0}S(Be,"refusesAdmission");function ot(n,t){try{return Ue(n,t),!1}catch(d){return s("error",`${y()}: ${d instanceof Error?d.message:String(d)}
+`),!0}}S(ot,"refusesStandingPins");async function Ge(n,t,d,r){const m=r?[[[],r.records]]:d.map(e=>[Me(e),we(e)]),p=m.flatMap(([,e])=>e);if(!p.length)return s("error",`${y()}: a batch is a file with claim lines
+`),{kind:"exit",code:2};const u=p.filter(e=>!o(e,"sig")),k=u.filter(e=>o(e,"epoch")||!["","target"].includes(o(e,"by")));if(k.length){for(const e of k)s("error",`BARE     ${o(e,"scope")} \xB7 by=${o(e,"by")||"\u2205"}${o(e,"epoch")?` epoch=${o(e,"epoch")}`:""}
+`);return s("error",`${y()}: REFUSE\xB7bare nothing landed \xB7 ${k.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 f=L(n),h=[...new Set([...ie(t),...m.flatMap(([e])=>e)])],a=G(f),g=h.filter(e=>!ge(n).includes(e)&&!zn(n,a,J(a,"families","region"),e));if(g.length)return s("error",`${y()}: REFUSE\xB7place nothing landed \xB7 ${g.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 i=Te(n,h),j={digest:Z(f,i),places:h},v=Le(i)+1,E=p.filter(e=>o(e,"sig")).flatMap(e=>((w,R)=>R===void 0||!$n(e,R,N(f).admitted)?[`${o(e,"scope")} \xB7 the signature does not hold for ${w||"\u2205"}`]:[])(o(e,"by"),Oe(n,o(e,"by"))));if(E.length){for(const e of E)s("error",`SIGNED   ${e}
+`);return s("error",`${y()}: REFUSE\xB7signed nothing landed \xB7 ${E.length} lines a lane signed stand at no epoch this act
+`),{kind:"exit",code:1}}const[c,x]=[ie(t),ge(n)],K=new Set(M(f).map(C)),b=new Map(x.map(e=>[e,new Set(vn(n,e).map(C))])),O=ee(M(f),ne(n),N(f).admitted),P=S(e=>!!o(e,"sig")&&O.of(e).kind==="admitted"&&wn(f,o(e,"by")).includes(e),"delivered"),re=S((e,w=c.length?c:m.flatMap(([R,$])=>$.includes(e)?R:[]))=>w.length?w.every(R=>b.get(R)?.has(C(e))):P(e)||K.has(C(e))||x.some(R=>b.get(R)?.has(C(e))),"held");if(p.every(e=>re(e))){if(p.some(e=>!V(e)))try{await ue(n,[...te(f),...p])}catch(e){return s("error",`${y()}: ${String(e)} \xB7 nothing landed
+`),{kind:"exit",code:1}}return{kind:"once",proposed:p}}const _=nt(p,v,re);if(_.length){for(const e of _)s("error",`SIGNED   ${o(e,"scope")} \xB7 signed by ${o(e,"by")} at epoch ${o(e,"epoch")}, and this act lands at ${v}: sign it again
+`);return s("error",`${y()}: REFUSE\xB7signed nothing landed \xB7 ${_.length} lines a lane signed stand at no epoch this act
+`),{kind:"exit",code:1}}const oe=r?void 0:X(t,Q.keyFile),A=r?.keyId??X(t,Q.key)??Xn(f),q=u.length?Oe(n,A):void 0;if(u.length&&!q)return s("error",`${y()}: unknown key ${A} \u2014 name it in ${y()}.keys
+`),{kind:"exit",code:2};let D=p.filter(e=>o(e,"sig"));if(r&&u.length){de(r.signal);const e=ee(M(f),ne(n),N(f).admitted).admitted.find(w=>w.id===A);for(const w of u){const R=xe(w);if(R.kind!=="fact"||!e||Ve({...R.value.fields,by:A,epoch:String(v)},e,v,o(w,"scope"),"authority").kind!=="admitted")throw new I("host/receiver-authority","REFUSE\xB7host/receiver-authority")}}if(u.length){let e;try{e=yn([...G(f),...h.flatMap($=>En(n,$))],A,r?.signer.name??X(t,Q.signer),oe,r?.signer)}catch($){if($ instanceof I)throw $;return s("error",`${y()}: ${$ instanceof Error?$.message:"REFUSE\xB7signer unavailable"}
+`),{kind:"exit",code:1}}const w=await kn(u,{epoch:v,by:A,algorithm:N(f).era},q,N(f).admitted,e);if(w.kind==="refuse")return s("error",`${y()}: ${w.why}
+`),{kind:"exit",code:1};let R=0;D=p.map($=>o($,"sig")?$:w.lines[R++])}const U=tt(n,D,c,e=>{const w=m.flatMap(([R,$])=>$.some(B=>C(B)===C(e))?R:[]);return w.length?w:void 0});if(U.kind==="refuse")return s("error",`${y()}: REFUSE\xB7${U.code} ${U.diagnostic} \xB7 nothing landed
+`),{kind:"exit",code:1};const T=U.ownership;if(Be(n,T.ledger,G(f)))return{kind:"exit",code:1};if(D.some(e=>!V(e)))try{await ue(n,[...te(f),...D],e=>s("out",e+`
+`))}catch(e){return s("error",`${y()}: ${e instanceof Error?e.message:String(e)} \xB7 nothing landed
+`),{kind:"exit",code:1}}const W=await Bn(f,"prospective admission evidence",()=>We(n,T.ledger,G(f),Date.now()));return W.kind==="refuse"?(s("error",`${y()}: ${W.diagnostic} \xB7 nothing landed
+`),{kind:"exit",code:1}):{kind:"signed",signed:D,epoch:v,base:j,...u.length?{keyId:A}:{}}}S(Ge,"signedBatch");async function ci(n,t){const d=Date.now(),r=ke(t);if(r.length===1&&Xe(n)&&!we(r[0]).length){if(ie(t).length||X(t,Q.key)||X(t,Q.keyFile)||X(t,Q.signer))throw Error("REFUSE\xB7contextual place accepts one already signed context envelope");const k=await Qe(n,r[0]);return s("out",JSON.stringify({profile:"place-act-context@1",identity:k.identity,status:k.kind,context:k.context,receipts:k.receipts})+`
+`),0}const m=ie(t),p=ke(t).reduce((k,f)=>(h=>h.length?we(f).reduce((a,g)=>a.set(C(g),[...new Set([...a.get(C(g))??[],...h])]),k):k)(Me(f)),new Map),u=await Ge(n,t,ke(t));return Ke(n,t,u,p,d)}S(ci,"accept");async function li(n,t){if(Je("Root lot admission"),de(t.signal),!Fe(G(L(n))))throw new I("host/act","REFUSE\xB7Root host requires the admitted atomic result profile");const d=Date.now(),r=await Ge(n,[],[],t);return Ke(n,[],r,new Map,d,t)}S(li,"acceptRootRecords");async function Ke(n,t,d,r,m,p){const u=ie(t);if(d.kind==="exit")return d.code;if(d.kind==="once")return Nn(L(n),"land",()=>dt(n,d.proposed,m));const k=L(n),f=ee([...M(k),...d.signed],ne(n),N(k).admitted),h=Ce(n,d.signed,b=>f.of(b).kind==="admitted",b=>f.admitted.find(O=>O.id===b)?.coverage??[],u,b=>r.get(C(b)));if(h.nowhere.length){for(const b of h.nowhere)s("error",`NOWHERE  ${o(b,"scope")} \xB7 ${(O=>O.kind==="admitted"?"admitted":O.why)(f.of(b))}, and ${u.length?`no place of ${u.join(", ")} takes it`:"no one own lock it covers takes it: name the places with --place"}
+`);return s("error",`${y()}: REFUSE\xB7nowhere nothing landed \xB7 ${h.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 a=ge(n),g=[...new Set([...h.own.keys(),...u])],i=g.length===0&&h.ledger.length?Kn(n,a,h.ledger,G(k)):[],j=g.length===0&&i.length===a.length&&a.length>0,v=(g.length?g:j?a:i).filter(b=>a.includes(b)),E=j?"every place \xB7 then the root, where the places join":v.length?v.map(b=>`${b}/`).join(" \xB7 "):"the root alone, where the places join";s("out",`ACTS     ${E} \xB7 ${h.ledger.length} lines to the ledger${[...h.own].map(([b,O])=>` \xB7 ${O.length} to ${b}'s own lock`).join("")} \xB7 before the lock
+`);const c=Date.now(),x=h.ledger.length>0||j||v.length===0;return(x?Mn:Pn)(k,x?[...v,""]:v,"land",()=>st(n,{...d,signed:h.ledger,records:d.signed},m,h,c,v,p))}S(Ke,"finishAcceptance");async function st(n,t,d,r,m=d,p=[],u){const k=Date.now()-m;k>6e4&&s("out",`RED      wait ${Math.round(k/1e3)} s for the lock before the act \xB7 a wait over a minute is a red
+`);const f=[`sign ${m-d}`,`wait ${k}`],h=rn(f),{signed:a,epoch:g}=t;if(ot(n,t.records??a))return 1;const i=L(n),j=Z(i,Te(n,t.base.places));if(j!==t.base.digest)return s("error",`${y()}: REFUSE\xB7base moved ${t.base.digest} \u2192 ${j} \xB7 nothing landed
+`),1;try{ye(n,a)}catch(e){return s("error",`${y()}: ${e instanceof Error?e.message:String(e)} \xB7 nothing landed
+`),1}if(a.some(e=>!V(e)))try{await ue(n,[...te(i),...a])}catch(e){return s("error",`${y()}: ${e instanceof Error?e.message:String(e)} \xB7 nothing landed
+`),1}const v=h("lines",()=>me(n));if(Be(n,a,v.standing))return 1;let E;const c=h("evidence",()=>We(n,a,v.standing,Date.now()));if(c.kind==="refuse")return s("error",`${y()}: ${c.diagnostic} \xB7 nothing landed
+`),1;E=c.evidence;const x=E.fold,K=h("authority",()=>ee([...M(i),...a],ne(n),N(i).admitted));for(const e of a){const w=K.of(e);if(w.kind!=="admitted")return s("error",`${y()}: ${w.kind==="refuse"?w.why:`REFUSE\xB7authority grey: ${w.why}`}
+`),1}const b=a.filter(e=>o(e,"value")==="withdraw"),O=E.coordinates,P=b.length?Tn(b,M(i)):null,re=`${J(x.standing,"families","view")}/`,_=Z(i,a),oe=Sn(i)?Z(i,[...Fn(i)].sort(([e],[w])=>e.localeCompare(w)).map(([e,w])=>`${e} ${w}`)):"key"in x&&typeof x.key=="string"?x.key:Z(i,x.standing),A=ct(gn(i,oe,_)),q=A??E.judged;A||hn(i,oe,_,q.map(at));const D=q.filter(e=>e.kind==="refused"||e.kind==="judged"&&e.verdict.kind==="refuse");if(D.length){for(const e of D)s("out",`REFUSE   take ${e.scope} \xB7 ${e.kind==="judged"?e.verdict.why:e.kind==="refused"?e.why:""}
+`);return s("error",`${y()}: REFUSE\xB7takes nothing landed \xB7 ${D.length} takes refused: a batch lands whole or not at all
+`),1}const U=h("told",()=>me(n,void 0,a));for(const e of Gn(p,U.standing,a))s("error",`OPEN     ${e}
+`);r.own.size&&qn(i,n,U.standing,i);const T=Fe(v.standing);let W=[];if(T){const e=t.records??a,w=[...a.length?[{place:".",records:a}]:[],...[...r.own].map(([l,F])=>({place:`${l}/${Re}`,records:F}))],$=un(e,{...T,digest:S(l=>be(i,new TextEncoder().encode(l)),"digest"),placements:w,localEpoch:g}),B=ae(v.standing,"fold");if(!B)throw Error("REFUSE\xB7act native result requires a declared fold identity");const se=Se({scope:T.scope,at:T.context,role:"writes",form:"alphabet",measure:"digest",value:$,by:B,epoch:String(g)}),Y={records:e.join(`
+`)+`
+`,receipt:se+`
+`,placements:w.map(l=>({place:l.place,records:l.records.join(`
+`)+`
+`}))};de(u?.signal??he()),u?.prepared?.($),de(u?.signal??he());const z=await Ye(i,$,p,async()=>Y,Ze,u?.storage,u?.signal??he());u?.committed?.($,z,z.kind),s("out",`ACT ${$} \xB7 epoch ${g} \xB7 admitted \xB7 conformance not asserted
+`);for(const l of e)s("out",l+`
+`);s("out",se+`
+`),W=[{at:"committed act "+$,appended:e.length}]}else W=h("land",()=>[...new Set(a.map(e=>o(e,"by")))].map(e=>ce(i,e,a.filter(w=>o(w,"by")===e))));for(const[e,w]of r.own)_n(n,e,w,T!==void 0);return Wn(i,"projection",async()=>{Ae(i,ae(U.standing,"fold"),[]);for(const l of a){const F=o(l,"value");if(/^[a-z0-9-]+:[0-9a-f]{32,}$/.test(F))for(const _e of xn(o(l,"needs")).locations){const qe=H(n,_e),fe=On(qe);fe!==void 0&&be(i,fe)===F&&pn(i,F,fe)}}if(O.taken.length){for(const l of O.taken){ve(H(n,l))&&sn(H(n,l),{recursive:!0});for(let F=Ee(l);F!=="."&&ve(H(n,F))&&!jn(H(n,F)).length;F=Ee(F))on(H(n,F))}Rn(i,new Map,O.taken,`withdraw:epoch-${g}`);for(const l of O.taken)s("out",`GONE     ${l} \xB7 withdrawn by its line
+`)}for(const l of q)$e(n,l,[]);const e=[...a,...x.standing].filter(l=>o(l,"role")==="demands"&&o(l,"value")!=="withdraw"),w=new Set(pe(i,e,x.observed,re).paid.map(l=>o(l,"scope"))),R=De(i,[...a,...x.standing],w);if(R.length){ce(i,"judge",R);for(const l of R)o(l,"measure")!=="cone"&&s("out",`LATE     ${o(l,"scope")} \xB7 answered from the landed cone
+`)}if(a.some(l=>o(l,"scope").startsWith(`${dn(Dn())}/`)&&!o(l,"scope").split("/").slice(1,-1).includes("uses"))){const l=fn(i,Ne(n),U.standing,n,Cn());if(ln(i)!==l){const F=await an(n,i);cn(i,l),s("error",`open by instrument \xB7 ${F.length}
+`)}}const $=h("render",()=>Ie(n,i));s("out",`RENDER 0
+`);const B=new Set([...r.own.values()].flat()).size,se=Math.round((Date.now()-d)/Math.max(1,a.length+B)),Y=ae(x.standing,"fold"),z=S((l,F)=>Se({scope:"beat/accept",role:"writes",form:"interval",measure:"ms",value:`${l}..${l}`,by:Y??"",at:`place:${F}`}),"beat");if(Y!==void 0&&ce(i,Y,[z(se,"line"),z(1,x.kept?"kept":"folded"),z(Date.now()-d,"total")]),s("out",`FACT     signed ${a.length+B} \xB7 landed ${W.length?W.map(l=>`${l.appended} in ${l.at}`).join(" \xB7 "):"0"}${[...r.own].map(([l,F])=>` \xB7 ${F.length} in ${l}/${Re}`).join("")} \xB7 epoch ${g}
+TARGET   ${$.standing} claims \xB7 ${$.forks.length} forks \xB7 ${$.vacuous.length} vacuous \xB7 ${$.grey.length} grey \xB7 ${$.refused.length} refused \xB7 readings \xB7 no encounters computed \xB7 ${Date.now()-d} ms
+SPENT    ${f.join(" ms \xB7 ")} ms \xB7 ${a.length} lines
+`),P){s("out",`WITHDRAW ${P.taken.length} taken \xB7 ${P.exact.length} exact on distributive scales \xB7 ${P.open.length} on open scales, not computed
+`);for(const l of P.inexact)s("out",`INEXACT  ${o(l,"scope")} \xB7 its scale is not distributive: what the others hold is not what they held without it
+`)}return 0})}S(st,"acceptNow");function dt(n,t,d){const r=L(n),m=en(r).find(c=>{const x=c.bundle.records.trimEnd().split(`
+`);return x.length===t.length&&x.every((K,b)=>K===t[b])});m&&s("out",`ACT ${m.identity} \xB7 epoch ${o(m.bundle.receipt.trim(),"epoch")} \xB7 admitted \xB7 replay
+`+m.bundle.records+m.bundle.receipt);const p=new Set(t.filter(c=>o(c,"role")==="demands").map(c=>o(c,"scope"))),u=`${J(je(te(r)).standing,"families","view")}/`,k=Zn(r).filter(c=>p.has(o(c,"scope"))&&!o(c,"scope").startsWith(u)),f=pe(r,k,[],u).missing;if(!f.length)return s("out",`ONCE     ${t.length} lines \xB7 every one already landed and every demand of it paid: a batch landed twice is one, nothing landed
+`),0;const h=f.map(c=>Pe(n,c));if(s("out",`ONCE     ${t.length} lines \xB7 every one already landed \xB7 ${f.length} of its demands unpaid, judged again
+`),h.every(c=>c.kind==="owed")){for(const c of h)$e(n,c,[]);return 0}const a=h.filter(c=>c.kind==="refused"||c.kind==="judged"&&c.verdict.kind==="refuse");if(a.length){for(const c of a)s("out",`REFUSE   take ${c.scope} \xB7 ${c.kind==="judged"?c.verdict.why:c.kind==="refused"?c.why:""}
+`);return s("error",`${y()}: REFUSE\xB7takes nothing landed \xB7 ${a.length} takes refused: what a batch left unpaid is paid whole or not at all
+`),1}const g=me(n);for(const c of h)$e(n,c,[]);Ae(r,ae(g.standing,"fold"),[]);const i=g.standing.filter(c=>o(c,"role")==="demands"&&o(c,"value")!=="withdraw"),j=new Set(pe(r,i,[],`${J(g.standing,"families","view")}/`).paid.map(c=>o(c,"scope"))),v=De(r,g.standing,j);if(v.length){ce(r,"judge",v);for(const c of v)o(c,"measure")!=="cone"&&s("out",`LATE     ${o(c,"scope")} \xB7 answered from the landed cone
+`)}const E=Ie(n,r);return s("out",`RENDER 0
+`),s("out",`TARGET   ${E.standing} claims \xB7 ${E.forks.length} forks \xB7 ${E.vacuous.length} vacuous \xB7 ${E.grey.length} grey \xB7 ${E.refused.length} refused \xB7 readings \xB7 no encounters computed \xB7 ${Date.now()-d} ms
+`),0}S(dt,"repaid");function at(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}S(at,"packTake");function ct(n){if(n===void 0)return;const t=[];for(const d of n){if(d===null||typeof d!="object"||!("kind"in d)||!("scope"in d))return;const r=d;if(r.kind!=="judged"){t.push(r);continue}t.push({kind:"judged",scope:r.scope,demand:r.demand,locations:r.locations,before:new Map(r.before),after:new Map(r.after),verdict:r.verdict,ignored:new Map(r.ignored),started:Date.now()})}return t}S(ct,"keptTakes");export{ci as accept,li as acceptRootRecords,rt as admissionChecks,et as admissionEvidence,We as admissionEvidenceResult,it as admissionWideningChecks,tt as configurationAdmissionGuards,nt as configurationEpochCheck,Ge as signedBatch};