@lapxo/head 0.1.4 → 0.1.5

package/dist/src/ahead/budget.d.ts

@@ -0,0 +1,6 @@
+import type { Asked } from '../core/answer.ts';
+import type { Said } from '../core/lock.ts';
+/** Whether a read would spend past what the place allows: a question, past the place's rate; a read ahead, past the share of what the questions leave of it that reads ahead may spend. A read ahead is told by the mark beside its receipt, and counted once. */
+export declare const overOf: (lines: readonly Said[], [family, at, mark]: readonly [string, string, string], source: string, now: number, rate: number, share: number, asked: Asked) => boolean;
+/** The mark a read made ahead lands beside its receipt, under the receipt's own at, so what reads ahead spent is counted apart from what questions spent. */
+export declare const markOf: (asked: Asked, [at, mark]: readonly [string, string], scope: string, digest: string, when: string) => readonly string[];

package/dist/src/ahead/budget.js

@@ -0,0 +1,11 @@
+import { canonical } from '@lapxo/topos/wire';
+import { spentOf } from "../core/receipt.js";
+const early = (asked) => asked['ahead'] === 'true';
+/** Whether a read would spend past what the place allows: a question, past the place's rate; a read ahead, past the share of what the questions leave of it that reads ahead may spend. A read ahead is told by the mark beside its receipt, and counted once. */
+export const overOf = (lines, [family, at, mark], source, now, rate, share, asked) => {
+    const ahead = lines.filter((l) => l.scope?.startsWith(`${family}/${source}/`) && l.scope.endsWith(`/${mark}`) && l.at?.startsWith(`${at}:`) && now - Date.parse(l.at.slice(at.length + 1)) < 3_600_000).length;
+    const calls = spentOf(lines, family, at, source, now) - ahead;
+    return calls >= rate || (early(asked) && ahead + 1 > ((rate - (calls - ahead)) * share) / 100);
+};
+/** The mark a read made ahead lands beside its receipt, under the receipt's own at, so what reads ahead spent is counted apart from what questions spent. */
+export const markOf = (asked, [at, mark], scope, digest, when) => early(asked) ? [canonical({ at: `${at}:${when}`, by: 'target', form: 'alphabet', measure: 'digest', role: 'writes', scope: `${scope}/${mark}`, value: digest })] : [];

package/dist/src/ahead/fold.d.ts

@@ -0,0 +1,2 @@
+/** A refused identity cannot validate an old answer. The reader binds new text to the expected identity. */
+export declare const folded: <T>(kind: string, place: string, identity: () => Promise<string | undefined>, read: (expected?: string) => Promise<T>) => Promise<T>;

package/dist/src/ahead/fold.js

@@ -0,0 +1,19 @@
+/** Cached projections are indexed only by identities returned by the instrument. */
+const kept = new Map();
+/** A refused identity cannot validate an old answer. The reader binds new text to the expected identity. */
+export const folded = async (kind, place, identity, read) => {
+    const key = `${kind}\0${place}`, current = await identity(), held = kept.get(key);
+    if (current === undefined) {
+        kept.delete(key);
+        return read();
+    }
+    if (held?.identity === current)
+        return held.folded;
+    const reading = read(current);
+    kept.set(key, { identity: current, folded: reading });
+    const forget = () => { if (kept.get(key)?.folded === reading)
+        kept.delete(key); };
+    reading.then((result) => { if (result && typeof result === 'object' && 'refused' in result)
+        forget(); }, forget);
+    return reading;
+};

package/dist/src/ahead/read.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../core/answer.ts';
+import type { Cell } from '../ports/surface.ts';
+/**
+ * What an answer leaves to do before the next call, done after it is answered; another call coming gives up what is not
+ * begun, never what is, so no land is cut halfway:
+ * the reads a known next asks for, read in a context that asks the person nothing — a read only, never an act, nothing it
+ * would need a yes or a secret for — and then every place the answer names folded again where it moved, so the next
+ * question finds it folded. A fold calls no source, so it spends nothing of a place's rate.
+ */
+export declare const readAhead: (cells: readonly Cell[], context: Context, signal: AbortSignal) => Promise<void>;

package/dist/src/ahead/read.js

@@ -0,0 +1,18 @@
+import { readSource } from "../flows/read.js";
+const none = async () => 'none', nothing = async () => undefined;
+/**
+ * What an answer leaves to do before the next call, done after it is answered; another call coming gives up what is not
+ * begun, never what is, so no land is cut halfway:
+ * the reads a known next asks for, read in a context that asks the person nothing — a read only, never an act, nothing it
+ * would need a yes or a secret for — and then every place the answer names folded again where it moved, so the next
+ * question finds it folded. A fold calls no source, so it spends nothing of a place's rate.
+ */
+export const readAhead = async (cells, context, signal) => {
+    const quiet = { ...context, elicit: none, person: { consent: none, enter: nothing, choose: nothing, visit: nothing } };
+    for (const { next } of cells)
+        if (!signal.aborted && 'tool' in next && next.tool === 'ask' && next.args['source'] && next.args['operation'] && !next.args['why'] && !next.args['history'])
+            await readSource({ ...next.args, ahead: 'true' }, quiet);
+    await quiet.settle();
+    for (const place of new Set(cells.flatMap((c) => [c.fields['place'] ?? '', 'tool' in c.next ? c.next.args['place'] ?? '' : '']).filter((p) => p && !signal.aborted)))
+        await Promise.all([context.standing(place), context.policy(place)]).catch(() => undefined);
+};

package/dist/src/claims/claim.d.ts

@@ -0,0 +1,9 @@
+import { type Asked, type Context } from '../core/answer.ts';
+/**
+ * What the person states, kept as theirs: a line their own key attests, their words exactly as given, in the place named;
+ * asked once a conversation whether what they state there is kept, and each statement said back as it goes in, so they see
+ * it, with who carried it here as the client says it is. Taken back by the same words: what a person attests is evidence, and
+ * stands for good, so taking it back is attesting that, beside it. A place whose lines admit no carrier is handed the line that does.
+ * Only this action keeps one, never a cell, an answer or a read ahead, so nothing the model concluded becomes the person's.
+ */
+export declare const claimed: (asked: Asked, context: Context) => Promise<readonly string[]>;

package/dist/src/claims/claim.js

@@ -0,0 +1,40 @@
+import { createHash } from 'node:crypto';
+import { canonical } from '@lapxo/topos/wire';
+import { inPlace, standingOr, unless } from "../core/answer.js";
+import { uncoveredIn } from "../core/device.js";
+import { aboutOf, members, valueOf } from "../core/lock.js";
+import { fill, sayIn } from "../core/surface.js";
+/** Whether the person said, in this conversation, that what they state in a place is kept as theirs: asked once a place, a no kept as a yes is. */
+const answered = new Map();
+/**
+ * What the person states, kept as theirs: a line their own key attests, their words exactly as given, in the place named;
+ * asked once a conversation whether what they state there is kept, and each statement said back as it goes in, so they see
+ * it, with who carried it here as the client says it is. Taken back by the same words: what a person attests is evidence, and
+ * stands for good, so taking it back is attesting that, beside it. A place whose lines admit no carrier is handed the line that does.
+ * Only this action keeps one, never a cell, an answer or a read ahead, so nothing the model concluded becomes the person's.
+ */
+export const claimed = (asked, context) => inPlace(asked, context, async (place) => {
+    const [say, word, said, held] = [sayIn(context.lock), (k) => valueOf(context.lock, k), (asked['said'] ?? '').trim(), await standingOr(context, place)];
+    if ('said' in held)
+        return held.said;
+    if (!said)
+        return [say('missing-param', { operation: 'claim', param: 'said' })];
+    const [family, withdraw, back] = [`${word('claim/family')}/${createHash('sha256').update(said).digest('hex').slice(0, 16)}`, asked['withdraw'] === 'true', word('claim/withdrawn')];
+    const standing = held.lines.filter((l) => l.scope?.startsWith(`${family}/`) && !l.scope.endsWith(`/${back}`) && !held.lines.some((w) => w.scope === `${l.scope}/${back}`)).map((l) => l.scope);
+    if (withdraw && !standing.length)
+        return [say('claim-none', { place, said })];
+    const wire = held.lines.find((l) => l.scope === 'wire/fields'), via = word('claim/via');
+    const bare = wire && Object.fromEntries(Object.entries(wire).filter(([k]) => !['sig', 'epoch', 'about'].includes(k)));
+    if (bare && !members(wire.value ?? '').includes(via))
+        return [say('claims-unadmitted', { place, lines: [canonical({ ...bare, by: 'target', value: 'withdraw' }), canonical({ ...bare, by: 'target', at: `policy:head/wire/${new Date(context.now()).toISOString()}`, value: `${wire.value}|${via}` })].join('\n') })];
+    const line = (scope) => canonical({ about: said, at: word('claim/at'), by: 'target', form: 'alphabet', measure: 'text', role: 'writes', scope, value: 'lock', [via]: context.client() ?? word('claim/via-unknown') });
+    const lot = withdraw ? standing.map((scope) => line(`${scope}/${back}`)) : [line(`${family}/${new Date(context.now()).toISOString().replace(/\D/g, '')}`)], outside = uncoveredIn(context.lock, held.lines, context.device('person'), place, lot);
+    if (outside)
+        return outside;
+    if (!withdraw && !answered.has(place))
+        answered.set(place, (await unless(context, fill(aboutOf(context.lock, 'said/elicit-claims'), { place }))) === undefined);
+    if (!withdraw && !answered.get(place))
+        return [say('claims-declined', { place, said })];
+    const landed = await context.landAs(place, lot, 'person', held.lines);
+    return 'refused' in landed ? [say('not-landed', { why: landed.refused })] : [say(withdraw ? 'unclaimed' : 'claimed', { place, said }), ...landed.lines];
+});

package/dist/src/core/answer.d.ts

@@ -15,6 +15,7 @@ export interface Context {
     readonly lock: readonly Said[];
     readonly bound: (cwd: string, args: readonly string[]) => Promise<Printed | undefined>;
     readonly roots: () => Promise<readonly string[]>;
+    readonly client: () => string | undefined;
     readonly keys: KeyStore;
     readonly device: (role: string) => string | undefined;
     readonly standing: (place: string) => Promise<{

package/dist/src/core/package.js

@@ -5,6 +5,7 @@ import { members, under, valueOf } from "./lock.js";
 import { fieldsOf, vocabOf } from "./read.js";
 import { sayIn } from "./surface.js";
 import { digestIn, linesOf } from "./worlds.js";
+import { linkOf } from "../links/link.js";
 /** A line no package carries: one that is not a world, or a source's document, overlay or pin, said once by digest — with, beside a digest that names bytes, the encrypted address they are read at. */
 export const foreignIn = (lines) => lines.find((l) => !/^(sources\/[a-z0-9-]+(\/overlay)?|uses\/[a-z0-9-]+)$/.test(l.scope ?? '') || lines.some((o) => o !== l && o.scope === l.scope && o.measure === l.measure)
     || (l.measure !== 'digest' && !(l.measure === 'id' && URL.canParse(l.value ?? '') && lines.some((o) => o.scope === l.scope && o.measure === 'digest' && o.needs))));
@@ -27,13 +28,13 @@ export const shared = (asked, context) => inPlace(asked, context, async (place)
         return [say('share-to', { place, to })];
     if ('said' in held)
         return held.said;
-    const pack = packed(context, place, held.lines, ((u) => (u && typeof u === 'object' ? u : {}))((() => { try {
+    const urls = ((u) => (u && typeof u === 'object' ? u : {}))((() => { try {
         return JSON.parse(asked['urls'] || '{}');
     }
     catch {
         return {};
-    } })())), bytes = new TextEncoder().encode(`${pack.lines.join('\n')}\n`);
-    return !pack.names.length ? [say('share-none', { place })] : ([...pack.files, [LOCK, bytes]].forEach(([at, laid]) => context.files.lay(to, at, laid)), [say('shared', { place, to, sources: pack.names.join(', '), digest: digestIn(context.lock)(bytes) }), ...pack.lines]);
+    } })()), pack = packed(context, place, held.lines, urls), bytes = new TextEncoder().encode(`${pack.lines.join('\n')}\n`);
+    return !pack.names.length ? [say('share-none', { place })] : ([...pack.files, [LOCK, bytes]].forEach(([at, laid]) => context.files.lay(to, at, laid)), [say('shared', { place, to, sources: pack.names.join(', '), digest: digestIn(context.lock)(bytes) }), ...linkOf(context, to, pack.lines, urls), ...pack.lines]);
 });
 /** What a package names, checked whole before anything is asked: every line a world or a source's document, overlay or pin, by digest; each world the one this head pins; an order its pins rest in. A source whose bytes did not arrive, or did not hash to their line, is open, and so is every source resting on it: absence is not a refusal, and the rest arrives. */
 export const unpacked = (context, document, bytes, read) => {

package/dist/src/flows/call.js

@@ -64,7 +64,7 @@ export const called = async (asked, context, planOf, then) => {
         if ('refused' in prepared)
             return say(prepared.refused, { source, origin: plan.origin });
         const most = (scope) => Number((lines.find((l) => l.scope === scope)?.value ?? '0..0').split('..')[1]);
-        const typed = async (status, bytes) => ((got) => ['lines' in got ? say('answered', { source, operation, status })[0] : say('untyped', { source, operation, status, why: got.untyped })[0], ...('lines' in got ? got.lines : [])])(await typedAnswer(context, place, lines, source, operation, prepared.key, bytes));
+        const typed = async (status, bytes) => ((got, at) => ['lines' in got ? say('answered', { source, operation, status, at })[0] : say('untyped', { source, operation, status, at, why: got.untyped })[0], ...('lines' in got ? got.lines : [])])(await typedAnswer(context, place, lines, source, operation, prepared.key, bytes), new Date(context.now()).toISOString());
         const lands = (...lot) => context.landAs(place, lot, 'head', lines);
         const attach = async () => ((got) => ('said' in got ? { said: say(got.said, { source, operation, kinds: plan.access.kind, input: got.input }) } : got))(await attachmentFor(context, place, lines, plan));
         const uncovered = (role, scopes) => uncoveredIn(context.lock, lines, context.device(role), place, [], scopes);

package/dist/src/flows/read.js

@@ -1,6 +1,6 @@
 import { under } from "../core/lock.js";
 import { observedAt, planRead } from "../core/read.js";
-import { basisOf, draftOf, receiptsOf, scopeOf, spentOf } from "../core/receipt.js";
+import { basisOf, draftOf, receiptsOf, scopeOf } from "../core/receipt.js";
 import { redIn, sayIn } from "../core/surface.js";
 import { grantedOf, isOpen, untilOf } from "../core/act.js";
 import { canonical } from '@lapxo/topos/wire';
@@ -8,6 +8,8 @@ import { called } from "./call.js";
 import { principalOf } from "../access/obtain.js";
 import { jsonOf } from "../access/contract.js";
 import { refusedAccess } from "../sources/refused.js";
+import { hand, keptOf } from "../kept/kept.js";
+import { markOf, overOf } from "../ahead/budget.js";
 /** An intent an earlier act left open, closed by the read that looked at what it would have changed: a line naming that read-s digest, signed by head. */
 const closeWith = async (intent, source, digest, { word, lines, lands }, context) => {
     const say = sayIn(context.lock);
@@ -30,7 +32,7 @@ export const readSource = (asked, context) => called(asked, context, planRead, a
     const closing = (digest) => closeWith(asked['closes'], source, digest, { word, lines, lands }, context);
     const scopes = (principal) => [scopeOf(family, source, operation, prepared.key, principal), `${scopeOf(word('receipt/kept'), source, operation, prepared.key, principal)}/${basisOf(lines, word, source)}`];
     const held = (digest) => ((bytes) => (bytes === undefined || digest === undefined ? undefined : { digest, bytes }))(digest === undefined ? undefined : context.cache.held(digest));
-    const keeping = (kept, answer) => (answer.length > 1 ? [draftOf(word('receipt/kept'), at, kept, context.cache.keep(Buffer.from(answer.join('\n'))), when)] : []);
+    const keeping = (kept, answer) => (answer.length > 1 ? [draftOf(word('receipt/kept'), at, kept, (asked['ahead'] === 'true' ? String : hand)(context.cache.keep(Buffer.from(answer.join('\n')))), when)] : []);
     const allowed = (key, measure) => (lines.find((l) => l.scope === `${word(key)}/${source}` && l.measure === measure) ?? lines.find((l) => l.scope === word(key) && l.measure === measure))?.value;
     if (asked['why'] === 'true') {
         const asOf = principalOf(context, plan, false), [newest] = asOf === undefined ? [] : receiptsOf(lines, at, scopes(asOf)[0]), pin = lines.find((l) => l.scope === `uses/${source}`);
@@ -54,36 +56,35 @@ export const readSource = (asked, context) => called(asked, context, planRead, a
     if (stopped)
         return stopped;
     if (!grantedOf(lines, word('grant/family'), source, context.now())) {
+        if (asked['ahead'] === 'true')
+            return [];
         const sources = [...new Set(lines.filter((l) => l.scope?.startsWith(`${word('vocab/region')}/`) && l.measure === word('vocab/origins')).map((l) => l.scope.split('/')[1]))].sort();
         const until = untilOf(word('access/period'), context.now());
-        const line = (measure, value) => canonical({ at: 'policy:person/grants', by: 'target', form: 'alphabet', measure, role: 'writes', scope: word('grant/family'), value });
-        const granted = await widen(say('grant', { sources: sources.join(', '), place, until })[0], [line('sources', sources.join('|')), line('until', until)]);
+        const line = (measure, value) => canonical({ at: `policy:person/grants/${new Date(context.now()).toISOString()}`, by: 'target', form: 'alphabet', measure, role: 'writes', scope: word('grant/family'), value });
+        const before = [...new Set(lines.filter((l) => l.scope === word('grant/family')).map(({ about: _about, sig: _sig, epoch: _epoch, ...l }) => canonical({ ...l, by: 'target', value: 'withdraw' })))];
+        const granted = await widen(say('grant', { sources: sources.join(', '), place, until })[0], [...before, line('sources', sources.join('|')), line('until', until)]);
         if ('said' in granted)
             return granted.said;
     }
-    const reuse = Number(/^\d+\.\.(\d+)$/.exec(allowed('reuse/family', 'seconds') ?? '')?.[1] ?? Number.NaN);
-    const [newest] = principal === undefined ? [] : receiptsOf(lines, at, scopes(principal)[0]), stood = ((b) => b !== undefined && Number(Buffer.from(b.bytes.subarray(0, b.bytes.indexOf(10))).toString('utf8')) < 300)(held(newest?.digest));
-    if (principal !== undefined && newest !== undefined && stood && context.now() - Date.parse(newest.at) <= reuse * 1000) {
-        const [scope, kept] = scopes(principal);
-        const answered = held(receiptsOf(lines, at, kept).find((k) => k.at >= newest.at)?.digest);
-        if (answered !== undefined)
-            return [...new TextDecoder().decode(answered.bytes).split('\n'), ...say('reused', { scope: kept, digest: answered.digest, at: newest.at }), ...(await closing(newest.digest)), ...redIn(context.lock)('answer/kept', `answer/${source}/${operation}`, context.begun, context.machine())];
-        const body = held(newest.digest);
-        if (body !== undefined) {
-            const cut = body.bytes.indexOf(10);
-            const answer = await typed(Buffer.from(body.bytes.subarray(0, cut)).toString('utf8'), body.bytes.subarray(cut + 1));
-            const keptLines = keeping(kept, answer);
-            const landed = keptLines.length ? await lands(...keptLines) : { lines: [] };
-            return [...answer, ...say('reread', { scope, digest: body.digest, at: newest.at }), ...('lines' in landed ? landed.lines : []), ...(await closing(body.digest))];
-        }
+    const was = principal === undefined ? undefined : keptOf(lines, at, scopes(principal), grantedOf(lines, word('grant/family'), source, context.now()), allowed('reuse/family', 'seconds'), context.now(), held);
+    if (was?.kind === 'kept')
+        return [...(was.bytes ? [...new TextDecoder().decode(was.bytes).split('\n'), ...say('reused', { scope: scopes(principal)[1], digest: hand(was.digest), at: was.at, receipt: was.receipt })] : say('kept', { source, operation, at: was.at, digest: was.digest, receipt: was.receipt })),
+            ...(await closing(was.receipt)), ...redIn(context.lock)('answer/kept', `answer/${source}/${operation}`, context.begun, context.machine())];
+    if (was?.kind === 'reread') {
+        const answer = await typed(Buffer.from(was.bytes.subarray(0, was.bytes.indexOf(10))).toString('utf8'), was.bytes.subarray(was.bytes.indexOf(10) + 1)), keptLines = keeping(scopes(principal)[1], answer);
+        const landed = keptLines.length ? await lands(...keptLines) : { lines: [] };
+        return [...answer, ...say('reread', { scope: scopes(principal)[0], digest: was.digest, at: was.at, receipt: was.digest }), ...('lines' in landed ? landed.lines : []), ...(await closing(was.digest))];
     }
-    if (spentOf(lines, family, at, source, context.now()) >= most('read/rate'))
-        return say('rate', { source });
+    const again = was?.kind === 'again' ? say(`kept-${was.why}`, { source, operation, at: was.at }) : [];
+    if (overOf(lines, [family, at, word('ahead/mark')], source, context.now(), most('read/rate'), Number(word('ahead/share').split('..')[1]), asked))
+        return asked['ahead'] === 'true' ? [] : say('rate', { source });
     const attached = await attach();
     if ('said' in attached)
         return attached.said;
     const [scope, kept] = scopes(attached.principal ?? '');
     const got = await send(attached.attachment);
+    if (asked['ahead'] === 'true' && (got.kind !== 'got' || got.status >= 300))
+        return [];
     if (got.kind !== 'got')
         return say(got.kind === 'over' ? 'too-large' : 'unreachable-source', { source });
     if (got.status === 401 && attached.principal !== 'anonymous')
@@ -93,6 +94,6 @@ export const readSource = (asked, context) => called(asked, context, planRead, a
     const observed = plan.access.probe && got.status < 300 ? [canonical({ at: `${at}:${when}`, by: 'target', form: 'alphabet', measure: word('vocab/access'), role: 'writes', scope: observedAt(context.lock, source, operation), value: word('vocab/anonymous') })] : [];
     const found = plan.access.probe && got.status === 401 && got.authenticate ? await (await context.access(word('access/adapter')))?.discover?.(plan.origin, got.authenticate, async (url) => jsonOf((await context.files.read.documentOf(context, place, url))?.bytes ?? new Uint8Array())) : undefined;
     const by = `${word('access/family')}/${source}/${word('access/authorizer')}`, authorizer = Object.entries(found ?? {}).flatMap(([k, f]) => Object.entries(f).map(([measure, all]) => canonical({ at: `${at}:${when}`, by: 'target', form: 'alphabet', measure, role: 'writes', scope: k ? `${by}/${k}` : by, value: all.join('|') })));
-    const landed = await lands(draftOf(family, at, scope, digest, when), ...(attached.principal === undefined ? [] : keeping(kept, answer)), ...observed, ...authorizer);
-    return [...answer, ...('lines' in landed ? [...landed.lines, ...(await closing(digest))] : say('not-landed', { why: landed.refused })), ...(found?.['']?.['issuer'] && 'lines' in landed ? say('authorizer-observed', { source, issuer: found['']['issuer'][0] }) : [])];
+    const landed = await lands(draftOf(family, at, scope, digest, when), ...markOf(asked, [at, word('ahead/mark')], scope, digest, when), ...(attached.principal === undefined ? [] : keeping(kept, answer)), ...observed, ...authorizer);
+    return [...again, ...answer, ...('lines' in landed ? [...landed.lines, ...(await closing(digest))] : say('not-landed', { why: landed.refused })), ...(found?.['']?.['issuer'] && 'lines' in landed ? say('authorizer-observed', { source, issuer: found['']['issuer'][0] }) : [])];
 });

package/dist/src/index.js

@@ -27,18 +27,21 @@ import { keychain } from "./ports/keychain.js";
 import { algorithmOf, deviceOf, idIn } from "./core/device.js";
 import { publicOf } from "./ports/keys.js";
 import { personOf } from "./ports/access/person.js";
+import { readAhead } from "./ahead/read.js";
 const [ext, root] = ((self) => [self.slice(self.lastIndexOf('.')), fileURLToPath(new URL(self.endsWith('.ts') ? '..' : '../..', self))])(import.meta.url);
 const lock = lockAt(root);
 const surface = surfaceOf(lock);
 const runs = valueOf(lock, 'runs');
-Object.assign(words, Object.fromEntries(['read', 'view', 'sign', 'land', 'key', 'signer', 'pin', 'topos', 'standing', 'evidence', 'act', 'profile', 'receipts', 'refusal'].map((w) => [w, valueOf(lock, `bound/${w}`)])));
+Object.assign(words, Object.fromEntries(['read', 'view', 'sign', 'land', 'key', 'signer', 'pin', 'topos', 'standing', 'evidence', 'act', 'profile', 'receipts', 'refusal', 'identity'].map((w) => [w, valueOf(lock, `bound/${w}`)])));
 Object.assign(limits, { wait: Number(valueOf(lock, 'bound/wait').split('..')[1]), most: Number(valueOf(lock, 'bound/printed').split('..')[1]) });
 Object.assign(warmth, { spares: Number(valueOf(lock, 'bound/spares').split('..')[1]), boot: valueOf(lock, 'bound/spare-env').split('|') });
 /** One call at a time, each after the one before it and never on a timer, so one asked while another lands sees its receipt; bound started ahead for it, and nothing of it kept once it is answered. */
-let last = Promise.resolve();
+let [last, ahead] = [Promise.resolve(), new AbortController()];
 const turn = (act) => ((next) => { last = next.catch(() => undefined); return next; })(last.then(() => { void warm(runs); return act().finally(cooled); }));
+for (const end of ['SIGTERM', 'SIGINT'])
+    process.once(end, () => void last.finally(() => process.exit(0)));
 const offered = (n) => (n ? { listChanged: false } : undefined);
-const server = new Server({ name: surface.name, version: surface.version }, { capabilities: { tools: offered(surface.tools.length), resources: offered(surface.resources.length), prompts: offered(surface.prompts.length) } });
+const server = new Server({ name: surface.name, version: surface.version }, { capabilities: { tools: offered(surface.tools.length), resources: offered(surface.resources.length), prompts: offered(surface.prompts.length) }, instructions: aboutOf(lock, 'prose/en/instructions') });
 /** The person, asked as the client lets head ask; every wait on them is counted, so a time ceiling measures head's work and never the person's. */
 let waited = 0;
 const timed = (ask) => async (...args) => { const t = Date.now(); try {
@@ -103,7 +106,7 @@ const contextOf = (signal) => {
         begun: Date.now() - waited,
         keys,
         device,
-        roots: async () => (server.getClientCapabilities()?.roots ? (await server.listRoots()).roots.flatMap((root) => folderOf(root.uri) ?? []) : []),
+        roots: async () => (server.getClientCapabilities()?.roots ? (await server.listRoots()).roots.flatMap((root) => folderOf(root.uri) ?? []) : []), client: () => ((c) => (c ? `${c.name}@${c.version}` : undefined))(server.getClientVersion()),
     };
 };
 const askedOf = (raw) => Object.fromEntries(Object.entries(raw ?? {}).map(([k, v]) => [k, v === undefined ? undefined : typeof v === 'object' ? JSON.stringify(v) : String(v)]));
@@ -113,14 +116,15 @@ if (surface.tools.length)
     server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: surface.tools.map((tool) => ({ name: tool.name, description: tool.about,
             inputSchema: schemaOf([...tool.fields]), outputSchema: shapeSchema(lock), annotations: Object.fromEntries(tool.hints.map((hint) => [`${hint}Hint`, true])) })) }));
 if (surface.tools.length)
-    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => turn(async () => {
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => (ahead.abort(), turn(async () => {
         const tool = surface.tools.find((one) => one.name === request.params.name);
         if (tool === undefined)
             return { isError: true, content: [] };
         const refused = refusedOn(lock, process.platform);
         const context = contextOf(extra.signal), answer = refused !== undefined ? [refused] : extra.signal.aborted ? [] : [...await (await answerOf('tools', tool.name))(askedOf(request.params.arguments), context), ...await context.settle()];
+        void ((early) => turn(() => readAhead(shapeOf(answer).cells, contextOf(), early.signal)))(ahead = new AbortController());
         return { content: [{ type: 'text', text: answer.join('\n') }], structuredContent: shapeOf(answer) };
-    }));
+    })));
 if (surface.resources.length)
     server.setRequestHandler(ListResourcesRequestSchema, () => ({ resources: [] }));
 if (surface.resources.length)

package/dist/src/kept/kept.d.ts

@@ -0,0 +1,30 @@
+import type { Said } from '../core/lock.ts';
+export declare const hand: (digest: string) => string;
+type Held = (digest: string | undefined) => {
+    readonly digest: string;
+    readonly bytes: Uint8Array;
+} | undefined;
+export type Was = {
+    readonly kind: 'kept';
+    readonly at: string;
+    readonly digest: string;
+    readonly receipt: string;
+    readonly bytes?: Uint8Array;
+} | {
+    readonly kind: 'reread';
+    readonly at: string;
+    readonly digest: string;
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: 'again';
+    readonly at: string;
+    readonly why: 'withdrawn' | 'changed' | 'expired';
+};
+/**
+ * A question read before, as its receipts and the place stand now. Where the place declares a reuse and the newest read
+ * stood, it is kept — its bytes only where this conversation does not hold them yet — or typed again from its receipt if
+ * nothing typed was kept; but read again, and why, where the person's grant had to be given again, the source is pinned
+ * otherwise than when it was read, or the read is older than the reuse allows. Never read, or no reuse: nothing is said.
+ */
+export declare const keptOf: (lines: readonly Said[], at: string, [read, kept]: readonly [string, string], granted: boolean, reuse: string | undefined, now: number, held: Held) => Was | undefined;
+export {};

package/dist/src/kept/kept.js

@@ -0,0 +1,20 @@
+import { receiptsOf } from "../core/receipt.js";
+/** The typed answers this conversation already holds, by digest: head is one process a conversation, so they last as long as it. */
+const handed = new Set();
+export const hand = (digest) => (handed.add(digest), digest);
+/**
+ * A question read before, as its receipts and the place stand now. Where the place declares a reuse and the newest read
+ * stood, it is kept — its bytes only where this conversation does not hold them yet — or typed again from its receipt if
+ * nothing typed was kept; but read again, and why, where the person's grant had to be given again, the source is pinned
+ * otherwise than when it was read, or the read is older than the reuse allows. Never read, or no reuse: nothing is said.
+ */
+export const keptOf = (lines, at, [read, kept], granted, reuse, now, held) => {
+    const [newest] = receiptsOf(lines, at, read), body = held(newest?.digest), window = Number(/^\d+\.\.(\d+)$/.exec(reuse ?? '')?.[1] ?? Number.NaN);
+    if (newest === undefined || body === undefined || Number.isNaN(window) || Number(Buffer.from(body.bytes.subarray(0, body.bytes.indexOf(10))).toString('utf8')) >= 300)
+        return undefined;
+    const typed = receiptsOf(lines, at, kept.slice(0, kept.lastIndexOf('/')), true).filter((k) => k.at >= newest.at), answered = held(typed.find((k) => k.scope === kept)?.digest);
+    const why = !granted ? 'withdrawn' : typed.length && !typed.some((k) => k.scope === kept) ? 'changed' : now - Date.parse(newest.at) > window * 1000 ? 'expired' : undefined;
+    if (why !== undefined)
+        return { kind: 'again', at: newest.at, why };
+    return answered === undefined ? { kind: 'reread', at: newest.at, digest: body.digest, bytes: body.bytes } : { kind: 'kept', at: newest.at, digest: answered.digest, receipt: newest.digest, ...(handed.has(answered.digest) ? {} : { bytes: answered.bytes }) };
+};

package/dist/src/links/inspect.d.ts

@@ -0,0 +1,8 @@
+import { type Asked, type Context } from '../core/answer.ts';
+/**
+ * A #bound: link connected: inspected by the instrument in the person's place, never authenticated — its bytes are the
+ * link's, and nothing shows who shared it — and what it names is shown; nothing is connected or granted, since a package
+ * is received by the digest its sharer sent apart. A place that admits no content transport is handed the lines that admit
+ * one, to sign; bytes that do not arrive are owed by the link until they do; bytes that are not what it names are refused.
+ */
+export declare const linked: (asked: Asked, context: Context) => Promise<readonly string[]>;

package/dist/src/links/inspect.js

@@ -0,0 +1,41 @@
+import { decodeReference } from '@lapxo/bound/reference';
+import { canonical } from '@lapxo/topos/wire';
+import { inPlace, standingOr } from "../core/answer.js";
+import { members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+import { linesOf } from "../core/worlds.js";
+import { rootIn } from "../flows/device.js";
+/**
+ * A #bound: link connected: inspected by the instrument in the person's place, never authenticated — its bytes are the
+ * link's, and nothing shows who shared it — and what it names is shown; nothing is connected or granted, since a package
+ * is received by the digest its sharer sent apart. A place that admits no content transport is handed the lines that admit
+ * one, to sign; bytes that do not arrive are owed by the link until they do; bytes that are not what it names are refused.
+ */
+export const linked = (asked, context) => inPlace(asked, context, async (place) => {
+    const [say, word, link] = [sayIn(context.lock), (k) => valueOf(context.lock, k), asked['document'] ?? ''], [held, admits] = [await standingOr(context, place, context.policy), members(valueOf(context.lock, 'link/transport'))];
+    if ('said' in held)
+        return held.said;
+    const lines = context.lock.filter((l) => admits.some((s) => l.scope === `birth/${s}`)).map(({ about: _about, scope, ...l }) => canonical({ ...l, scope: scope.slice('birth/'.length), at: 'policy:person/transport', by: 'target' }));
+    let reference;
+    try {
+        reference = decodeReference(link);
+    }
+    catch (refused) {
+        return [say('link-refused', { link, why: refused instanceof Error ? refused.message : String(refused) })];
+    }
+    if (![admits[0], `transport/${new URL(reference.source).protocol.slice(0, -1)}`].every((s) => held.lines.some((l) => l.scope === s)))
+        return [say('transport-missing', { place, lines: lines.join('\n') })];
+    const [printed, scope] = [await context.bound(place, [word('bound/read'), link]), `${word('place/needs')}/bytes/${reference.blob.slice(reference.algorithm.length + 1, reference.algorithm.length + 17)}`];
+    const [owed, root, why] = [held.lines.find((l) => l.scope === scope && l.role === 'demands' && l.value === link), rootIn(context, place), printed?.err.filter((l) => !l.startsWith('{')).at(-1) ?? ''];
+    if ('said' in root)
+        return root.said;
+    if (printed?.code !== 0 && !why.includes(word('link/unarrived')))
+        return [say('link-refused', { link, why })];
+    const settled = (lot) => (lot.length ? context.landRoot(place, lot, root.account).then((got) => ('refused' in got ? say('not-landed', { why: got.refused }) : got.lines)) : Promise.resolve([]));
+    const due = { at: 'policy:head/link', by: 'target', form: 'alphabet', measure: 'id', role: 'demands', scope, value: link };
+    if (printed?.code !== 0)
+        return [say('link-owed', { place, source: reference.source }), ...await settled(owed ? [] : [canonical(due)])];
+    const named = linesOf(new TextEncoder().encode(printed.out.filter((l) => l.startsWith('TOPOS ')).map((l) => l.slice('TOPOS '.length)).join('\n')));
+    const sources = named.filter((l) => /^sources\/[^/]+$/.test(l.scope ?? '')).map((l) => l.scope.split('/')[1]);
+    return [say('inspected', { source: reference.source, sources: sources.join(', ') || '—', digest: reference.digest }), say('sharer-unverified', {}), ...await settled(owed ? [canonical({ ...due, value: 'withdraw' })] : [])];
+});

package/dist/src/links/link.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '../core/answer.ts';
+/**
+ * A package's link: its lines as one standing document, laid in its folder as it is to be published — the link names that
+ * document's bytes, never the package's files — and the #bound: link to it at the address the person publishes it at.
+ * With no address there is no link, said so: a link needs where its bytes are published, and the digest still goes apart.
+ */
+export declare const linkOf: (context: Context, to: string, lines: readonly string[], urls: Readonly<Record<string, string>>) => readonly string[];

package/dist/src/links/link.js

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { encodeReference } from '@lapxo/bound/reference';
+import { semanticStandingBytes } from '@lapxo/topos/standing';
+import { members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+const sha = (bytes) => createHash('sha256').update(bytes).digest('hex');
+/**
+ * A package's link: its lines as one standing document, laid in its folder as it is to be published — the link names that
+ * document's bytes, never the package's files — and the #bound: link to it at the address the person publishes it at.
+ * With no address there is no link, said so: a link needs where its bytes are published, and the digest still goes apart.
+ */
+export const linkOf = (context, to, lines, urls) => {
+    const say = sayIn(context.lock), [name, profile, [kind, algorithm]] = [valueOf(context.lock, 'link/document'), valueOf(context.lock, 'link/profile'), members(valueOf(context.lock, 'link/reference'))];
+    const standing = semanticStandingBytes(lines), bytes = new TextEncoder().encode(JSON.stringify({ profile, standing })), at = urls[name], document = join(to, name);
+    context.files.lay(to, name, bytes);
+    if (at === undefined || !URL.canParse(at))
+        return [say('shared-unlinked', { document })];
+    try {
+        return [say('shared-link', { document, at, link: encodeReference({ class: kind, algorithm, digest: sha(standing), blob: `${algorithm}:${sha(bytes)}`, source: new URL(at).href }) })];
+    }
+    catch (refused) {
+        return [say('link-refused', { link: at, why: refused instanceof Error ? refused.message : String(refused) })];
+    }
+};

package/dist/src/marks/compare.d.ts

@@ -0,0 +1,9 @@
+import type { Asked, Context } from '../core/answer.ts';
+/**
+ * One question asked of several sources at once — the same operation, the same arguments — and their typed answers
+ * compared field by field. Where they agree, the field is marked by the sources that say it, each mark resting on the
+ * receipt of its read: ● for each its own, ○ for one that is the same source in another form or declared to share its
+ * lineage, with what the place declares of that lineage and nothing more. Where they differ, each is shown with its source
+ * and hour, and the loss between them is not measured. None is ever picked.
+ */
+export declare const compared: (asked: Asked, context: Context, place: string) => Promise<readonly string[]>;

package/dist/src/marks/compare.js

@@ -0,0 +1,48 @@
+import { join } from 'node:path';
+import { standingOr } from "../core/answer.js";
+import { members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+import { linesOf } from "../core/worlds.js";
+import { readSource } from "../flows/read.js";
+import { shapeOf } from "../ports/surface.js";
+/** What one source answered the question: its typed fields by name, the hour it said them, and the receipt the read rests on; or what it said instead. */
+const readOf = async (asked, context, place, source) => {
+    const [word, raw] = [(k) => valueOf(context.lock, k), await readSource({ ...asked, sources: undefined, source, place }, context)], got = shapeOf(raw);
+    const cell = got.cells.filter((c) => ['head/answered', 'head/reused', 'head/kept', 'head/reread'].includes(c.code)).at(-1), family = `${word('receipt/family')}/${source}/`;
+    const receipt = got.lines.map((l) => linesOf(new TextEncoder().encode(l))[0]).find((l) => l?.scope?.startsWith(family) && l.measure === 'digest')?.value ?? cell?.fields['receipt'];
+    const typed = cell?.code === 'head/kept' ? new TextDecoder().decode(context.cache.held(cell.fields['digest'] ?? '') ?? new Uint8Array()).split('\n') : got.lines;
+    const fields = new Map(linesOf(new TextEncoder().encode(typed.join('\n'))).flatMap((l) => ((m) => (m ? [[m[1], l.value ?? '']] : []))(new RegExp(`^${word('vocab/answer')}/[0-9a-f]{16}/(.+)$`).exec(l.scope ?? ''))));
+    return cell === undefined || receipt === undefined || !fields.size ? { said: raw.filter((l) => l.startsWith('said/')) } : { source, at: cell.fields['at'] ?? '', receipt, fields };
+};
+/**
+ * One question asked of several sources at once — the same operation, the same arguments — and their typed answers
+ * compared field by field. Where they agree, the field is marked by the sources that say it, each mark resting on the
+ * receipt of its read: ● for each its own, ○ for one that is the same source in another form or declared to share its
+ * lineage, with what the place declares of that lineage and nothing more. Where they differ, each is shown with its source
+ * and hour, and the loss between them is not measured. None is ever picked.
+ */
+export const compared = async (asked, context, place) => {
+    const [say, word, held] = [sayIn(context.lock), (k) => valueOf(context.lock, k), await standingOr(context, place)], [own, mark] = [members(word('marks/own-signers')), members(word('marks/mark'))];
+    if ('said' in held)
+        return held.said;
+    const got = [];
+    for (const source of members(asked['sources'] ?? ''))
+        got.push(await readOf(asked, context, place, source));
+    const reads = got.filter((g) => 'fields' in g), line = (scope, measure) => held.lines.find((l) => l.scope === scope && (!measure || l.measure === measure));
+    const pinned = (s) => linesOf(context.files.take(join(place, line(`uses/${s}`)?.needs ?? '')) ?? new Uint8Array()).filter((l) => l.scope === `${word('vocab/region')}/${s}`);
+    const origin = (s) => ((region) => ({ origins: members(region.find((l) => l.measure === word('vocab/origins'))?.value ?? ''), pin: region.find((l) => l.measure === word('vocab/documents'))?.value, by: ((b) => (b && !own.includes(b) ? b : undefined))(region.find((l) => l.by)?.by) }))(pinned(s));
+    const same = (a, b) => ((x, y) => x.origins.some((o) => y.origins.includes(o)) || (x.pin !== undefined && x.pin === y.pin) || (x.by !== undefined && x.by === y.by))(origin(a), origin(b));
+    const shares = (s) => ((l) => (l === undefined ? undefined : members(l.value ?? '')))(line(`${word('marks/shares')}/${s}`));
+    const kin = (s, earlier) => earlier.find((e) => same(s, e.source) || shares(s)?.includes(e.source) || shares(e.source)?.includes(s));
+    return [...got.flatMap((g) => ('said' in g ? g.said : [])), ...[...new Set(reads.flatMap((r) => [...r.fields.keys()]))].flatMap((field) => {
+            const values = reads.filter((r) => r.fields.has(field));
+            if (new Set(values.map((r) => r.fields.get(field))).size > 1)
+                return [...values.map((r) => say('forked', { field, source: r.source, value: r.fields.get(field), at: r.at })), say('unmeasured', { what: `${word('marks/loss')} ${values.map((r) => r.source).join(', ')}`, needs: word('marks/loss-needs') })];
+            if (values.length < 2 || values.length < reads.length)
+                return values.map((r) => say('partial', { field, source: r.source, value: r.fields.get(field), at: r.at }));
+            const kinOf = values.map((r, i) => kin(r.source, values.slice(0, i))), first = kinOf.findIndex((k) => k !== undefined);
+            const base = { field, value: values[0].fields.get(field), sources: values.map((r) => r.source).join(', '), marks: kinOf.map((k) => (k ? mark[1] : mark[0])).join(''), receipts: values.map((r) => r.receipt).join('|') };
+            return [first >= 0 ? say('agreed-lineage', { ...base, source: values[first].source, other: kinOf[first].source })
+                    : values.every((r) => line(`${word('marks/shares')}/${r.source}`)?.value === word('marks/undeclared')) ? say('agreed-undeclared', base) : say('agreed-unknown', base)];
+        })];
+};

package/dist/src/ports/bound.d.ts

@@ -57,5 +57,6 @@ export declare const words: {
     profile: string;
     receipts: string;
     refusal: string;
+    identity: string;
 };
 export declare const settledView: (name: string, place: string, view: string, signal?: AbortSignal) => Promise<Folded>;

package/dist/src/ports/bound.js

@@ -5,6 +5,8 @@ import { dirname, join } from 'node:path';
 import { parse } from '@lapxo/topos/wire';
 import { spawned } from "./process.js";
 import { cooled, kept, warmed } from "./warm.js";
+import { folded } from "../ahead/fold.js";
+import { readingOf } from "./reading.js";
 const binOf = (name) => {
     try {
         const manifest = createRequire(import.meta.url).resolve(join(name, 'package.json'));
@@ -34,6 +36,16 @@ export const warm = (name) => ((bin) => (bin === undefined ? Promise.resolve() :
 export { cooled };
 const facts = (out) => out.flatMap((line) => ((got) => (got.kind === 'fact' ? [got.value.fields] : []))(parse(line)));
 const readOf = (printed) => (printed === undefined || printed.code !== 0 ? { refused: why(printed) ?? '' } : { lines: facts(printed.out) });
+/** Native identities and expected-identity results come from the same public CLI contract. Without it, read fresh. */
+const nativeView = (name, place, view, signal) => {
+    const read = async (expected) => {
+        if (expected === undefined)
+            return readOf(await run(name, place, [words.read, words.view, view], {}, signal));
+        const result = readingOf(await run(name, place, [words.read, words.view, `${words.identity}@${view}@${expected}`], {}, signal), view, expected);
+        return 'refused' in result ? result : { lines: facts(result.text.split('\n')) };
+    };
+    return !words.identity ? read() : folded(`${name}/${view}`, place, async () => { const result = readingOf(await run(name, place, [words.read, words.view, `${words.identity}@${view}`], {}, signal), view); return 'refused' in result ? undefined : result.identity; }, read);
+};
 /**
  * The lines a place stands on, from bound's public views alone: its folded normative standing (the lines view) — its
  * policy, all that a reader of its pins, keys and views needs, read alone where nothing else is — and from
@@ -43,12 +55,12 @@ const readOf = (printed) => (printed === undefined || printed.code !== 0 ? { ref
  * name. A place whose land prints no act result is refused before anything lands in it. Any refusal of bound is no standing.
  */
 export const policyAt = async (name, place, signal) => ((folded) => ('refused' in folded || folded.lines.some((line) => line.scope === words.profile) ? folded
-    : { refused: `REFUSE·act the place declares no ${words.profile}: land would print nothing of what it admits, so head lands nothing there; its root can land the local-act@1 profile and view/act` }))(readOf(await run(name, place, [words.read, words.view, words.standing], {}, signal)));
+    : { refused: `REFUSE·act the place declares no ${words.profile}: land would print nothing of what it admits, so head lands nothing there; its root can land the local-act@1 profile and view/act` }))(await nativeView(name, place, words.standing, signal));
 export const standingAt = async (name, place, devicesOf, isHistory, signal) => {
     const folded = await policyAt(name, place, signal);
     if ('refused' in folded)
         return folded;
-    const evidence = readOf(await run(name, place, [words.read, words.view, words.evidence], {}, signal));
+    const evidence = await nativeView(name, place, words.evidence, signal);
     if ('refused' in evidence)
         return evidence;
     const ids = new Set(devicesOf(folded.lines)), own = evidence.lines.filter((line) => ids.has(line.by ?? ''));
@@ -81,5 +93,5 @@ export const pinnedAt = async (name, place, file, signal) => {
     return pin === undefined || !bytes ? undefined : { pin, bytes, lines: read.lines };
 };
 export const founded = async (name, place, key, signer, env, signal) => ((got) => (got !== undefined && got.code === 0 ? { lines: got.out } : { refused: why(got) ?? '' }))(await run(name, place, [words.land, words.key, key, words.signer, signer], env, signal));
-export const words = { read: '', view: '', sign: '', land: '', key: '', signer: '', pin: '', topos: '', standing: '', evidence: '', act: '', profile: '', receipts: '', refusal: '' };
+export const words = { read: '', view: '', sign: '', land: '', key: '', signer: '', pin: '', topos: '', standing: '', evidence: '', act: '', profile: '', receipts: '', refusal: '', identity: '' };
 export const settledView = async (name, place, view, signal) => readOf(await run(name, place, [words.read, words.view, view], {}, signal));