@lapxo/bound 0.1.0

package/dist/fold/kept.d.ts

@@ -0,0 +1,29 @@
+import type { PlaceFold } from '../cli/place.ts';
+/**
+ * The points a fold folds: each coordinate the place holds at the digest its readers last read it, with what they said of
+ * it there, the lines that stand, and the receipts the store keeps. A coordinate is never a digest it had before nor a coordinate
+ * of another place, so an edit elsewhere moves nothing here; and a reader is what it said, so a reader edit that says
+ * the same moves nothing either. A fold is a function of these points, so a fold that was not found is never a
+ * mystery — what moved is the difference between the points kept beside the last one and the points there are now.
+ */
+export type PlaceReads = {
+    readonly owned: readonly string[];
+    readonly scopes: ReadonlySet<string>;
+    readonly place: string;
+};
+export declare function foldPoints(store: string, standing: readonly string[], under: string | undefined, keeper?: string, instrument?: string, observed?: readonly string[], root?: string, answered?: ReadonlyMap<string, string>, reads?: PlaceReads): readonly string[];
+/**
+ * What a reader said at one digest, as one digest: every point of a fold that stands for an answer is this. The writer
+ * whose class the lock names live is judged when read, so a fold keeps what it said — which lines it found standing and
+ * which ledger it folded — and not when.
+ */
+export declare const saidDigest: (store: string, lines: readonly string[]) => string;
+export declare function movedPoints(store: string, now: readonly string[], key: string): {
+    readonly gone: readonly string[];
+    readonly came: readonly string[];
+} | undefined;
+export declare const foldsElsewhere: () => number;
+export declare function keptPlace(store: string, under?: string): PlaceFold | undefined;
+export declare const keptRender: (store: string, key: string, name: string) => string | undefined;
+export declare const keepRender: (store: string, _signer: string, key: string, name: string, _epoch: number, text_: string) => void;
+export declare function keepFold(store: string, key: string, fold: PlaceFold, points: readonly string[], instrument?: string): void;

package/dist/fold/kept.js

@@ -0,0 +1,142 @@
+import { createHash, dirname, existsSync, join, mkdirSync, readdirSync, renameSync, writeFileSync } from "../host/io.js";
+import { bytesDigest, coordinateDigest } from "./digests.js";
+import { viewsOf } from "./views.js";
+import { landMemo, ledgerLines, memoAt } from "../land/ledger.js";
+import { observeText } from "../observe/files.js";
+import { EXTENSION, fieldOf } from "./claims.js";
+import { keyFor, lockSigners } from "./keys.js";
+import { sourceOf, vouching } from "../land/vouched.js";
+import { wordsOf } from "./wire.js";
+import { ownLock } from "../observe/runner.js";
+const text = (s) => new TextEncoder().encode(s);
+const atOf = (line) => {
+    if (line.includes(' about='))
+        return fieldOf(line, 'at');
+    const from = line.indexOf(' at=') + ' at='.length;
+    return line.slice(from, line.indexOf(' ', from));
+};
+export function foldPoints(store, standing, under, keeper, instrument = '', observed = [], root = dirname(store), answered, reads) {
+    const said = new Map();
+    for (const line of answered === undefined ? observed : []) {
+        if (line.includes(' measure=observed '))
+            continue;
+        const key = `${fieldOf(line, 'by').split(':')[1] ?? ''} ${atOf(line)}`;
+        (said.get(key) ?? said.set(key, []).get(key)).push(line);
+    }
+    const coordinates = observed
+        .filter((line) => line.includes(' measure=observed ') && atOf(line).startsWith('place:') && (!under || fieldOf(line, 'scope').startsWith(under)))
+        .map((line) => ((key) => `${fieldOf(line, 'scope')} ${atOf(line)} ${answered?.get(key) ?? saidDigest(store, said.get(key) ?? [])}`)(`${fieldOf(line, 'by').split(':')[1] ?? ''} ${atOf(line)}`));
+    const signers = new Set(reads ? lockSigners(store) : []);
+    const tree = reads ? vouching(standing) : undefined;
+    const digestOf = (lines) => bytesDigest(store, text(lines.join('\n')));
+    const narrowed = reads === undefined ? [] : [
+        `lock ${digestOf([...reads.owned].sort())}`,
+        `judge ${digestOf(ledgerLines(store, 'judge').filter((line) => reads.scopes.has(fieldOf(line, 'scope'))))}`,
+        `take ${digestOf(ledgerLines(store, 'take').filter((line) => reads.scopes.has(fieldOf(line, 'scope').replace(/^take\//, ''))))}`,
+        `tree ${digestOf(ledgerLines(store, tree ?? '').filter((line) => (sourceOf(line) ?? '').startsWith(reads.place)))}`,
+    ];
+    const heads = (existsSync(join(store, 'ledger')) ? readdirSync(join(store, 'ledger')) : []).filter((name) => name.endsWith(EXTENSION)).map((name) => name.slice(0, -EXTENSION.length))
+        .filter((writer) => writer !== keeper && writer !== 'gate' && !writer.startsWith('reader') && !(reads && (signers.has(writer) || writer === 'judge' || writer === 'take' || writer === tree)))
+        .map((writer) => `${writer} ${writer === liveWriter(store, standing) ? lastWord(store, writer) : bytesDigest(store, text(ledgerLines(store, writer).join('\n')))}`);
+    const written = [...new Set([...viewsOf(standing).values()].flatMap((view) => ('regions' in view && view.shape ? [view.shape] : [])))].sort()
+        .map((shape) => `written ${shape} ${coordinateDigest(store, join(root, under ?? '', shape)) ?? 'absent'}`);
+    const lined = ownLock().filter((line) => fieldOf(line, 'scope').startsWith('region/') && fieldOf(line, 'measure') === 'lines' && fieldOf(line, 'value') !== 'withdraw')
+        .flatMap((line) => fieldOf(line, 'value').split('|').filter(Boolean)).sort().map((coordinate) => `lines ${coordinate} ${coordinateDigest(store, join(root, under ?? '', coordinate)) ?? 'absent'}`);
+    return [
+        `place ${under ?? '.'}`,
+        `instrument ${instrument}`,
+        ...written,
+        ...lined,
+        ...[...new Set(coordinates)].sort(),
+        ...heads.sort(),
+        ...narrowed,
+        `lines ${bytesDigest(store, text([...standing].sort().join('\n')))}`,
+        ...(existsSync(join(store, 'cas', 'receipts')) ? readdirSync(join(store, 'cas', 'receipts')).sort() : []),
+    ];
+}
+/**
+ * What a reader said at one digest, as one digest: every point of a fold that stands for an answer is this. The writer
+ * whose class the lock names live is judged when read, so a fold keeps what it said — which lines it found standing and
+ * which ledger it folded — and not when.
+ */
+export const saidDigest = (store, lines) => bytesDigest(store, text([...new Set(lines
+        .filter((line) => !line.includes(' measure=observed ') && !line.includes(' scope=cost/'))
+        .map((line) => `${fieldOf(line, 'scope')} ${fieldOf(line, 'measure')} ${fieldOf(line, 'value')}`))].sort().join('\n')));
+function liveWriter(store, standing) {
+    if (!wordsOf(standing, 'live').includes('attest'))
+        return undefined;
+    try {
+        return keyFor(store, 'attest');
+    }
+    catch {
+        return undefined;
+    }
+}
+const lastWord = (store, writer) => ((last) => `${fieldOf(last, 'at')} ${fieldOf(last, 'restsOn')} ${fieldOf(last, 'value')}`)(ledgerLines(store, writer).filter((line) => fieldOf(line, 'scope') === `${writer}/target`).at(-1) ?? '');
+export function movedPoints(store, now, key) {
+    const last = observeText(memoAt(store, lastOf(now)))?.trim();
+    const held = last === undefined || last === key ? undefined : observeText(memoAt(store, `fold/${last}`));
+    if (held === undefined)
+        return undefined;
+    const was = new Set((JSON.parse(held).points ?? []));
+    const has = new Set(now);
+    return { gone: [...was].filter((one) => !has.has(one)), came: now.filter((one) => !was.has(one)) };
+}
+const lastOf = (points) => `last/${createHash('sha256').update(points[0] ?? '').digest('hex')}`;
+/**
+ * A fold is kept under its key and a view's text under the key and the view's name, in the store's memos: the first to
+ * keep a key keeps it, since one point set folds into one set of bytes, and a fold kept by another instrument is
+ * another origin's, readable as history and never as this instrument's own state.
+ */
+const elsewhere = { folds: 0 };
+export const foldsElsewhere = () => elsewhere.folds;
+const joined = (lines) => lines.join('\n');
+const split = (text) => (text === '' ? [] : text.split('\n'));
+const linesOf = (value) => value === undefined ? [] : typeof value === 'string' ? split(value) : value;
+export function keptPlace(store, under) {
+    const key = observeText(memoAt(store, lastOf([`place ${under ?? '.'}`])))?.trim();
+    if (key === undefined || key === '')
+        return undefined;
+    const held = observeText(memoAt(store, `fold/${key}`));
+    if (held === undefined)
+        return undefined;
+    const blob = JSON.parse(held);
+    const fold = blob.fold;
+    return {
+        ...fold,
+        standing: linesOf(fold.standing),
+        observed: linesOf(fold.observed),
+        grey: linesOf(fold.grey),
+        refused: linesOf(fold.refused),
+        demands: linesOf(fold.demands),
+        paid: linesOf(fold.paid),
+        missing: linesOf(fold.missing),
+        history: linesOf(fold.history),
+        orphans: linesOf(fold.orphans),
+        signed: new Map(fold.signed),
+        kept: true,
+    };
+}
+export const keptRender = (store, key, name) => observeText(memoAt(store, `render/${key}/${name}`));
+export const keepRender = (store, _signer, key, name, _epoch, text_) => { landMemo(store, `render/${key}/${name}`, text(text_)); };
+export function keepFold(store, key, fold, points, instrument = '') {
+    const packed = {
+        ...fold,
+        standing: joined(fold.standing),
+        observed: joined(fold.observed),
+        grey: joined(fold.grey),
+        refused: joined(fold.refused),
+        demands: joined(fold.demands),
+        paid: joined(fold.paid),
+        missing: joined(fold.missing),
+        history: joined(fold.history),
+        orphans: joined(fold.orphans),
+        signed: [...fold.signed],
+        kept: false,
+    };
+    landMemo(store, `fold/${key}`, text(JSON.stringify({ fold: packed, points, instrument })));
+    const at = memoAt(store, lastOf(points));
+    mkdirSync(dirname(at), { recursive: true });
+    writeFileSync(`${at}.${process.pid}.part`, `${key}\n`);
+    renameSync(`${at}.${process.pid}.part`, at);
+}

package/dist/fold/keys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Whose lines carry a class of writing, as the lock says it. Every ledger the store keeps is read, the key claims
+ * folded, and the class answered with the id the lock admitted first for it: no module here holds a signer's name, so
+ * the day another head runs the same work its lines come out under its own name without a letter changing.
+ */
+export declare const keyOf: (store: string, kind: string, told?: readonly string[]) => string | undefined;
+export declare function keyFor(store: string, kind: string, told?: readonly string[]): string;
+export declare function lockSigners(store: string, told?: readonly string[]): readonly string[];
+export declare function lockLines(store: string): readonly string[];
+/** What stands of the lock, folded once per landing of any of its ledgers: lockLines is the bytes, lockSigners the ids that write them, signedLockLines the same lines still carrying their signatures. */
+export declare function lockStanding(store: string): readonly string[];
+export declare function signedLockLines(store: string, told?: readonly string[]): string[];
+/**
+ * A release's lock, where the store signs no key of its own: the lock as it was laid is the place's only lines, read
+ * and never written. What it says is true where a pin names the release; no ledger is made of it.
+ */
+export declare function releaseOf(store: string): readonly string[] | undefined;

package/dist/fold/keys.js

@@ -0,0 +1,84 @@
+import { dirname, existsSync, join } from "../host/io.js";
+import { ledgerLines, signedLines } from "../land/ledger.js";
+import { EXTENSION, fieldOf, foldClaims, isWire, LOCK, selfName } from "./claims.js";
+import { entriesIn, observeText } from "../observe/files.js";
+const held = new Map();
+const merged = new Map();
+/**
+ * Whose lines carry a class of writing, as the lock says it. Every ledger the store keeps is read, the key claims
+ * folded, and the class answered with the id the lock admitted first for it: no module here holds a signer's name, so
+ * the day another head runs the same work its lines come out under its own name without a letter changing.
+ */
+export const keyOf = (store, kind, told = []) => keysOf(store, told).classes.get(kind)?.[0];
+export function keyFor(store, kind, told = []) {
+    const id = keyOf(store, kind, told);
+    if (id === undefined) {
+        throw new Error(`${selfName()}: REFUSE·keys the lock admits no key of class \`${kind}\`: name one as \`keys/<id> measure=class value=${kind}\``);
+    }
+    return id;
+}
+export function lockSigners(store, told = []) {
+    const keys = keysOf(store, told);
+    const attests = new Set(keys.classes.get('attest') ?? []);
+    return keys.signers.filter((id) => !attests.has(id));
+}
+export function lockLines(store) {
+    const release = releaseOf(store);
+    if (release)
+        return release;
+    const parts = lockSigners(store).map((id) => ledgerLines(store, id)).filter((part) => part.length > 0);
+    const last = merged.get(store);
+    if (last !== undefined && last.parts.length === parts.length && last.parts.every((part, i) => part === parts[i]))
+        return last.lines;
+    const lines = parts.length === 1 ? parts[0] : parts.flat();
+    merged.set(store, { parts, lines });
+    return lines;
+}
+const standings = new WeakMap();
+/** What stands of the lock, folded once per landing of any of its ledgers: lockLines is the bytes, lockSigners the ids that write them, signedLockLines the same lines still carrying their signatures. */
+export function lockStanding(store) {
+    const lines = lockLines(store);
+    return standings.get(lines) ?? standings.set(lines, foldClaims(signedLockLines(store)).standing).get(lines);
+}
+export function signedLockLines(store, told = []) {
+    const release = releaseOf(store);
+    if (release)
+        return [...release];
+    return lockSigners(store, told).flatMap((id) => signedLines(store, id));
+}
+function keysOf(store, told) {
+    const mine = told.length ? read(store, told) : held.get(store) ?? read(store);
+    if (!told.length)
+        held.set(store, mine);
+    return mine;
+}
+const ledgerKeyLines = (store) => (existsSync(join(store, 'ledger')) ? entriesIn(join(store, 'ledger')).map((entry) => entry.name) : [])
+    .filter((name) => name.endsWith(EXTENSION)).flatMap((name) => ledgerLines(store, name.slice(0, -EXTENSION.length)))
+    .filter((line) => /\bsig=/.test(line) && /(?:^|\s)scope=keys\/[^/\s]+\s/.test(line));
+const releases = new Map();
+/**
+ * A release's lock, where the store signs no key of its own: the lock as it was laid is the place's only lines, read
+ * and never written. What it says is true where a pin names the release; no ledger is made of it.
+ */
+export function releaseOf(store) {
+    if (releases.has(store))
+        return releases.get(store);
+    const at = join(dirname(store), LOCK);
+    const lines = ledgerKeyLines(store).length || !existsSync(at) ? [] : (observeText(at) ?? '').split('\n').filter(isWire);
+    const got = lines.some((line) => fieldOf(line, 'scope') === 'publish/bootstrap' && fieldOf(line, 'value') !== 'withdraw') ? lines : undefined;
+    releases.set(store, got);
+    return got;
+}
+function read(store, told = []) {
+    const said = [...ledgerKeyLines(store), ...releaseOf(store) ?? [], ...told]
+        .filter((line) => /\bsig=/.test(line) && /(?:^|\s)scope=keys\/[^/\s]+\s/.test(line));
+    const standing = foldClaims(said).standing.filter((line) => fieldOf(line, 'value') !== 'withdraw')
+        .sort((a, b) => (Number(fieldOf(a, 'epoch')) || 0) - (Number(fieldOf(b, 'epoch')) || 0));
+    const idOf = (line) => fieldOf(line, 'scope').slice('keys/'.length);
+    const classes = new Map();
+    for (const line of standing.filter((one) => fieldOf(one, 'measure') === 'class'))
+        classes.set(fieldOf(line, 'value'), [...(classes.get(fieldOf(line, 'value')) ?? []), idOf(line)]);
+    const named = new Set(standing.filter((one) => fieldOf(one, 'measure') === 'public-key').map(idOf));
+    const signers = [...new Set(standing.filter((one) => fieldOf(one, 'measure') === 'class').map(idOf))].filter((id) => named.has(id));
+    return { classes, signers };
+}

package/dist/fold/laid.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A release is named by the digest of its folder, and what is laid is read again from its bytes by the same method: every
+ * coordinate but those the tree's roles call foreign, a dotted one only where the folder's own lock writes into it, sorted, each a
+ * ustar entry of mode 0644, owner 0 and time 0, then two empty blocks, gzipped at level nine. The mark the host writes is
+ * none of those coordinates, so the digest of a place is the digest of the release laid there, or it is not that release.
+ */
+export declare function releaseDigest(store: string, place: string): {
+    readonly state: string;
+    readonly digest: string;
+};
+/**
+ * What the pass lands after it lays: for each release the own lock lays where it needs it, the digest its bytes give, by
+ * the stamps of the bytes it read. What is read is the receipt of the bytes as they lie now: none is a count, and one
+ * whose digest is not the one the lock names is a count.
+ */
+export declare function landLaid(store: string, own: string, lock: readonly string[], folder: string | undefined): void;
+export declare const laidDiffers: (store: string, own: string, lock: readonly string[], folder: string | undefined) => number;

package/dist/fold/laid.js

@@ -0,0 +1,90 @@
+import { createHash, gzipSync, join } from "../host/io.js";
+import { canonical, LOCK } from '@lapxo/topos/wire';
+import { fieldOf, isWire } from "./claims.js";
+import { memoized } from "./digests.js";
+import { rolesOf } from "./roles.js";
+import { said } from "./wire.js";
+import { releasesOf } from "../host/release.js";
+import { land, landBlob, ledgerLines } from "../land/ledger.js";
+import { coordinatesUnder, observeFile, observeText, stampOf } from "../observe/files.js";
+import { ownLock } from "../observe/runner.js";
+const RECEIPT = 'laid/';
+const DIGEST = '{digest}';
+/** The host's marks, named by the lock: `release/asset` on this place, else the asset and archive the tree already writes. */
+const assetsOf = (_store) => said(ownLock(), 'release/asset');
+const marked = (coordinate, tokens) => tokens.some((token) => {
+    const at = token.indexOf(DIGEST);
+    if (at < 0)
+        return !token.includes('{') && coordinate === token;
+    const head = token.slice(0, at);
+    const tail = token.slice(at + DIGEST.length);
+    return coordinate.startsWith(head) && coordinate.endsWith(tail)
+        && coordinate.length === head.length + tail.length + 64
+        && /^[0-9a-f]{64}$/.test(coordinate.slice(head.length, coordinate.length - tail.length));
+});
+const coordinatesOf = (store, place) => {
+    const roleOf = rolesOf(store);
+    const written = new Set((observeText(join(place, LOCK)) ?? '').split('\n').filter(isWire)
+        .map((line) => fieldOf(line, 'shape').split('/')[0] ?? ''));
+    const held = (coordinate) => !coordinate || (roleOf(coordinate) !== 'foreign' && (!coordinate.startsWith('.') || written.has(coordinate.split('/')[0] ?? '')));
+    const marks = assetsOf(store);
+    return coordinatesUnder(place, place, held).filter((coordinate) => held(coordinate) && !marked(coordinate, marks)).sort();
+};
+const stateOf = (place, files) => createHash('sha256').update(files.map((coordinate) => `${coordinate} ${stampOf(join(place, coordinate))?.stamp ?? ''}`).join('\n')).digest('hex');
+/**
+ * A release is named by the digest of its folder, and what is laid is read again from its bytes by the same method: every
+ * coordinate but those the tree's roles call foreign, a dotted one only where the folder's own lock writes into it, sorted, each a
+ * ustar entry of mode 0644, owner 0 and time 0, then two empty blocks, gzipped at level nine. The mark the host writes is
+ * none of those coordinates, so the digest of a place is the digest of the release laid there, or it is not that release.
+ */
+export function releaseDigest(store, place) {
+    const files = coordinatesOf(store, place);
+    const state = stateOf(place, files);
+    return { state, digest: memoized(store, `laid ${state}`, () => {
+            const blocks = [];
+            for (const coordinate of files) {
+                const bytes = Buffer.from(observeFile(join(place, coordinate)) ?? new Uint8Array());
+                const header = Buffer.alloc(512);
+                const cut = coordinate.length <= 100 ? -1 : coordinate.lastIndexOf('/');
+                header.write(cut < 0 ? coordinate : coordinate.slice(cut + 1), 0, 100, 'utf8');
+                header.write('0000644\0', 100, 8, 'utf8');
+                header.write('0000000\0', 108, 8, 'utf8');
+                header.write('0000000\0', 116, 8, 'utf8');
+                header.write(`${bytes.length.toString(8).padStart(11, '0')}\0`, 124, 12, 'utf8');
+                header.write('00000000000\0', 136, 12, 'utf8');
+                header.write('        ', 148, 8, 'utf8');
+                header.write('0', 156, 1, 'utf8');
+                header.write('ustar\0', 257, 6, 'utf8');
+                header.write('00', 263, 2, 'utf8');
+                header.write(cut < 0 ? '' : coordinate.slice(0, cut), 345, 155, 'utf8');
+                header.write(`${header.reduce((sum, byte) => sum + byte, 0).toString(8).padStart(6, '0')}\0 `, 148, 8, 'utf8');
+                blocks.push(header, bytes, Buffer.alloc((512 - (bytes.length % 512)) % 512));
+            }
+            blocks.push(Buffer.alloc(1024));
+            const archive = gzipSync(Buffer.concat(blocks), { level: 9 });
+            const digest = `sha256:${createHash('sha256').update(archive).digest('hex')}`;
+            landBlob(store, digest, archive);
+            return digest;
+        }) };
+}
+/**
+ * What the pass lands after it lays: for each release the own lock lays where it needs it, the digest its bytes give, by
+ * the stamps of the bytes it read. What is read is the receipt of the bytes as they lie now: none is a count, and one
+ * whose digest is not the one the lock names is a count.
+ */
+export function landLaid(store, own, lock, folder) {
+    if (folder === undefined)
+        return;
+    land(store, folder, releasesOf(lock).filter((line) => fieldOf(line, 'needs')).map((line) => ((got) => canonical({
+        scope: `${RECEIPT}${fieldOf(line, 'scope').slice('dep/'.length)}/digest`, role: 'writes', form: 'alphabet', measure: 'digest',
+        value: got.digest, by: folder, at: `place:${got.state}`,
+    }))(releaseDigest(store, join(own, fieldOf(line, 'needs'))))));
+}
+export const laidDiffers = (store, own, lock, folder) => {
+    const said = new Map((folder === undefined ? [] : ledgerLines(store, folder)).filter((line) => fieldOf(line, 'scope').startsWith(RECEIPT))
+        .map((line) => [`${fieldOf(line, 'scope')} ${fieldOf(line, 'at')}`, fieldOf(line, 'value')]));
+    return releasesOf(lock).filter((line) => fieldOf(line, 'needs')).filter((line) => {
+        const place = join(own, fieldOf(line, 'needs'));
+        return said.get(`${RECEIPT}${fieldOf(line, 'scope').slice('dep/'.length)}/digest place:${stateOf(place, coordinatesOf(store, place))}`) !== fieldOf(line, 'value');
+    }).length;
+};

package/dist/fold/nos.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A bug found lands as a no of the law it broke. From the epoch the lock asks for it on — the next one while no line
+ * asks yet, the epoch an accept would sign it at — every law of the place a witness names, a demand or a ceiling, holds
+ * its bug in a no: a need under the wire's sample family /<area>/no/, or a no of the place named after the law. What this
+ * counts is each law witnessed since then that holds none. When the lock lists no sample family, every such law is a
+ * demand: the folder is not guessed.
+ */
+export declare function bugsWithoutANo(root: string, store: string, standing: readonly string[], place: string, measure: string): number;

package/dist/fold/nos.js

@@ -0,0 +1,48 @@
+import { existsSync, join } from "../host/io.js";
+import { fieldOf } from "./claims.js";
+import { lockLines } from "./keys.js";
+import { wordsOf } from "./wire.js";
+import { entriesIn } from "../observe/files.js";
+const sampleWord = (standing, root, place) => wordsOf(standing, 'families').find((one) => [one, `${one}s`].some((name) => existsSync(join(root, place, name))));
+const noOf = (need, word) => {
+    const steps = need.split('/');
+    const i = steps.findIndex((step) => step === word || step === `${word}s`);
+    if (i < 0 || steps[i + 2] !== 'no')
+        return undefined;
+    const file = steps[i + 3];
+    return file === undefined || file.includes('*') ? undefined : file.replace(/\.[^.]+$/, '');
+};
+/**
+ * A bug found lands as a no of the law it broke. From the epoch the lock asks for it on — the next one while no line
+ * asks yet, the epoch an accept would sign it at — every law of the place a witness names, a demand or a ceiling, holds
+ * its bug in a no: a need under the wire's sample family /<area>/no/, or a no of the place named after the law. What this
+ * counts is each law witnessed since then that holds none. When the lock lists no sample family, every such law is a
+ * demand: the folder is not guessed.
+ */
+export function bugsWithoutANo(root, store, standing, place, measure) {
+    const epoch = (line) => Number(fieldOf(line, 'epoch'));
+    const asking = standing.filter((line) => fieldOf(line, 'measure') === measure && fieldOf(line, 'value') !== 'withdraw').map(epoch);
+    const from = asking.length ? Math.min(...asking) : lockLines(store).reduce((most, line) => Math.max(most, epoch(line)), 0) + 1;
+    const word = sampleWord(standing, root, place);
+    const nos = new Set();
+    for (const line of standing)
+        for (const need of fieldOf(line, 'needs').split('|').filter(Boolean)) {
+            const name = word === undefined ? undefined : noOf(need, word);
+            if (name)
+                nos.add(name);
+        }
+    if (word !== undefined) {
+        const dir = [word, `${word}s`].map((name) => join(root, place, name)).find((at) => existsSync(at));
+        if (dir !== undefined)
+            for (const area of entriesIn(dir).filter((one) => one.dir)) {
+                for (const one of entriesIn(join(dir, area.name, 'no')))
+                    nos.add(one.name.replace(/\.[^.]+$/, ''));
+            }
+    }
+    const named = (scope) => scope.slice(scope.lastIndexOf('/') + 1);
+    const holds = (line) => nos.has(named(fieldOf(line, 'scope')))
+        || (word !== undefined && fieldOf(line, 'needs').split('|').some((need) => noOf(need, word) !== undefined && existsSync(join(root, need))));
+    return standing.filter((line) => fieldOf(line, 'at').startsWith('witness:') && fieldOf(line, 'value') !== 'withdraw' && epoch(line) >= from
+        && fieldOf(line, 'scope').startsWith(`${place}/`)
+        && (fieldOf(line, 'role') === 'demands' || fieldOf(line, 'form') === 'interval') && !holds(line)).length;
+}

package/dist/fold/object.d.ts

@@ -0,0 +1,17 @@
+import type { Mark, Cell } from '@lapxo/obligations/views/field';
+import type { ObjectRecord, ObjectContext } from '@lapxo/topos/wire';
+/** Projection dispatches admitted acts into Obligatory; it defines no meet or propagation. */
+export interface ObjectReading {
+    cell: string;
+    state: string;
+    parts: Cell<unknown>;
+    rest: readonly string[];
+    ownMarks: readonly (string | undefined)[];
+    ownClaims: readonly {
+        id: string | undefined;
+        origin: string;
+    }[];
+    marks: readonly Mark<unknown>[];
+    claims: readonly unknown[];
+}
+export declare function objectFold(records: readonly ObjectRecord[], context: ObjectContext): readonly ObjectReading[];

package/dist/fold/object.js

@@ -0,0 +1,38 @@
+import { cell, sign, join, require as requireFloor, observe, mark, parts, state, live, restOf } from '@lapxo/obligations/views/field';
+import { restCoordinates } from '@lapxo/topos/wire';
+export function objectFold(records, context) {
+    let world = new Map();
+    const definitions = new Map(records.filter(r => r.record === 'cell').map(r => [r.fields.scope, r]));
+    const codecs = new Map([...definitions].map(([name, c]) => [name, context.resolve(c)]));
+    const ids = new Map(records.map(r => [r.fields.id, r]));
+    for (const record of [...records].sort((a, b) => Number(a.fields.epoch) - Number(b.fields.epoch))) {
+        const f = record.fields, name = f.scope, at = Number(f.epoch);
+        if (record.record === 'cell') {
+            world = new Map([...world, [name, cell(name, at, [], restCoordinates(f.restsOn))]]);
+            continue;
+        }
+        const codec = codecs.get(name), L = codec.form.lattice(codec.params), held = world.get(name);
+        if (record.record === 'claim') {
+            const target = f.sign === '-1' ? ids.get(f.takes).fields : f;
+            const changed = observe(held, { id: f.id, at, origin: target.origin, span: codec.form.parse(codec.params, target.value), ...(f.takes ? { takes: f.takes } : {}) }, f.sign === '-1' ? -1 : 1);
+            const seen = [...changed.seen];
+            seen[seen.length - 1] = { ...seen.at(-1), id: f.id };
+            world = new Map([...world, [name, { ...changed, seen }]]);
+        }
+        else if (f.sign === '-1') {
+            const target = ids.get(f.takes).fields;
+            world = new Map([...world, [name, { ...held, marks: [...(held.marks ?? []), mark({ id: f.id, at, takes: f.takes, pole: target.pole, reach: 'local', span: codec.form.parse(codec.params, target.value) })] }]]);
+        }
+        else if (f.widens !== undefined) {
+            const changed = join(L, held, codec.form.parse(codec.params, f.value), f.widens, at);
+            const marks = [...(changed.marks ?? [])];
+            marks[marks.length - 1] = { ...marks.at(-1), id: f.id };
+            world = new Map([...world, [name, { ...changed, marks }]]);
+        }
+        else {
+            const span = codec.form.parse(codec.params, f.value);
+            world = f.pole === 'floor' ? requireFloor(L, world, name, span, { id: f.id, at }) : sign(L, world, name, span, { id: f.id, at });
+        }
+    }
+    return [...world].map(([name, c]) => { const codec = codecs.get(name), L = codec.form.lattice(codec.params); return { cell: name, state: state(L, c, world), parts: parts(L, c, world), rest: restOf(c, world), ownMarks: live(c.marks ?? []).map(m => m.id), ownClaims: live(c.seen).map(s => ({ id: s.id, origin: s.origin })), marks: live(c.marks ?? []), claims: live(c.seen) }; });
+}

package/dist/fold/observed.d.ts

@@ -0,0 +1,33 @@
+export declare const cased: (question: string) => boolean;
+export declare function isReaderLock(line: string): boolean;
+export declare function readerModules(store: string): readonly string[];
+type Placed = {
+    readonly question: string;
+    readonly measure: string;
+    readonly value: string;
+    readonly place: string;
+    readonly by: string;
+    readonly at: string;
+};
+export declare function placedReadings(observed: readonly string[]): readonly Placed[];
+export declare function casesHeld(observed: readonly string[]): number;
+export declare const readersBehind: () => readonly {
+    readonly module: string;
+    readonly places: number;
+}[];
+export declare function readerLines(store: string): readonly string[];
+/**
+ * A reader never blocks a fold that did not ask to wait: what it read before is served at once, and a reader whose
+ * identity is new, or whose places moved, is grey by name and runs behind the fold. A fold that judges waits. A fold
+ * that reaches only some regions observes only those, and a place with no reader reads what it carries.
+ */
+export declare const carriesOnly: (root: string, store: string) => boolean;
+/** A reader whose `needs` meet the reach runs, wherever its module lives. The module path is not the region it reads. */
+export declare function readerReaches(reach: readonly string[] | undefined, where: readonly string[]): boolean;
+export declare function observedClaims(root: string, store: string, options?: {
+    readonly wait?: boolean;
+    readonly only?: string;
+    readonly reach?: readonly string[];
+    readonly answered?: Map<string, string>;
+}): readonly string[];
+export {};