@lapxo/bound 0.1.0

package/dist/cli/owner.js

@@ -0,0 +1,119 @@
+import { keyFor, lockLines, releaseOf, signedLockLines } from "../fold/keys.js";
+import { existsSync, renameSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { bytesDigest, fullDigest, memoized, signaturesOf } from "../fold/digests.js";
+import { claimKey, isConfig, fieldOf, foldClaims, LOCK, selfName } from "../fold/claims.js";
+import { asksThePlace } from "../fold/configures.js";
+import { receiptsIn } from "../fold/receipts.js";
+import { authorityFor, releaseSigner, rootSigner } from "../fold/signers.js";
+import { storeRoot } from "../host/ports/store.js";
+import { blobAt, landBlob, ledgerLines, storeOf } from "../land/ledger.js";
+import { observeText } from "../observe/files.js";
+import { everLanded, inside, locationsOf } from "../land/vouched.js";
+import { renderTarget } from "../render/target.js";
+export const ownerOf = (store, told = []) => keyFor(store, 'authorize', told);
+/** The signed lines standing in the lock: the owner's, and those of every key it admits to authorize, each in its own ledger. */
+export function signedOwnerLines(store) {
+    return signedLockLines(store);
+}
+function forkReceipts(store, lines) {
+    const scopes = [...new Set(foldClaims(lines.filter(line => fieldOf(line, 'sig') !== '')).forks.map((f) => f.key.split(' ')[0] ?? ''))].filter(Boolean);
+    return scopes.length ? receiptsIn(store, scopes) : [];
+}
+export function standingDemands(store) {
+    const lines = signedOwnerLines(store);
+    return foldClaims(lines, forkReceipts(store, lines)).standing
+        .filter((line) => asksThePlace(line) && fieldOf(line, 'value') !== 'withdraw');
+}
+/**
+ * A demand is history when it asks about a place that is gone: one the tree once held and holds no more. It paid, or
+ * did not, in its own time; whoever wants it again signs it against the region as it is. A place never held is not
+ * gone — it is still to be made, and its demand stays live.
+ */
+export function historyOf(root, store, demands) {
+    const held = [...everLanded(store)];
+    const gone = (need) => {
+        const at = need.replace(/\/+$/, '');
+        return !existsSync(join(root, at)) && held.some((coordinate) => coordinate === at || inside(coordinate, at));
+    };
+    const history = demands.filter((line) => locationsOf(fieldOf(line, 'needs')).locations.some(gone));
+    return { live: demands.filter((line) => !history.includes(line)), history };
+}
+export function signedDemands(store, root = resolve('.')) {
+    return historyOf(root, store, standingDemands(store)).live;
+}
+export function forkedScopes(store) {
+    const lines = signedOwnerLines(store);
+    return new Set(foldClaims(lines, forkReceipts(store, lines)).forks.flatMap((f) => f.lines.map((line) => fieldOf(line, 'scope'))));
+}
+export function epochOf(lines) {
+    return lines.reduce((top, line) => Math.max(top, Number(fieldOf(line, 'epoch')) || 0), 0);
+}
+export function targetFile(root) {
+    return join(storeRoot(root), LOCK);
+}
+export function renderInto(root, store) {
+    if (!lockLines(store).length)
+        throw new Error(`${selfName()}: the owner ledger is empty; land it before rendering TARGET`);
+    const rendered = renderedLock(root, store);
+    if (releaseOf(store))
+        return rendered;
+    const at = targetFile(root);
+    writeFileSync(`${at}.render`, rendered.text);
+    renameSync(`${at}.render`, at);
+    return rendered;
+}
+const rendered = new WeakMap();
+/**
+ * A release's lock is read as it was laid and never rendered over. Its target lines are true only where a pin names the
+ * release, so here they stand grey; a line signed by a key the release does not carry is refused and does not stand.
+ */
+function readRelease(lines) {
+    const of = authorityFor(lines, releaseSigner(lines), [], { digest: '', pins: [] }).of;
+    const refused = lines.filter((line) => of(line).kind === 'refuse');
+    const standing = lines.filter((line) => !refused.includes(line));
+    return {
+        text: `${standing.join('\n')}\n`, standing: standing.length, superseded: [], retracted: [], forks: [],
+        grey: standing.filter((line) => of(line).kind === 'grey'), refused, vacuous: [],
+    };
+}
+export function renderedLock(root, store, told = []) {
+    const released = releaseOf(store);
+    if (released && !told.length)
+        return readRelease(released);
+    const owned = [...lockLines(store), ...told];
+    const render = () => renderTarget(owned, undefined, authorityFor(owned, rootSigner(root), signaturesOf(store, told).admitted).of, forkReceipts(store, owned));
+    if (told.length) {
+        const byLock = rendered.get(lockLines(store)) ?? rendered.set(lockLines(store), new Map()).get(lockLines(store));
+        return byLock.get(told) ?? byLock.set(told, render()).get(told);
+    }
+    const anchor = [join(storeRoot(root), `${selfName()}.keys`), join(storeOf(root), `${selfName()}.keys`)].map((at) => observeText(at) ?? '').join('\n');
+    const judged = ledgerLines(store, 'judge');
+    const key = `lock ${fullDigest(store, [new Date().toISOString().slice(0, 10), anchor, `${judged.length} ${judged.at(-1) ?? ''}`, ...owned])}`;
+    const held = memoized(store, key, () => {
+        const bytes = new TextEncoder().encode(JSON.stringify(render()));
+        const digest = bytesDigest(store, bytes);
+        landBlob(store, digest, bytes);
+        return digest;
+    });
+    const text = observeText(blobAt(store, held));
+    return text === undefined ? render() : JSON.parse(text);
+}
+export function forksJoinedBy(store, signed) {
+    signed = signed.filter(isConfig);
+    const keys = new Set(signed.map(claimKey));
+    const held = signedOwnerLines(store).filter((line) => isConfig(line) && keys.has(claimKey(line)));
+    const vacuous = new Set(foldClaims(held, forkReceipts(store, held)).vacuous);
+    const live = held.filter((line) => !vacuous.has(line));
+    return foldClaims([...live, ...signed]).forks.filter((fork) => fork.lines.some((line) => signed.includes(line)));
+}
+export function forksItself(lines) {
+    const bySigner = new Map();
+    for (const line of lines)
+        bySigner.set(fieldOf(line, 'by'), (bySigner.get(fieldOf(line, 'by')) ?? 0) + 1);
+    return [...bySigner.values()].some((n) => n > 1);
+}
+export function sideOf(line, landed) {
+    const at = landed.indexOf(line);
+    return ['value', 'at', 'needs', 'restsOn'].map((k) => `${k}=${fieldOf(line, k) || '∅'}`).join(' ') + ` landed=${at < 0 ? 'new' : `#${at + 1}`}`;
+}

package/dist/cli/pass.d.ts

@@ -0,0 +1,6 @@
+export declare function pass(root: string, entry: string, under: string | undefined, check: boolean): Promise<number>;
+export type Journal = Map<string, {
+    readonly held: Uint8Array | undefined;
+    readonly made: string | undefined;
+}>;
+export declare function landSaid(store: string, folder: string | undefined, lines: readonly string[]): void;

package/dist/cli/pass.js

@@ -0,0 +1,309 @@
+import { mkdirSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { Worker } from 'node:worker_threads';
+import { ENVELOPE, canonical, parse } from '@lapxo/topos/wire';
+import { foldPlace, standingOf } from "./place.js";
+import { fieldOf, selfName } from "../fold/claims.js";
+import { observedClaims } from "../fold/observed.js";
+import { layReleases, resolvedOf } from "../host/release.js";
+import { ownLock, ownRoot, ownStore, processOf } from "../observe/runner.js";
+import { landLaid } from "../fold/laid.js";
+import { actSeconds, idleCount, instrumentKeep, instrumentKept, meets, noteIdle, receiptPlaces, receiptsSeen } from "../fold/closed.js";
+import { algorithmCost, instrumentOf, instrumentDigest } from "../fold/digests.js";
+import { writerFor } from "../fold/signers.js";
+import { defaulted, placesOf, viewsOf } from "../fold/views.js";
+import { ownLockOf } from "../fold/signed.js";
+import { worldAt, worldsIn } from "../fold/places.js";
+import { wordsOf } from "../fold/wire.js";
+import { land, ledgerLines, replaceWhole, storeOf } from "../land/ledger.js";
+import { holdRoot, holds, underTheLock } from "../land/act.js";
+import { emptyLedger, sayStranger } from "../fold/stranger.js";
+import { entriesIn, observeFile, observeText } from "../observe/files.js";
+import { render, renderedOf, unrendered, viewOf } from "../render/view.js";
+import { releasePolicyLines } from "../fold/release-policy.js";
+import { carriedFrom } from "../fold/resolved.js";
+import { wireLine } from "../fold/wire.js";
+import { isWire, RECEIPTS } from "../fold/claims.js";
+/**
+ * The pass of a place, in one process: the releases its instrument names are laid out first, its readers observe
+ * once, each place a view writes in is folded once, the places before the root whose door reads them, and every coordinate a
+ * view writes there is its render or is written again.
+ * A round that wrote nothing ends the pass; one that made a coordinate or wrote one a region reads folds again, since what a
+ * place shows may rest on what another renders — a coordinate rewritten that no region reads moves no page — and a third round
+ * that still writes is named, never looped. With `--check` nothing is written; without it the pass holds the store,
+ * and what it saw answer and lay lands by the key that writes folds: which capsule rendered each region of a view and
+ * which release each dependency was laid from, each line once. What an act's gates saw answer lands only once its batch
+ * has landed, and never when it is refused.
+ */
+/**
+ * A check verifies existing receipts without running readers or refreshing hashes. Open regions or a different
+ * instrument refuse; an admitted fold must establish closure before it can be checked.
+ */
+async function checked(root, entry, under) {
+    const started = Date.now();
+    const store = storeOf(root);
+    if (!meets(root, store, under ?? '')) {
+        process.stderr.write(`${selfName()}: REFUSE·check receipts are open; a fold must close them\n`);
+        return 1;
+    }
+    const contract = wireLine(ownLock(), 'receipt-instrument');
+    const evidence = carriedFrom(store, (observeText(join(root, under ?? '', RECEIPTS)) ?? '').split('\n').filter(isWire));
+    const sealed = contract === undefined ? undefined : evidence?.find(line => fieldOf(line, 'scope') === fieldOf(contract, 'value') && fieldOf(line, 'measure') === 'digest');
+    const expectedInstrument = sealed === undefined ? instrumentKept(store) : fieldOf(sealed, 'value');
+    if (!expectedInstrument) {
+        process.stderr.write(`${selfName()}: REFUSE·check no verified instrument identity is available for these receipts\n`);
+        return 1;
+    }
+    const standing = emptyLedger(store) ? ownLockOf(root, under?.replace(/\/$/, '') ?? '') : standingOf(root).standing;
+    const instrument = sealed === undefined ? instrumentOf(store, entry, standing, root, ownLock()) : instrumentDigest(store, entry, [], ownRoot(), ownLock());
+    if (expectedInstrument !== instrument) {
+        process.stderr.write(`${selfName()}: REFUSE·check receipt instrument differs; a fold must close it\n`);
+        return 1;
+    }
+    const read = receiptsSeen();
+    const ms = Date.now() - started;
+    if (under === undefined)
+        process.stderr.write(`RECEIPTS ${read.count || receiptPlaces(root, store).length} read · 0 opened · ${ms} ms\n`);
+    else
+        process.stderr.write(`CLOSED   ${under} · ${ms} ms\n`);
+    const seconds = actSeconds();
+    process.stderr.write(`COST     act ${seconds} s\n`);
+    process.stdout.write(`PASS     closed · ${under ? 1 : receiptPlaces(root, store).length} places · ${ms} ms\n`);
+    return 0;
+}
+export async function pass(root, entry, under, check) {
+    if (check) {
+        // Verification reads existing evidence; it grants no admission authority.
+        return emptyLedger(storeOf(root)) ? checked(root, entry, under) : underTheLock(storeOf(root), 'check', () => checked(root, entry, under));
+    }
+    if (!under && emptyLedger(storeOf(root))) {
+        sayStranger(root);
+        return 0;
+    }
+    const started = Date.now();
+    const run = async () => {
+        const swept = await sweep(root, entry, under, check, []);
+        for (const coordinate of check ? swept.written : [])
+            process.stdout.write(`DIFFERS  ${coordinate}\n`);
+        const closed = meets(root, storeOf(root), under ?? '') && !swept.written.length;
+        const fold = foldPlace(root, entry, under, false, { standing: swept.standingAt.get(under ?? '') ?? standingOf(root, under), observed: swept.observed.length ? swept.observed : observedClaims(root, storeOf(root), { wait: false }), free: true });
+        for (const line of releasePolicyLines(fold.release))
+            process.stdout.write(`${line}\n`);
+        if (closed) {
+            instrumentKeep(storeOf(root), instrumentOf(storeOf(root), entry, standingOf(root).standing, root, ownLock()));
+            process.stdout.write(`PASS     closed · ${swept.places} places · ${Date.now() - started} ms\n`);
+            return 0;
+        }
+        process.stdout.write(`PASS     ${swept.same + swept.written.length} renders · ${swept.same} same${swept.written.length ? ` · ${swept.written.length} ${check ? 'differ' : 'still written after three rounds'}` : ''} · ${swept.places} places · ${Date.now() - started} ms\n`);
+        process.stdout.write(render(fold, [{ name: 'programs', at: 1 }]));
+        return swept.written.length ? 1 : 0;
+    };
+    return underTheLock(storeOf(root), 'pass', run);
+}
+export function landSaid(store, folder, lines) {
+    if (folder === undefined || !lines.length)
+        return;
+    const bare = (line) => ((got) => (got.kind === 'fact' ? canonical(Object.fromEntries(Object.entries(got.value.fields).filter(([name]) => !ENVELOPE.has(name) && name !== 'by'))) : line))(parse(line));
+    const held = new Set(ledgerLines(store, folder).filter((line) => /(?:^|\s)scope=re(?:ndered|solved)\//.test(line)).map(bare));
+    const fresh = [...new Set(lines.filter((line) => !held.has(bare(line))).map((line) => ((got) => (got.kind === 'fact' ? canonical({ ...got.value.fields, by: folder }) : line))(parse(line))))];
+    if (fresh.length)
+        land(store, folder, fresh);
+}
+async function sweep(root, entry, under, check, told, journal, given, keep, reach) {
+    const store = storeOf(root);
+    const digestAt = Date.now();
+    const met = told.length === 0 && reach === undefined && meets(root, store, under ?? '');
+    const sameInstrument = instrumentKept(store) === instrumentOf(store, entry, standingOf(root).standing, root, ownLock());
+    const missingView = () => {
+        if (!under || !worldAt(root, under.replace(/\/$/, '')))
+            return false;
+        const held = standingOf(root, under);
+        const views = viewsOf(held.standing);
+        return wordsOf(held.standing, 'views/world').some((name) => {
+            const view = views.get(name);
+            return view?.shape !== undefined && view.shape !== '' && observeText(join(root, under, view.shape)) === undefined;
+        });
+    };
+    const settled = met && sameInstrument && !missingView();
+    if (settled) {
+        const ms = Date.now() - digestAt;
+        const read = receiptsSeen();
+        const lock = algorithmCost();
+        const hash = Math.max(0, ms - lock);
+        if (lock > 0) {
+            noteIdle();
+            process.stderr.write(`RED      fold/idle · ${idleCount()} · lock ${lock} ms · hash ${hash} ms · a fold over a closed region\n`);
+        }
+        if (under === undefined)
+            process.stderr.write(`RECEIPTS ${read.count} read · 0 opened · ${ms} ms\n`);
+        else
+            process.stderr.write(`CLOSED   ${under} · lock ${lock} ms · hash ${hash} ms\n`);
+        const seconds = actSeconds();
+        process.stderr.write(`COST     act ${seconds} s\n`);
+        return { same: 0, written: [], places: under === undefined ? read.count : 1, observed: [], standingAt: new Map(), folds: new Map(), said: [] };
+    }
+    layReleases(store, ownRoot(), ownLock(), ownStore());
+    const descent = reach ?? (under ? [under.replace(/\/$/, '')] : undefined);
+    const limited = descent !== undefined;
+    const observed = given ?? observedClaims(root, store, { wait: true, ...(descent !== undefined ? { reach: descent } : {}) });
+    const lock = standingOf(root, undefined, told);
+    landLaid(store, ownRoot(), ownLock(), writerFor(lock.standing, 'fold'));
+    const shaped = (standing) => [...viewsOf(standing).values()].flatMap((view) => ('regions' in view && view.shape ? [view] : []));
+    const views = shaped(lock.standing);
+    const tree = viewsOf(lock.lock);
+    const worldList = wordsOf(lock.standing, 'views/world');
+    const worldPlaces = new Set(worldsIn(root).map((name) => `${name}/`));
+    const resolved = (view) => {
+        const named = placesOf(lock.standing, view);
+        if (!worldList.includes(view.name))
+            return named;
+        const picked = named.filter((place) => worldPlaces.has(place));
+        return picked.length ? picked : [...worldPlaces];
+    };
+    const placeless = views.filter((view) => !worldList.includes(view.name) && !placesOf(lock.standing, view).length);
+    const holding = entriesIn(root).filter((entry) => entry.dir && placeless.some((view) => observeText(join(root, entry.name, view.shape)) !== undefined)).map((entry) => `${entry.name}/`);
+    const descended = (place) => !limited || descent.some((one) => one === '' || place === `${one}/` || place.startsWith(`${one}/`));
+    const reached = limited ? descent.filter((one) => one !== '').map((one) => (one.endsWith('/') ? one : `${one}/`)) : [];
+    const places = [...new Set([...views.flatMap(resolved), ...holding, ...reached])]
+        .filter((place) => place !== '' && (!under || place.startsWith(under)) && descended(place)).sort();
+    const standingAt = new Map([...places, ''].map((place) => [place, place ? standingOf(root, place, told) : lock]));
+    const writes = (place) => {
+        const { standing } = standingAt.get(place) ?? lock;
+        const mine = shaped(standing);
+        const own = worldAt(root, place.slice(0, -1)) ? ownLockOf(root, place.slice(0, -1)) : [];
+        const namedOf = (view) => placesOf(standing, view);
+        return mine.filter((view) => namedOf(view).includes(place) || (own.length > 0 && defaulted(standing, view, own, tree))
+            || (!worldList.includes(view.name) && !namedOf(view).length && observeText(join(root, place, view.shape)) !== undefined && !mine.some((other) => other.shape === view.shape && namedOf(other).includes(place))));
+    };
+    let same = 0;
+    let written = [];
+    const read = new Set(ownLock().filter((line) => fieldOf(line, 'scope').startsWith('region/') && fieldOf(line, 'measure') === 'lines').flatMap((line) => fieldOf(line, 'value').split('|')));
+    const free = (place) => limited ? descended(place) : !sameInstrument || !meets(root, store, place);
+    const folds = new Map();
+    const answered = new Map();
+    const paint = (place, drawn, moved) => {
+        for (const view of drawn) {
+            if (view.missing.length) {
+                throw new Error(`REFUSE·view at ${place || '.'} · asks regions nothing renders: ${view.missing.join(' ')}`);
+            }
+            if (!check && view.said.length)
+                answered.set(`${place}${view.shape}`, view.said);
+            const coordinate = join(root, place, view.shape);
+            const leaf = ['s', 'v', 'g'].join('');
+            if (view.shape.endsWith(`.${leaf}`) && !view.text.includes(`<${leaf}`)) {
+                if (!check && observeText(coordinate) !== undefined) {
+                    rmSync(coordinate, { force: true });
+                    written.push(`${place}${view.shape}`);
+                }
+                continue;
+            }
+            if (observeText(coordinate) === view.text)
+                same += 1;
+            else if (check)
+                written.push(`${place}${view.shape}`);
+            else {
+                moved.at || (moved.at = observeText(coordinate) === undefined || read.has(view.shape));
+                const held = journal !== undefined && !journal.has(coordinate) ? observeFile(coordinate) : undefined;
+                const made = mkdirSync(dirname(coordinate), { recursive: true });
+                if (journal !== undefined && !journal.has(coordinate))
+                    journal.set(coordinate, { held, made });
+                replaceWhole(coordinate, view.text);
+                written.push(`${place}${view.shape}`);
+            }
+        }
+    };
+    for (let round = 1; round <= 3; round += 1) {
+        written = [];
+        same = 0;
+        const moved = { at: false };
+        const asked = [...places, ...(under || (limited && descent.length > 0 && !descent.includes('')) ? [] : [''])];
+        const open = asked.filter((place) => free(place));
+        for (const place of asked)
+            if (!open.includes(place))
+                same += writes(place).length;
+        if (!under && round === 1) {
+            if (!receiptsSeen().count)
+                meets(root, store, '');
+            const read = receiptsSeen();
+            process.stderr.write(`RECEIPTS ${read.count} read · ${open.length} opened · ${read.ms} ms\n`);
+        }
+        if (open.length)
+            process.stderr.write(`OPEN     ${open.map((place) => place || '.').join(' ')}\n`);
+        const aside = open.filter((place) => place !== '' && !keep?.has(place) && !meets(root, store, place));
+        const drawn = aside.length > 1 ? await drawParallel(aside.map((place) => ({ root, entry, place, told, observed, views: writes(place) }))) : new Map();
+        for (const place of open) {
+            if (!check && place === '')
+                await holdRoot(store, 'join');
+            if (!check && !holds(store, place)) {
+                process.stderr.write(`OUTSIDE  ${place} · not settled, and no region this act holds: the next pass renders it\n`);
+                continue;
+            }
+            const ready = drawn.get(place);
+            if (ready !== undefined) {
+                paint(place, ready, moved);
+                continue;
+            }
+            const standing = standingAt.get(place) ?? lock;
+            const fold = foldPlace(root, entry, place || undefined, false, { standing, observed, free: true });
+            if (keep?.has(place))
+                folds.set(place, fold);
+            paint(place, writes(place).map((view) => {
+                const missing = unrendered(fold, view);
+                return { shape: view.shape, missing, text: missing.length ? '' : viewOf(fold, view), said: missing.length ? [] : renderedOf(fold, view) };
+            }), moved);
+        }
+        if (check || !written.length)
+            break;
+        for (const coordinate of written)
+            process.stdout.write(`RENDERED ${coordinate} · round ${round}\n`);
+        if (!moved.at) {
+            same += written.length;
+            written = [];
+            break;
+        }
+    }
+    const said = [...answered.values()].flat();
+    if (!check && journal === undefined)
+        landSaid(store, writerFor(lock.standing, 'fold'), [...resolvedOf(store, ownRoot(), ownLock(), ownStore()), ...said]);
+    return { same, written, places: places.length + (under ? 0 : 1), observed, standingAt, folds, said: journal === undefined ? [] : said };
+}
+function drawParallel(jobs) {
+    const out = new Map();
+    if (jobs.length < 2)
+        return Promise.resolve(out);
+    return new Promise((resolve, reject) => {
+        const workers = [];
+        let left = jobs.length;
+        let failed = false;
+        const refuse = (error) => {
+            if (failed)
+                return;
+            failed = true;
+            reject(error);
+            for (const worker of workers)
+                void worker.terminate();
+        };
+        try {
+            for (const job of jobs) {
+                const worker = new Worker(processOf('fold-worker', 'fold'), { execArgv: process.execArgv, workerData: job });
+                workers.push(worker);
+                worker.on('message', (msg) => out.set(msg.place, msg.texts));
+                worker.on('error', refuse);
+                worker.on('exit', (code) => {
+                    if (failed)
+                        return;
+                    if (code !== 0 || !out.has(job.place)) {
+                        refuse(new Error(`REFUSE·worker ${job.place} · exit ${code} · no completed render`));
+                        return;
+                    }
+                    left -= 1;
+                    if (left === 0)
+                        resolve(out);
+                });
+            }
+        }
+        catch (error) {
+            refuse(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}

package/dist/cli/place.d.ts

@@ -0,0 +1,74 @@
+import type { ReleasePolicyResult } from '../fold/release-policy.ts';
+import type { Fork } from '../fold/claims.ts';
+import type { Packed } from '../fold/region.ts';
+import type { OpenCell } from '../render/open.ts';
+import type { SecondHead } from '../fold/second.ts';
+import { renderTarget } from '../render/target.ts';
+/**
+ * Everything the fold knows about one place of the tree, or about the whole tree: what every region is rendered from,
+ * whether it was read back from a key already answered rather than taken again, and the middle of the last ten folds
+ * of this place, those that had to fold apart from those that read. A region whose points are ledger lines that move
+ * at every beat is judged when it is read and never kept: a kept fold answers for the regions whose digest is in its
+ * key and for no others.
+ */
+export interface PlaceFold {
+    readonly release?: ReleasePolicyResult;
+    readonly root: string;
+    readonly store: string;
+    readonly under?: string;
+    readonly epoch: number;
+    readonly standing: readonly string[];
+    readonly claims: number;
+    readonly forks: readonly Fork[];
+    readonly grey: readonly string[];
+    readonly refused: readonly string[];
+    readonly vacuous: number;
+    readonly demands: readonly string[];
+    readonly paid: readonly string[];
+    readonly missing: readonly string[];
+    readonly history: readonly string[];
+    readonly observed: readonly string[];
+    readonly ceilings: {
+        readonly read: number;
+        readonly total: number;
+        readonly unread: readonly string[];
+        readonly vacuous: readonly string[];
+        readonly short: readonly string[];
+        readonly over: readonly string[];
+    };
+    readonly orphans: readonly string[];
+    readonly lock: number;
+    readonly signed: ReadonlyMap<string, number>;
+    readonly second: SecondHead;
+    readonly effects: string;
+    readonly costs: readonly number[];
+    readonly landed: number;
+    readonly kept?: boolean;
+    readonly key: string;
+    readonly instrument: string;
+    readonly own: Readonly<Record<string, number>>;
+    readonly open: readonly OpenCell[];
+    readonly beats: {
+        readonly kept: number;
+        readonly folded: number;
+    };
+    readonly regions?: Packed;
+}
+export declare function standingOf(root: string, under?: string, told?: readonly string[]): {
+    readonly standing: readonly string[];
+    readonly lock: readonly string[];
+    readonly rendered: ReturnType<typeof renderTarget>;
+    readonly owned: readonly string[];
+};
+export declare function coneOf(root: string, entry: string, ceilings: readonly string[], descent?: readonly string[]): {
+    readonly standing: readonly string[];
+    readonly observed: readonly string[];
+    readonly own: Readonly<Record<string, number>>;
+    readonly kept: boolean;
+};
+export declare const ownCeilings: (under?: string) => readonly string[];
+export declare function foldPlace(root: string, entry: string, under?: string, look?: boolean, given?: {
+    readonly standing: ReturnType<typeof standingOf>;
+    readonly observed: readonly string[];
+    readonly free?: boolean;
+}): PlaceFold;