@lapxo/head 0.1.4 → 0.1.6

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,9 @@
+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.
+ * Asked why, it shows the transport it reads by: the profile's lines, laid at the place's birth by head, never the person's.
+ */
+export declare const linked: (asked: Asked, context: Context) => Promise<readonly string[]>;

package/dist/src/links/inspect.js

@@ -0,0 +1,44 @@
+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.
+ * Asked why, it shows the transport it reads by: the profile's lines, laid at the place's birth by head, never the person's.
+ */
+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;
+    if (asked['why'] === 'true')
+        return [...held.lines.filter((l) => admits.includes(l.scope ?? '') || l.scope?.startsWith('transport/')).map((l) => canonical(l)), say('why-transport', { place })];
+    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/onboard/first.js

@@ -28,7 +28,7 @@ export const firstRun = async (asked, context, then) => {
     const connected = await then(dir, true), unread = connected.some((l) => l.startsWith('said/head/document-unread ')), held = unread ? undefined : await context.policy(dir);
     if (held !== undefined && ('refused' in held || !held.lines.some((l) => l.scope === `uses/${source}`)))
         return [...born, ...connected];
-    const line = (scope, measure, value, role = 'writes') => canonical({ at: 'policy:head/first-run', by: 'target', form: 'alphabet', measure, role, scope, value });
+    const line = (scope, measure, value, role = 'writes') => canonical({ at: 'policy:person/grant', by: 'target', form: 'alphabet', measure, role, scope, value });
     const owed = unread ? [line(`${word('place/needs')}/bytes/${source}`, 'id', document, 'demands')] : [];
     const landed = await context.landRoot(dir, [line(word('grant/family'), 'sources', source), line(word('grant/family'), 'until', until), ...owed], root.account);
     if ('refused' in landed)

package/dist/src/places/admit.js

@@ -26,7 +26,7 @@ export const admitted = (asked, context) => inPlace(asked, context, async (place
     const refused = await unless(context, say('elicit-admit', { name, place, coverage }));
     if (refused)
         return refused;
-    const lot = admissionOf(context.lock, key, 'head', { id: name, coverage, at: `policy:head/admit/${new Date(context.now()).toISOString()}` });
+    const lot = admissionOf(context.lock, key, 'head', { id: name, coverage, at: `policy:person/admit/${new Date(context.now()).toISOString()}` });
     const landed = await context.landRoot(place, lot, root.account);
     return 'refused' in landed ? [say('not-landed', { why: landed.refused })] : [say('admitted', { name, place, coverage }), ...landed.lines];
 });

package/dist/src/places/found.js

@@ -2,19 +2,15 @@ import { isAbsolute, basename } from 'node:path';
 import { canonical, LOCK } from '@lapxo/topos/wire';
 import { unless } from "../core/answer.js";
 import { admissionOf } from "../core/device.js";
-import { valueOf } from "../core/lock.js";
+import { members, valueOf } from "../core/lock.js";
 import { deviceKey } from "../flows/device.js";
 import { walkable } from "../walk/context.js";
 import { fill, sayIn } from "../core/surface.js";
-/**
- * The lines a place is born with, every one drafted by target: its root, by the public half of a key kept only in the
- * keychain and the signer that reaches it; this device's keys admitted; and the prelude head's lock declares under
- * birth/ — the wire, the regions and views a world is read through, and the lifetime every reader is bounded by.
- */
-const birthOf = (lock, root, head, person, place) => [
-    ...[['class', 'authorize'], ['coverage', '*'], ['signer', valueOf(lock, 'device/head/signer')], ['public-key', root]].map(([measure, value]) => canonical({ at: 'policy:head/birth', by: 'target', form: 'alphabet', measure: measure, role: 'writes', scope: valueOf(lock, 'founding/root'), value: value })),
+/** Found the place from the declared prelude; personal lines retain the person's provenance. */
+const birthOf = (lock, root, head, person, place, mine = `${valueOf(lock, 'founding/person-at')}birth`) => [
+    ...[['class', 'authorize'], ['coverage', '*'], ['signer', valueOf(lock, 'device/head/signer')], ['public-key', root]].map(([measure, value]) => canonical({ at: mine, by: 'target', form: 'alphabet', measure: measure, role: 'writes', scope: valueOf(lock, 'founding/root'), value: value })),
     ...admissionOf(lock, head, 'head'), ...admissionOf(lock, person, 'person'),
-    ...lock.filter((l) => l.scope?.startsWith('birth/')).map(({ about: _about, scope, ...line }) => canonical({ ...line, value: fill(line.value ?? '', { place }), scope: scope.slice('birth/'.length), at: 'policy:head/birth', by: 'target' })),
+    ...lock.filter((l) => l.scope?.startsWith('birth/')).map(({ about: _about, scope, ...line }) => ((s) => canonical({ ...line, value: fill(line.value ?? '', { place }), scope: s, at: members(valueOf(lock, 'founding/person')).includes(s) ? mine : 'policy:head/birth', by: 'target' }))(scope.slice('birth/'.length))),
 ];
 /** A place founded in a folder: a root key made in the keychain under the place's name — never a file — the birth lines written, and the first land signed by that root. */
 const founded = async (context, dir, name) => {

package/dist/src/ports/adapters/request.d.ts

@@ -12,6 +12,7 @@ export type Fetched = {
     readonly kind: 'over';
 } | {
     readonly kind: 'failed';
+    readonly why?: string;
 };
 export type Prepared = {
     readonly key: string;

package/dist/src/ports/adapters/request.js

@@ -19,8 +19,8 @@ const requestCapped = async (method, url, headers, body, most, wait, redirect =
         }
         return size > most ? { kind: 'over' } : { kind: 'got', status: response.status, bytes: Buffer.concat(chunks), type: response.headers.get('content-type') ?? '', ...((at) => (at ? { location: at } : {}))(response.headers.get('location')), ...((asks) => (asks ? { authenticate: asks } : {}))(response.headers.get('www-authenticate')) };
     }
-    catch {
-        return { kind: 'failed' };
+    catch (error) {
+        return { kind: 'failed', why: String(error?.cause?.code ?? error?.name ?? '') };
     }
 };
 const loopback = new Set(['127.0.0.1', 'localhost', '[::1]']);

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

@@ -17,20 +17,18 @@ export type Folded = {
 } | {
     readonly refused: string;
 };
-/**
- * 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
- * its authenticated evidence what this device's own keys signed. Receipts are history, each kept as it was made; any other
- * line of a device key, the person's own attestation, stands only while it is the one line of its scope and measure,
- * unwithdrawn and beside no line of the place's own: anything else needs a fold bound does not publish, and is refused by
- * name. A place whose land prints no act result is refused before anything lands in it. Any refusal of bound is no standing.
- */
+/** Read normative standing plus authenticated device evidence; ambiguous device history refuses. */
 export declare const policyAt: (name: string, place: string, signal?: AbortSignal) => Promise<Folded>;
 export declare const standingAt: (name: string, place: string, devicesOf: (lines: readonly Said[]) => readonly string[], isHistory: (line: Said) => boolean, signal?: AbortSignal) => Promise<Folded>;
 export declare const sign: (name: string, place: string, lot: readonly string[], key: string, signer: string, env: Readonly<Record<string, string>>, signal?: AbortSignal) => Promise<Outcome>;
 /** A lot signed and landed in one process, its result read from what bound printed of the committed act: the records it admitted, never the receipt beside them; a place that declares no act result is refused by name. */
 /** A place's receipts rendered beside its lock, so bound alone checks the place: nothing when they closed, else why they did not. */
 export declare const closing: (name: string, place: string, signal?: AbortSignal) => Promise<string | undefined>;
+/** A place's own lines in the person's words, beside its lock, the text they read and share: each line head lands at the person's at, drafted with no signature, gone with its withdraw. Bound reads the file as it reads the place, so it is written with the land, never while a fold runs. Set from head's lock. */
+export declare const birth: {
+    at: string;
+    file: string;
+}, birthed: (place: string, lot: readonly string[]) => void;
 export declare const landAct: (name: string, place: string, lot: readonly string[], key: string, signer: string, env: Readonly<Record<string, string>>, signal?: AbortSignal) => Promise<Outcome>;
 export declare const land: (name: string, place: string, signed: readonly string[], signal?: AbortSignal) => Promise<Outcome>;
 export declare const told: (name: string, place: string, signed: readonly string[], view: string, signal?: AbortSignal) => Promise<readonly string[]>;
@@ -57,5 +55,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

@@ -1,10 +1,12 @@
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { parse } from '@lapxo/topos/wire';
+import { canonical, LOCK, 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,21 +36,23 @@ 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) });
-/**
- * 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
- * its authenticated evidence what this device's own keys signed. Receipts are history, each kept as it was made; any other
- * line of a device key, the person's own attestation, stands only while it is the one line of its scope and measure,
- * unwithdrawn and beside no line of the place's own: anything else needs a fold bound does not publish, and is refused by
- * name. A place whose land prints no act result is refused before anything lands in it. Any refusal of bound is no standing.
- */
+/** 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);
+};
+/** Read normative standing plus authenticated device evidence; ambiguous device history refuses. */
 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);
+    const [folded, evidence] = await Promise.all([policyAt(name, place, signal), nativeView(name, place, words.evidence, signal)]);
     if ('refused' in folded)
         return folded;
-    const evidence = readOf(await run(name, place, [words.read, words.view, 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 ?? ''));
@@ -62,14 +66,20 @@ export const sign = async (name, place, lot, key, signer, env, signal) => ((got)
 /** A lot signed and landed in one process, its result read from what bound printed of the committed act: the records it admitted, never the receipt beside them; a place that declares no act result is refused by name. */
 /** A place's receipts rendered beside its lock, so bound alone checks the place: nothing when they closed, else why they did not. */
 export const closing = async (name, place, signal) => ((got) => (got !== undefined && got.code === 0 ? undefined : why(got) ?? 'nothing printed'))(await run(name, place, [words.read, words.view, words.receipts], {}, signal));
+/** A place's own lines in the person's words, beside its lock, the text they read and share: each line head lands at the person's at, drafted with no signature, gone with its withdraw. Bound reads the file as it reads the place, so it is written with the land, never while a fold runs. Set from head's lock. */
+export const birth = { at: '', file: '' }, birthed = (place, lot) => {
+    const [file, mine] = [join(place, birth.file), facts(lot).filter((l) => birth.file && l['at']?.startsWith(birth.at))], bare = (l) => JSON.stringify(Object.entries(l).filter(([k]) => !['about', 'value', 'sig', 'epoch', 'by'].includes(k)).sort());
+    if (mine.length)
+        writeFileSync(file, [...(existsSync(file) ? facts(readFileSync(file, 'utf8').split('\n')) : []).filter((k) => !mine.some((m) => bare(m) === bare(k))), ...mine.filter((m) => m['value'] !== 'withdraw')].map(({ sig: _sig, epoch: _epoch, ...l }) => `${canonical({ ...l, by: 'target' })}\n`).join(''));
+};
 export const landAct = async (name, place, lot, key, signer, env, signal) => ((got) => {
     if (got === undefined || got.code !== 0)
         return { refused: why(got) ?? '' };
     const at = got.out.findIndex((line) => line.startsWith(words.act));
     return at < 0 ? { refused: `REFUSE·act bound printed no act result, and the place declares ${words.profile}: what was admitted is bound's to say` }
-        : { lines: got.out.slice(at + 1).filter((line) => parse(line).kind === 'fact').slice(0, -1) };
+        : (birthed(place, lot), { lines: got.out.slice(at + 1).filter((line) => parse(line).kind === 'fact').slice(0, -1) });
 })(await run(name, place, [words.land, lotFile(lot), words.key, key, words.signer, signer], env, signal));
-export const land = async (name, place, signed, signal) => ((got) => (got !== undefined && got.code === 0 ? { lines: signed } : { refused: why(got) ?? '' }))(await run(name, place, [words.land, lotFile(signed)], {}, signal));
+export const land = async (name, place, signed, signal) => ((got) => (got !== undefined && got.code === 0 ? (birthed(place, signed), { lines: signed }) : { refused: why(got) ?? '' }))(await run(name, place, [words.land, lotFile(signed)], {}, signal));
 export const told = async (name, place, signed, view, signal) => ((got) => [...(got?.out ?? []), ...(got?.err ?? [])])(await run(name, place, [words.read, words.view, view, lotFile(signed)], {}, signal));
 export const pinnedAt = async (name, place, file, signal) => {
     const printed = await run(name, place, [words.read, file], {}, signal);
@@ -80,6 +90,6 @@ export const pinnedAt = async (name, place, file, signal) => {
     const bytes = printed.out.filter((line) => line.startsWith(words.topos)).map((line) => `${line.slice(words.topos.length)}\n`).join('');
     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 founded = async (name, place, key, signer, env, signal) => ((got) => (got !== undefined && got.code === 0 ? (birthed(place, readFileSync(join(place, LOCK), 'utf8').split('\n')), { 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: '', identity: '' };
 export const settledView = async (name, place, view, signal) => readOf(await run(name, place, [words.read, words.view, view], {}, signal));

package/dist/src/ports/documents.js

@@ -32,7 +32,7 @@ export const fetchedAs = async (context, at, via, got, named, accept) => {
             return { said: [say('fetch-redirect', { document: at })] };
         return ((bytes) => (bytes ? { bytes, kind: kindOf(at) } : { said: [say('document-unread', { document: at })] }))(await transport.published(new URL(answer.location, at).href, named, most, wait));
     }
-    return answer.status < 300 ? { bytes: answer.bytes, kind: kindOf(at, answer.type) } : { said: [say('fetch-status', { document: at, via, status: String(answer.status) })] };
+    return answer.status < 300 ? { bytes: answer.bytes, kind: kindOf(at, answer.type) } : { said: [say('fetch-status', { document: at, via, status: String(answer.status), at: new Date(context.now()).toISOString() })] };
 };
 /**
  * Every byte a package's lines name, by the path each names: read where a line of the same scope says — an encrypted

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

@@ -0,0 +1,8 @@
+import type { Printed } from './process.ts';
+/** Only the installed instrument names a view's identity and the result bound to it. */
+export declare const readingOf: (printed: Printed | undefined, view: string, expected?: string) => {
+    readonly identity: string;
+    readonly text?: string;
+} | {
+    readonly refused: string;
+};

package/dist/src/ports/reading.js

@@ -0,0 +1,14 @@
+/** Only the installed instrument names a view's identity and the result bound to it. */
+export const readingOf = (printed, view, expected) => {
+    if (!printed || printed.code !== 0)
+        return { refused: printed?.refusal?.['code'] ?? 'reading-identity/unavailable' };
+    try {
+        const value = printed.out.length === 1 ? JSON.parse(printed.out[0]) : undefined;
+        if (value?.['kind'] !== 'fact' || value['view'] !== view || typeof value['identity'] !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(value['identity']) || (expected !== undefined && (value['identity'] !== expected || typeof value['text'] !== 'string')))
+            return { refused: 'reading-identity/context' };
+        return { identity: value['identity'], ...(expected === undefined ? {} : { text: value['text'] }) };
+    }
+    catch {
+        return { refused: 'reading-identity/format' };
+    }
+};

package/dist/src/ports/spare.js

@@ -18,7 +18,7 @@ import { pathToFileURL } from 'node:url';
 const [program] = process.argv.slice(2);
 const url = pathToFileURL(program), pipe = new Socket({ fd: 3, readable: true, writable: true });
 const asked = new Promise((resolve) => { let text = ''; pipe.setEncoding('utf8').on('data', (chunk) => { text += chunk; }).on('error', () => undefined).on('close', () => resolve(text)); });
-await Promise.all([...readFileSync(program, 'utf8').matchAll(/^import [^'"]*['"](\.{1,2}\/[^'"]+)['"];?$/gm)].map(([, path]) => import(__rewriteRelativeImportExtension(new URL(path, url).href)).catch(() => undefined)));
+await Promise.all([...readFileSync(program, 'utf8').matchAll(/(?:^|[;\n])\s*import\s*(?:(?:[^'";]*?)\s*from\s*)?['"](\.{1,2}\/[^'"]+)['"]/g)].map(([, path]) => import(__rewriteRelativeImportExtension(new URL(path, url).href)).catch(() => undefined)));
 pipe.write('ready\n');
 const text = await asked;
 if (!text)

package/dist/src/ports/warm.js

@@ -40,7 +40,6 @@ export const warmed = (program, args, at, bounds) => {
     const spare = index < 0 ? undefined : live.splice(index, 1)[0];
     if (spare === undefined)
         return undefined;
-    void kept(program);
     spare.child.stdio[3].end(`${JSON.stringify({ cwd: at.cwd, args, env: at.env })}\n`);
-    return watched(spare.child, bounds);
+    return watched(spare.child, bounds).finally(() => { void kept(program); });
 };

package/dist/src/sources/connect.js

@@ -9,6 +9,7 @@ import { paidBy, pinIn } from "../compile/pin.js";
 import { adopted } from "../adopt/adopt.js";
 import { firstRun } from "../onboard/first.js";
 import { resolved } from "../onboard/site.js";
+import { linked } from "../links/inspect.js";
 import { rootIn } from "../flows/device.js";
 import { attachedFor } from "./access.js";
 /**
@@ -22,7 +23,8 @@ import { attachedFor } from "./access.js";
  * its pins rest in, its pin held to the package's; one that differs is refused by name, and the place holds what it
  * compiled. Nothing the sharing place was granted comes with it: access is asked here, issuer by issuer.
  */
-export const connected = async (asked, context, covered = false) => ((got) => ('said' in got ? got.said : connectedAs(got.asked, context, covered)))(await resolved(asked, context));
+export const connected = async (asked, context, covered = false) => ((asked['document'] ?? '').startsWith(valueOf(context.lock, 'link/prefix')) ? linked(asked, context)
+    : ((got) => ('said' in got ? got.said : connectedAs(got.asked, context, covered)))(await resolved(asked, context)));
 const connectedAs = async (asked, context, covered = false) => (asked['source'] && !(await placeOf(asked, context)) ? firstRun(asked, context, (dir, covered) => connected({ ...asked, place: dir }, context, covered))
     : ((started) => inPlace(asked, context, async (place) => {
         const say = sayIn(context.lock), digest = digestIn(context.lock), { documentOf, fetchedAs, kindOf } = context.files.read;

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

@@ -0,0 +1 @@
+export { claimed as answer } from '../claims/claim.ts';

package/dist/src/tools/claim.js

@@ -0,0 +1 @@
+export { claimed as answer } from "../claims/claim.js";

package/dist/src/tools/look.js

@@ -24,18 +24,18 @@ export const answer = (asked, context) => inPlace(asked, context, async (place)
         if ('unsettled' in held)
             return [sayIn(context.lock)('unsettled', { source, why: held.unsettled })];
         const [v, first, shallow] = [vocabOf(context.lock), asked['at'] === '0', word('look/first').split('|')];
-        const region = `${v.offers}/${source}/${operation ?? ''}`;
+        const [region, uses] = [`${v.offers}/${source}/`, held.lines.filter((l) => l.scope?.startsWith(`${word('use/family')}/${source}/`))], named = operation ? [operation] : uses.map((l) => l.value ?? '');
         const shown = held.lines.filter((l) => {
             const scope = l.scope ?? '';
-            if (scope === `${v.region}/${source}`)
+            if (scope === `${v.region}/${source}` || (!operation && uses.includes(l)))
                 return true;
             if (scope.startsWith(`${v.keys}/${source}/`))
                 return !first;
-            if (!(operation ? scope === region || scope.startsWith(`${region}/`) : scope.startsWith(region)) || scope.endsWith(`/${v.carry}`))
+            if (!named.some((op) => scope === `${region}${op}` || scope.startsWith(`${region}${op}/`)) || scope.endsWith(`/${v.carry}`))
                 return false;
             return !first || (!scope.endsWith(`/${v.form}`) && shallow.includes(l.measure ?? ''));
-        });
-        return shown.length ? [...shown.map((l) => canonical(l)).sort(), ...(first ? [] : trustOf(context.lock, held.lines, source)), ...(operation ? await readSource(asked, context) : [])] : [sayIn(context.lock)('unread', { source })];
+        }), more = held.lines.filter((l) => l.measure === v.class && l.scope?.startsWith(region) && !named.includes(l.scope.slice(region.length))).length;
+        return shown.length ? [...shown.map((l) => canonical(l)).sort(), ...(first ? [] : trustOf(context.lock, held.lines, source)), ...(more ? [sayIn(context.lock)('more-offers', { source, more: String(more) })] : []), ...(operation ? await readSource(asked, context) : [])] : [sayIn(context.lock)('unread', { source })];
     }
     const view = `${asked['view'] ?? ''}${asked['at'] ? `${word('bound/at')}${asked['at']}` : ''}`;
     return printedOr(context, await context.bound(place, [word('bound/read'), word('bound/view'), view]));

package/dist/src/use/named.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '../core/answer.ts';
+import { type Said } from '../core/lock.ts';
+/** The offers of a source a place holds: head's own registry of it, local, never sent to the model whole. */
+export declare const offersOf: (lock: readonly Said[], lines: readonly Said[], source: string) => readonly string[];
+/** Resolve the offer against the local registry. Ambiguity asks the person; read-ahead creates no use line. */
+export declare const namedIn: (context: Context, lines: readonly Said[], source: string, asked: string, ahead: boolean) => Promise<{
+    readonly operation: string;
+    readonly use?: string;
+    readonly scope?: string;
+} | {
+    readonly said: readonly string[];
+}>;

package/dist/src/use/named.js

@@ -0,0 +1,25 @@
+import { canonical } from '@lapxo/topos/wire';
+import { valueOf } from "../core/lock.js";
+import { vocabOf } from "../core/read.js";
+import { sayIn } from "../core/surface.js";
+/** The words of a name as a person or a model says it: its runs of letters and digits, lowercase. */
+const words = (text) => text.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+/** The offers of a source a place holds: head's own registry of it, local, never sent to the model whole. */
+export const offersOf = (lock, lines, source) => ((at) => lines.filter((l) => l.measure === vocabOf(lock).class && l.scope?.startsWith(at)).map((l) => l.scope.slice(at.length)))(`${vocabOf(lock).offers}/${source}/`);
+/** Resolve the offer against the local registry. Ambiguity asks the person; read-ahead creates no use line. */
+export const namedIn = async (context, lines, source, asked, ahead) => {
+    const [v, word, say] = [vocabOf(context.lock), (k) => valueOf(context.lock, k), sayIn(context.lock)];
+    const [family, name] = [word('use/family'), words(asked).join('-')], uses = lines.filter((l) => l.scope?.startsWith(`${family}/${source}/`)), offers = offersOf(context.lock, lines, source);
+    const used = uses.find((l) => l.scope === `${family}/${source}/${name}`)?.value;
+    if (used !== undefined || ahead || !asked)
+        return { operation: used ?? asked };
+    const named = (op) => words([op, ...lines.filter((l) => l.scope === `${v.offers}/${source}/${op}/${v.carry}`).map((l) => l.value ?? '')].join(' '));
+    const found = offers.includes(asked) ? [asked] : offers.filter((op) => words(asked).length > 0 && words(asked).every((w) => named(op).includes(w)));
+    const operation = found.length > 1 ? (await context.person.choose(say('pick-offer', { source, asked }), [{ name: family, options: found.map((o) => ({ value: o, label: o })) }]))?.[family] : found[0];
+    if (!found.length)
+        return { operation: asked };
+    if (operation === undefined || !found.includes(operation))
+        return { said: [say('pick-offer', { source, asked })] };
+    const scope = `${family}/${source}/${name}`;
+    return uses.some((l) => l.value === operation) ? { operation } : { operation, scope, use: canonical({ at: `${word('founding/person-at')}use/${new Date(context.now()).toISOString()}`, by: 'target', form: 'alphabet', measure: 'operation', role: 'writes', scope, value: operation }) };
+};

package/dist/src/verbs/ask.d.ts

@@ -1,11 +1,3 @@
 import type { Answer } from '../core/answer.ts';
-/**
- * What a person asks, answered by the question it is. A view, or the region of a source or of one operation in it (what
- * it offers, one read of it, why that answer stands, what was kept of it), is answered by look; drafted lines by plan;
- * what is open by card; anything else by places. Each form is read with no resolution unless the lock declares one for a
- * person; asked why, at the one it declares to explain, and where it declares none, the same answer, said so. Nothing
- * here writes one. An answer about one place ends with its card, taken off the fold the answer reads, valid from it.
- * With no place at all, nothing is founded: it says so, and that connecting an API founds the person's place, the question
- * carried along. A place still owing a source's bytes is answered only once they arrive.
- */
+/** Route a question at the declared resolution, then attach the card of the place it read. */
 export declare const asked: Answer;

package/dist/src/verbs/ask.js

@@ -5,18 +5,11 @@ import { valueOf } from "../core/lock.js";
 import { sayIn } from "../core/surface.js";
 import { paidIn } from "../onboard/owed.js";
 import { pendingIn } from "../sources/refused.js";
+import { compared } from "../marks/compare.js";
 import { cardAt } from "./card.js";
-/**
- * What a person asks, answered by the question it is. A view, or the region of a source or of one operation in it (what
- * it offers, one read of it, why that answer stands, what was kept of it), is answered by look; drafted lines by plan;
- * what is open by card; anything else by places. Each form is read with no resolution unless the lock declares one for a
- * person; asked why, at the one it declares to explain, and where it declares none, the same answer, said so. Nothing
- * here writes one. An answer about one place ends with its card, taken off the fold the answer reads, valid from it.
- * With no place at all, nothing is founded: it says so, and that connecting an API founds the person's place, the question
- * carried along. A place still owing a source's bytes is answered only once they arrive.
- */
+/** Route a question at the declared resolution, then attach the card of the place it read. */
 export const asked = async (asked, context) => {
-    const why = asked['why'] === 'true', at = (form) => valueOf(context.lock, `resolution/${form}/${why ? 'why' : 'person'}`) || undefined;
+    const why = asked['why'] === 'true', at = (form) => ((v) => (v && v !== valueOf(context.lock, 'resolution/own') ? v : undefined))(valueOf(context.lock, `resolution/${form}/${why ? 'why' : 'person'}`));
     const read = async (form, tool, more = {}) => [...(why && at(form) === undefined ? [sayIn(context.lock)('why-undeclared', { form })] : []),
         ...await (await answerOf('tools', tool))({ ...asked, ...more, at: at(form) }, context)];
     const place = await placeOf(asked, context), founded = place !== undefined && context.files.has(place, LOCK), carded = asked['card'] === 'true';
@@ -28,7 +21,7 @@ export const asked = async (asked, context) => {
     const owed = asked['source'] && founded ? await paidIn(asked, context, place) : undefined;
     if (owed !== undefined && !owed.answer)
         return owed.said;
-    const answer = asked['lines'] ? await read('plan', 'plan') : asked['view'] ? await read('view', 'look') : asked['source'] ? await read('offers', 'look')
+    const answer = asked['sources'] && founded ? await compared(asked, context, place) : asked['lines'] ? await read('plan', 'plan') : asked['view'] ? await read('view', 'look') : asked['source'] ? await read('offers', 'look')
         : !carded ? await read('places', 'places') : founded ? [...await read('card', 'card', { place }), ...await pendingIn(context, place)] : [];
     const after = held === undefined || 'said' in held || place === undefined || !context.moved(place) ? held : await cardAt(context, place);
     return [...(owed?.said ?? []), ...answer, ...(after === undefined || 'said' in after ? [] : [sayIn(context.lock)('card', { place: place ?? '', card: after.card, from: 'ask' })])];

package/dist/src/verbs/card.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from '../core/answer.ts';
 /**
- * The card an act is made on: the place's standing as bound folds it, with the reads it kept set aside, and the keys this
- * device acts with. Anything landed, a grant withdrawn or a key admitted or changed moves it; a read never does. A folder
+ * The card an act is made on: the place's standing as bound folds it, with the reads it kept and the uses they named set
+ * aside, and the keys this device acts with. Anything landed, a grant withdrawn or a key admitted or changed moves it; a read never does. A folder
  * that holds no place yet has the card of nothing.
  */
 export declare const cardAt: (context: Context, place: string | undefined) => Promise<{