@lapxo/head 0.1.3 → 0.1.5

package/dist/src/access/obtain.d.ts

@@ -1,7 +1,12 @@
-import type { Attachment } from './contract.ts';
+import type { Attachment, Obtained } from './contract.ts';
 import type { Context } from '../core/answer.ts';
 import type { Said } from '../core/lock.ts';
 import type { Call } from '../core/read.ts';
+type Kept = Obtained & {
+    readonly at?: string;
+};
+export declare const sealed: (got: Kept) => string;
+export declare const opened: (kept: string | undefined) => Kept | undefined;
 /** Whom a call is made as, never its secret: anonymous, or the access account and when the secret it holds now was obtained — still holding, unless what was made as it is only being looked back on; none while no secret is kept, or one is kept without saying when. */
 export declare const principalOf: (context: Context, plan: Call, current?: boolean) => string | undefined;
 /**
@@ -17,3 +22,4 @@ export declare const attachmentFor: (context: Context, place: string, lines: rea
     readonly said: string;
     readonly input?: string;
 }>;
+export {};

package/dist/src/access/obtain.js

@@ -1,10 +1,10 @@
 import { canonical } from '@lapxo/topos/wire';
 import { jsonOf } from "./contract.js";
 import { placeNameOf } from "../core/answer.js";
-import { members, valueOf } from "../core/lock.js";
+import { aboutOf, members, valueOf } from "../core/lock.js";
 import { fieldsOf, stepOf, vocabOf } from "../core/read.js";
-const sealed = (got) => Buffer.from(JSON.stringify(got)).toString('base64url');
-const opened = (kept) => { try {
+export const sealed = (got) => Buffer.from(JSON.stringify(got)).toString('base64url');
+export const opened = (kept) => { try {
     return kept === undefined ? undefined : JSON.parse(Buffer.from(kept, 'base64url').toString('utf8'));
 }
 catch {
@@ -55,7 +55,7 @@ export const attachmentFor = async (context, place, lines, plan) => {
         values: members(valueOf(lines, 'wire/access-values') || valueOf(context.lock, 'wire/access-values')),
         host: Object.fromEntries(context.lock.filter((l) => l.scope?.startsWith('host/')).map((l) => [l.scope.slice('host/'.length), l.value ?? ''])),
         scopes: [...new Set(lines.filter((l) => reads.has(l.scope) && l.measure === 'scopes').flatMap((l) => (l.value ?? '').split('|')))].sort(),
-        enter: (title, fields) => context.person.enter(title, fields), consent: async (message) => (await context.person.consent(message, valueOf(context.lock, 'said/elicit/yes'))) === 'yes', choose: (message, choices) => context.person.choose(message, choices), visit: (message, to) => context.person.visit(message, to),
+        enter: (title, fields) => context.person.enter(title, fields), consent: async (message) => (await context.person.consent(message, aboutOf(context.lock, 'said/elicit/yes'))) === 'yes', choose: (message, choices) => context.person.choose(message, choices), visit: (message, to) => context.person.visit(message, to),
         form: (source, operation) => fieldsOf(lines, `${v.offers}/${source}/${operation}/${v.form}`), call: step,
         post: async (url, body, as) => ((transport) => (transport === undefined ? undefined : transport.post(url, body, most, Number(valueOf(context.lock, 'adapter/request/wait').split('..')[1]), as)))(await context.adapter(url)),
     };

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<{
@@ -64,6 +65,7 @@ export interface Context {
     readonly signRoot: (place: string, lot: readonly string[], account: string) => Promise<Outcome>;
     readonly landRoot: (place: string, lot: readonly string[], account: string) => Promise<Outcome>;
     readonly settle: () => Promise<readonly string[]>;
+    readonly moved: (place: string) => boolean;
     readonly pinned: (place: string, file: string) => Promise<{
         readonly pin: string;
         readonly bytes: string;
@@ -82,6 +84,7 @@ export interface Context {
     readonly elicit: (message: string) => Promise<'yes' | 'no' | 'none'>;
     readonly now: () => number;
     readonly machine: () => number;
+    readonly begun: number;
 }
 export type Answer = (asked: Asked, context: Context) => Promise<readonly string[]>;
 /** What answers a line of the surface: the module named as the line, in the folder of its family. */

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/core/read.js

@@ -61,4 +61,4 @@ const callOf = (lines, lock, source, operation, place) => {
 };
 const isCallable = (lock, classes) => classes.length === 1 && classes[0] === vocabOf(lock).callable;
 export const planRead = (lines, lock, source, operation, place) => ((call) => (call.kind === 'call' && !isCallable(lock, call.classes) ? said('not-callable', { source, operation, class: call.classes.join(', ') }) : call))(callOf(lines, lock, source, operation, place));
-export const planAct = (lines, lock, source, operation, place) => ((call) => (call.kind === 'call' && isCallable(lock, call.classes) ? said('is-read', { source, operation }) : call.kind === 'call' && call.access.probe ? said('access-unstated', { source, operation }) : call))(callOf(lines, lock, source, operation, place));
+export const planAct = (lines, lock, source, operation, place) => ((call) => (call.kind === 'call' && isCallable(lock, call.classes) ? said('is-read', { source, operation }) : call.kind === 'call' && call.access.probe ? said('access-unstated', { source, operation, method: call.carry['method']?.[0], path: call.carry['path']?.[0] }) : call))(callOf(lines, lock, source, operation, place));

package/dist/src/flows/call.d.ts

@@ -12,8 +12,6 @@ export declare const pickedOrigin: (context: Context, place: string, lines: read
 } | {
     readonly said: readonly string[];
 }>;
-/** Calls of one place take turns, so one asked while another lands sees its receipt; nothing waits on a timer. */
-export declare const inTurn: <T>(place: string, act: () => Promise<T>) => Promise<T>;
 export interface Frame {
     readonly say: (key: string, fields?: Readonly<Record<string, string | undefined>>) => readonly string[];
     readonly lands: (...lot: readonly string[]) => Promise<Outcome>;
@@ -43,7 +41,7 @@ export interface Frame {
     readonly uncovered: (role: string, scopes: readonly string[]) => readonly string[] | undefined;
 }
 /**
- * The steps a read and an act share: the place, its turn, the lines it stands on once bound settled them, the offer's
+ * The steps a read and an act share: the place, the lines it stands on once bound settled them, the offer's
  * plan, the transport its origin names and the request it prepares; then what is particular, given a frame that says
  * by the lock, attaches access when asked, types what came back and lands a line under head's key.
  */

package/dist/src/flows/call.js

@@ -27,18 +27,15 @@ export const pickedOrigin = async (context, place, lines, source, plan) => {
     const landed = await by.land([canonical(line(chosen))]);
     return 'refused' in landed ? { said: [sayIn(context.lock)('not-landed', { why: landed.refused })] } : { lines: [...lines, line(chosen)] };
 };
-const turns = new Map();
-/** Calls of one place take turns, so one asked while another lands sees its receipt; nothing waits on a timer. */
-export const inTurn = (place, act) => { const next = (turns.get(place) ?? Promise.resolve()).then(act, act); turns.set(place, next.catch(() => undefined)); return next; };
 /**
- * The steps a read and an act share: the place, its turn, the lines it stands on once bound settled them, the offer's
+ * The steps a read and an act share: the place, the lines it stands on once bound settled them, the offer's
  * plan, the transport its origin names and the request it prepares; then what is particular, given a frame that says
  * by the lock, attaches access when asked, types what came back and lands a line under head's key.
  */
 export const called = async (asked, context, planOf, then) => {
     const say = (key, fields = {}) => [sayIn(context.lock)(key, fields)];
     const [source, operation] = [asked['source'] ?? '', asked['operation'] ?? ''];
-    return inPlace(asked, context, (place) => inTurn(place, async () => {
+    return inPlace(asked, context, async (place) => {
         const held = await standingFor(context, place);
         if ('unsettled' in held)
             return say('unsettled', { source, why: held.unsettled });
@@ -67,10 +64,10 @@ 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);
         return then({ widen, word: (scope) => valueOf(context.lock, scope), say, place, lines, source, operation, plan, prepared, most, typed, attach, send: (attachment) => prepared.send(attachment, most('read/response-bytes')), lands, uncovered });
-    }));
+    });
 };

package/dist/src/flows/read.js

@@ -1,12 +1,15 @@
 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';
 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);
@@ -24,12 +27,12 @@ const closeWith = async (intent, source, digest, { word, lines, lands }, context
  * the reuse the place allows, it answers from what was kept: nothing called. Asked for history, it shows what was kept
  * of that request as of when it was read — evidence of that read, never a current answer — where the place allows it.
  */
-export const readSource = (asked, context) => ((started) => called(asked, context, planRead, async ({ word, say, place, lines, source, operation, plan, prepared, most, typed, attach, send, lands, widen, uncovered }) => {
+export const readSource = (asked, context) => called(asked, context, planRead, async ({ word, say, place, lines, source, operation, plan, prepared, most, typed, attach, send, lands, widen, uncovered }) => {
     const [family, at, when] = [word('receipt/family'), word('receipt/at'), new Date(context.now()).toISOString()];
     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}`);
@@ -53,43 +56,44 @@ export const readSource = (asked, context) => ((started) => called(asked, contex
     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}@${word('look/call')}`, started, 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')
+        return refusedAccess(context, place, lines, plan, operation);
     const digest = context.cache.keep(Buffer.concat([Buffer.from(`${got.status}\n`), got.bytes]));
     const answer = await typed(String(got.status), got.bytes);
     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] }) : [])];
-}))(context.machine());
+    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

@@ -13,7 +13,8 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { answerOf } from "./core/answer.js";
-import { valueOf } from "./core/lock.js";
+import { parse } from '@lapxo/topos/wire';
+import { aboutOf, valueOf } from "./core/lock.js";
 import { fill, sayIn } from "./core/surface.js";
 import { matchTemplate, refusedOn, shapeOf, shapeSchema, surfaceOf } from "./ports/surface.js";
 import { closing, cooled, founded, land, landAct, limits, pinnedAt, policyAt, run, settledView, sign, standingAt, told, warm, words } from "./ports/bound.js";
@@ -26,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 { inTurn } from "./flows/call.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, with bound started ahead for it and nothing of it kept once it is answered. */
-const turn = (act) => inTurn('', () => { void warm(runs); return act().finally(cooled); });
+/** 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, 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 {
@@ -58,19 +62,21 @@ const device = (role) => devices.get(role) ?? ((secret) => (secret === undefined
 const asRoot = (account) => ((device, key) => [key, device.signer, { BOUND_SIGNERS: registryFor(device.signer, service, account, key, valueOf(lock, 'founding/algorithm'), store) }])(deviceOf(lock), valueOf(lock, 'founding/root').split('/')[1]);
 /** What a call is answered with, one call at a time as when bound blocked head: every bound process it starts is stopped when the client cancels it, and a call cancelled while it waits its turn is never begun. */
 const contextOf = (signal) => {
-    /** One call's folds of a place, kept until something lands in it or is laid there; and the places its root acted in, whose receipts close once, when the call ends. */
-    const [folds, touched] = [new Map(), new Set()], forget = (place) => { for (const k of [...folds.keys()])
+    /** One call's folds of a place, kept until something lands in it or is laid there; the places its root acted in, whose receipts close once, when the call ends; and those where anything but a read's receipts landed, as bound printed it. */
+    const [folds, touched, moved] = [new Map(), new Set(), new Set()], forget = (place) => { for (const k of [...folds.keys()])
         if (k.endsWith(`\0${place}`))
             folds.delete(k); };
+    const read = (at) => at?.startsWith(`${valueOf(lock, 'receipt/at')}:`) === true;
     const once = (key, place, fold) => (folds.get(`${key}\0${place}`) ?? ((p) => (folds.set(`${key}\0${place}`, p), p))(fold()));
-    const acted = (place, root, done) => done.finally(() => { forget(place); if (root)
+    const acted = (place, root, done) => done.then((got) => { if ('lines' in got && !got.lines.every((l) => ((f) => f.kind === 'fact' && read(f.value.fields['at']))(parse(l))))
+        moved.add(place); return got; }).finally(() => { forget(place); if (root)
         touched.add(place); });
     const signRoot = (place, lot, account) => sign(runs, place, lot, ...asRoot(account), signal);
     const signAs = (place, lot, role, lines) => ((one, id) => sign(runs, place, lot, id, one.signer, { BOUND_SIGNERS: registryFor(one.signer, service, one.account, id, algorithmOf(lines), store) }, signal))(deviceOf(lock, role), idIn(lines, device(role)) ?? deviceOf(lock, role).account);
     return {
         lock,
         bound: (cwd, args) => run(runs, cwd, args, {}, signal),
-        standing: (place) => once('standing', place, () => standingAt(runs, place, (lines) => ['head', 'person'].flatMap((role) => ((id) => (id === undefined ? [] : [id]))(idIn(lines, device(role)))), (line) => line.at?.startsWith(`${valueOf(lock, 'receipt/at')}:`) === true, signal)),
+        standing: (place) => once('standing', place, () => standingAt(runs, place, (lines) => ['head', 'person'].flatMap((role) => ((id) => (id === undefined ? [] : [id]))(idIn(lines, device(role)))), (line) => read(line.at), signal)),
         policy: (place) => once('policy', place, () => policyAt(runs, place, signal)),
         world: (place, view) => once(`world/${view}`, place, () => settledView(runs, place, view, signal)),
         adapter: async (origin) => ((name) => (!/^[a-z-]+$/.test(name) ? undefined : import(__rewriteRelativeImportExtension(new URL(`./ports/adapters/${name}${ext}`, import.meta.url).href))))(URL.canParse(origin) ? valueOf(lock, `adapter/${new URL(origin).protocol.slice(0, -1)}`) : ''),
@@ -80,6 +86,7 @@ const contextOf = (signal) => {
         found: (place, account) => acted(place, true, founded(runs, place, ...asRoot(account), signal)),
         signRoot,
         landRoot: (place, lot, account) => acted(place, true, landAct(runs, place, lot, ...asRoot(account), signal)),
+        moved: (place) => moved.has(place),
         settle: async () => { const red = []; for (const place of touched) {
             const why = await closing(runs, place, signal);
             if (why !== undefined)
@@ -93,12 +100,13 @@ const contextOf = (signal) => {
         landAs: (place, lot, role, lines) => acted(place, false, ((one, id) => landAct(runs, place, lot, id, one.signer, { BOUND_SIGNERS: registryFor(one.signer, service, one.account, id, algorithmOf(lines), store) }, signal))(deviceOf(lock, role), idIn(lines, device(role)) ?? deviceOf(lock, role).account)),
         land: (place, signed) => acted(place, true, land(runs, place, signed, signal)),
         told: (place, signed) => told(runs, place, signed, words.standing, signal),
-        elicit: (message) => person.consent(message, valueOf(lock, 'said/elicit/yes')),
+        elicit: (message) => person.consent(message, aboutOf(lock, 'said/elicit/yes')),
         now: () => Date.now(),
         machine: () => Date.now() - waited,
+        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)]));
@@ -108,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[]>;