@lapxo/head 0.1.5 → 0.1.6

package/dist/src/answers/answered.d.ts

@@ -0,0 +1,4 @@
+import type { Asked, Context } from '../core/answer.ts';
+import type { Frame } from '../flows/call.ts';
+/** Distinguish an empty response from missing transport bytes; only the latter leaves a named need. */
+export declare const answering: (context: Context, place: string, asked: Asked, frame: Frame) => Frame;

package/dist/src/answers/answered.js

@@ -0,0 +1,22 @@
+import { canonical } from '@lapxo/topos/wire';
+import { valueOf } from "../core/lock.js";
+import { rootIn } from "../flows/device.js";
+/** A body that answers nothing: no byte of it, or a list with no member. */
+const nothing = (bytes) => ((text) => text === '' || /^\[\s*\]$/.test(text))(new TextDecoder().decode(bytes).trim());
+/** Distinguish an empty response from missing transport bytes; only the latter leaves a named need. */
+export const answering = (context, place, asked, frame) => {
+    const need = `${valueOf(context.lock, 'place/needs')}/bytes/${frame.source}/${frame.operation}`, held = frame.lines.find((l) => l.scope === need && l.role === 'demands' && l.value !== 'withdraw');
+    const owe = (line) => ((root) => ('said' in root ? undefined : context.landRoot(place, [line], root.account)))(rootIn(context, place));
+    const withdrawn = ({ about: _about, sig: _sig, epoch: _epoch, ...l }) => canonical({ ...l, by: 'target', value: 'withdraw' });
+    return { ...frame,
+        typed: (status, bytes) => (nothing(bytes) ? Promise.resolve(frame.say('answered-nothing', { source: frame.source, operation: frame.operation, status, at: new Date(context.now()).toISOString() })) : frame.typed(status, bytes)),
+        send: async (attachment) => {
+            const got = await frame.send(attachment);
+            if (asked['ahead'] !== 'true' && got.kind === 'failed' && held === undefined)
+                await owe(canonical({ at: `policy:head/owed/${new Date(context.now()).toISOString()}`, by: 'target', form: 'alphabet', measure: 'id', role: 'demands', scope: need, value: frame.plan.origin }));
+            if (got.kind === 'got' && held !== undefined)
+                await owe(withdrawn(held));
+            return got;
+        },
+    };
+};

package/dist/src/compile/pin.js

@@ -4,11 +4,7 @@ import { members, under, valueOf } from "../core/lock.js";
 import { fieldsOf, vocabOf } from "../core/read.js";
 import { sayIn } from "../core/surface.js";
 import { digestIn, linesOf, pinnedOf } from "../core/worlds.js";
-/**
- * One compile, by the fold: the place view asked once, this source's lines kept with a region of its own — and the flow
- * of each issuer the source declares, so a flow is pinned once, by whoever declares it — and the standing bound selects
- * from them pinned and laid where its input names it.
- */
+/** Pin the compiled source and adopt only the declared outputs. */
 const compiledOf = async (context, place, source, file) => {
     const say = sayIn(context.lock), v = vocabOf(context.lock);
     const compiled = await context.world(place, valueOf(context.lock, 'place/view'));
@@ -53,7 +49,7 @@ export const pinIn = (context, place, lands, line) => async (source, read) => {
     if ('said' in pinned || (old?.needs === file && old.value === pinned.pin))
         return pinned;
     const withdraw = old === undefined ? [] : [canonical({ ...Object.fromEntries(Object.entries(old).filter(([k]) => !['sig', 'epoch'].includes(k))), by: 'target', value: 'withdraw' })];
-    const landed = await lands([...withdraw, line(`uses/${source}`, 'digest', pinned.pin, { needs: file, at: `policy:head/connect/${new Date(context.now()).toISOString()}` })]);
+    const landed = await lands([...withdraw, line(`uses/${source}`, 'digest', pinned.pin, { needs: file, at: `policy:person/connect/${new Date(context.now()).toISOString()}` })]);
     return 'refused' in landed ? { said: [say('not-landed', { why: landed.refused })] } : pinned;
 };
 /**

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

@@ -5,10 +5,7 @@ export interface Device {
     readonly signer: string;
 }
 export declare const deviceOf: (lock: readonly Said[], role?: string) => Device;
-/**
- * The drafted lines a place signs to admit a key: each device/<role>/<measure> line of head-s lock, said of keys/<id>, and
- * its public half. The id is the role's own unless whoever admits names it; so is the coverage, unless they give it.
- */
+/** Derive device authority from the admitted lock. */
 export declare const admissionOf: (lock: readonly Said[], publicKey: string, role?: string, as?: {
     readonly id?: string;
     readonly coverage?: string;

package/dist/src/core/device.js

@@ -3,14 +3,11 @@ import { members, said, valueOf } from "./lock.js";
 import { sayIn } from "./surface.js";
 const HEAD = 'head';
 export const deviceOf = (lock, role = HEAD) => ({ account: valueOf(lock, `device/${role}/account`), service: valueOf(lock, 'device/service'), signer: valueOf(lock, `device/${role}/signer`) });
-/**
- * The drafted lines a place signs to admit a key: each device/<role>/<measure> line of head-s lock, said of keys/<id>, and
- * its public half. The id is the role's own unless whoever admits names it; so is the coverage, unless they give it.
- */
+/** Derive device authority from the admitted lock. */
 export const admissionOf = (lock, publicKey, role = HEAD, as = {}) => ((id, at) => [
     ...['class', 'coverage', 'resolution', 'signer'].flatMap((measure) => ((line) => (line === undefined ? [] : [canonical({ at, by: 'target', form: line.form ?? 'alphabet', measure, role: 'writes', scope: `keys/${id}`, value: measure === 'coverage' && as.coverage ? as.coverage : line.value ?? '' })]))(said(lock, `device/${role}/${measure}`))),
     canonical({ at, by: 'target', form: 'alphabet', measure: 'public-key', role: 'writes', scope: `keys/${id}`, value: publicKey }),
-])(as.id ?? valueOf(lock, `device/${role}/account`), as.at ?? 'policy:head/device');
+])(as.id ?? valueOf(lock, `device/${role}/account`), as.at ?? 'policy:person/device');
 export const algorithmOf = (lines) => ((era) => (lines.find((l) => l.scope === 'wire/signature-algorithms')?.value ?? '').split('|').find((one) => one.endsWith(`:${era}`)) ?? '')(valueOf(lines, 'wire/era'));
 /** The id a place admits a public key under, as its own lines say: a key is who the place says it is, and a key it never admitted is no one there. */
 export const idIn = (lines, publicKey) => publicKey === undefined ? undefined : lines.find((l) => l.scope?.startsWith('keys/') && l.measure === 'public-key' && l.value === publicKey)?.scope.slice('keys/'.length);

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

@@ -1,7 +1,3 @@
 import type { Asked, Context } from '../core/answer.ts';
-/**
- * One offer that is not of the class head reads: within a cap the person signed it is called as far as the cap goes;
- * without one, each call asks the person once, and their yes is signed for exactly that request. The intent lands before
- * the call, the receipt after; a call that never answered stays open until a look of what it would have changed closes it.
- */
+/** Run one action within its declared authority, with the person's approval when required. */
 export declare const act: (asked: Asked, context: Context) => Promise<readonly string[]>;

package/dist/src/flows/act.js

@@ -4,11 +4,7 @@ import { draftOf } from "../core/receipt.js";
 import { sayIn } from "../core/surface.js";
 import { canonical } from '@lapxo/topos/wire';
 import { called } from "./call.js";
-/**
- * One offer that is not of the class head reads: within a cap the person signed it is called as far as the cap goes;
- * without one, each call asks the person once, and their yes is signed for exactly that request. The intent lands before
- * the call, the receipt after; a call that never answered stays open until a look of what it would have changed closes it.
- */
+/** Run one action within its declared authority, with the person's approval when required. */
 export const act = (asked, context) => called(asked, context, planAct, async ({ word, say, lines, source, operation, prepared, typed, attach, send, lands, widen, uncovered }) => {
     const [family, done] = [word('act/family'), word('act/done')];
     const allowed = allowedOf(lines, word('allow/family'), source, operation);

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

@@ -3,10 +3,7 @@ import type { Said } from '../core/lock.ts';
 import type { Call, Plan } from '../core/read.ts';
 import type { Attachment } from '../access/contract.ts';
 import type { Fetched, Prepared } from '../ports/adapters/request.ts';
-/**
- * The origin of a source a person picks once for a place, when its document declares several: offered as a choice among
- * them, none a default, and kept as the person's line; the lines a call stands on, with it.
- */
+/** Ask for one declared origin when the source offers several. */
 export declare const pickedOrigin: (context: Context, place: string, lines: readonly Said[], source: string, plan: Call | Plan) => Promise<{
     readonly lines: readonly Said[];
 } | {
@@ -40,9 +37,5 @@ export interface Frame {
     readonly send: (attachment: Attachment | undefined) => Promise<Fetched>;
     readonly uncovered: (role: string, scopes: readonly string[]) => readonly string[] | undefined;
 }
-/**
- * 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.
- */
+/** Prepare one call, authorize its access and pass its frame to the read or action flow. */
 export declare const called: (asked: Asked, context: Context, planOf: (lines: readonly Said[], lock: readonly Said[], source: string, operation: string, place: string) => Call | Plan, then: (frame: Frame) => Promise<readonly string[]>) => Promise<readonly string[]>;

package/dist/src/flows/call.js

@@ -5,13 +5,12 @@ import { sayIn } from "../core/surface.js";
 import { valueOf } from "../core/lock.js";
 import { uncoveredIn } from "../core/device.js";
 import { widening } from "./device.js";
+import { namedIn } from "../use/named.js";
+import { answering } from "../answers/answered.js";
 import { attachmentFor } from "../access/obtain.js";
 import { typedAnswer } from "./answer.js";
 import { standingFor } from "./world.js";
-/**
- * The origin of a source a person picks once for a place, when its document declares several: offered as a choice among
- * them, none a default, and kept as the person's line; the lines a call stands on, with it.
- */
+/** Ask for one declared origin when the source offers several. */
 export const pickedOrigin = async (context, place, lines, source, plan) => {
     if (plan.kind !== 'said' || plan.key !== 'pick-origin')
         return { lines };
@@ -27,18 +26,18 @@ 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)] };
 };
-/**
- * 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.
- */
+/** Prepare one call, authorize its access and pass its frame to the read or action flow. */
 export const called = async (asked, context, planOf, then) => {
     const say = (key, fields = {}) => [sayIn(context.lock)(key, fields)];
-    const [source, operation] = [asked['source'] ?? '', asked['operation'] ?? ''];
+    const source = asked['source'] ?? '';
     return inPlace(asked, context, async (place) => {
         const held = await standingFor(context, place);
         if ('unsettled' in held)
             return say('unsettled', { source, why: held.unsettled });
+        const named = await namedIn(context, held.lines, source, asked['operation'] ?? '', asked['ahead'] === 'true');
+        if ('said' in named)
+            return named.said;
+        const operation = named.operation;
         const widen = async (message, lot) => {
             const by = widening(context, place, held.lines, lot);
             if ('said' in by)
@@ -65,9 +64,10 @@ export const called = async (asked, context, planOf, then) => {
             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, 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 });
+        let use = named.use !== undefined && uncovered('head', [named.scope]) === undefined ? [named.use] : [];
+        const lands = (...lot) => { const once = use; use = []; return context.landAs(place, [...once, ...lot], 'head', lines).then((out) => ('lines' in out ? { lines: out.lines.filter((l) => !l.includes(` scope=${valueOf(context.lock, 'use/family')}/`)) } : out)); };
+        return then(answering(context, place, asked, { 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.d.ts

@@ -1,9 +1,3 @@
 import type { Asked, Context } from '../core/answer.ts';
-/**
- * A read of one offer the place declares of the class head reads: the response comes back once, typed by the world,
- * and both are kept — the body's digest and the typed answer's, receipts the device key signs. Asked again as the same
- * principal, while the place stands on what typed it, the person's grant holds now and the newest read is younger than
- * 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.
- */
+/** Read one permitted offer, reuse only under its policy and land the signed receipt. */
 export declare const readSource: (asked: Asked, context: Context) => Promise<readonly string[]>;

package/dist/src/flows/read.js

@@ -20,13 +20,7 @@ const closeWith = async (intent, source, digest, { word, lines, lands }, context
     const landed = await lands(draftOf('', word('receipt/at'), `${intent}/${word('act/closed')}`, digest, new Date(context.now()).toISOString()));
     return 'refused' in landed ? [say('not-landed', { why: landed.refused })] : [...landed.lines, say('closed', { intent, digest })];
 };
-/**
- * A read of one offer the place declares of the class head reads: the response comes back once, typed by the world,
- * and both are kept — the body's digest and the typed answer's, receipts the device key signs. Asked again as the same
- * principal, while the place stands on what typed it, the person's grant holds now and the newest read is younger than
- * 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.
- */
+/** Read one permitted offer, reuse only under its policy and land the signed receipt. */
 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);
@@ -86,7 +80,7 @@ export const readSource = (asked, context) => called(asked, context, planRead, a
     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 });
+        return say(got.kind === 'over' ? 'too-large' : 'unreachable-source', { source, why: got.kind === 'failed' ? got.why : '' });
     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]));

package/dist/src/index.js

@@ -17,7 +17,7 @@ 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";
+import { birth, closing, cooled, founded, land, landAct, limits, pinnedAt, policyAt, run, settledView, sign, standingAt, told, warm, words } from "./ports/bound.js";
 import { warmth } from "./ports/warm.js";
 import { held, keep } from "./ports/cache.js";
 import { registryFor } from "./ports/signers.js";
@@ -30,10 +30,15 @@ import { personOf } from "./ports/access/person.js";
 import { readAhead } from "./ahead/read.js";
 const [ext, root] = ((self) => [self.slice(self.lastIndexOf('.')), fileURLToPath(new URL(self.endsWith('.ts') ? '..' : '../..', self))])(import.meta.url);
 const lock = lockAt(root);
+if (process.argv[2] !== valueOf(lock, 'cli/run')) {
+    process.stdout.write(`${aboutOf(lock, 'cli/help')}\n`);
+    process.exit(0);
+}
 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', '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(birth, { at: valueOf(lock, 'founding/person-at'), file: valueOf(lock, 'founding/birth-file') });
 Object.assign(warmth, { spares: Number(valueOf(lock, 'bound/spares').split('..')[1]), boot: valueOf(lock, 'bound/spare-env').split('|') });
 /** One call at a time, each after the one before it and never on a timer, so one asked while another lands sees its receipt; bound started ahead for it, and nothing of it kept once it is answered. */
 let [last, ahead] = [Promise.resolve(), new AbortController()];

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

@@ -4,5 +4,6 @@ import { type Asked, type Context } from '../core/answer.ts';
  * 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

@@ -10,11 +10,14 @@ import { rootIn } from "../flows/device.js";
  * 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 {

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[]>;

package/dist/src/ports/bound.js

@@ -1,8 +1,8 @@
-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";
@@ -46,21 +46,13 @@ const nativeView = (name, place, view, signal) => {
     };
     return !words.identity ? read() : folded(`${name}/${view}`, place, async () => { const result = readingOf(await run(name, place, [words.read, words.view, `${words.identity}@${view}`], {}, signal), view); return 'refused' in result ? undefined : result.identity; }, read);
 };
-/**
- * The lines a place stands on, from bound's public views alone: its folded normative standing (the lines view) — its
- * policy, all that a reader of its pins, keys and views needs, read alone where nothing else is — and from
- * 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 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` }))(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 = await nativeView(name, place, words.evidence, signal);
     if ('refused' in evidence)
         return evidence;
     const ids = new Set(devicesOf(folded.lines)), own = evidence.lines.filter((line) => ids.has(line.by ?? ''));
@@ -74,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);
@@ -92,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 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/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; one question of several sources at once, by comparing what each said; 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

@@ -7,17 +7,9 @@ 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; one question of several sources at once, by comparing what each said; 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';

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<{

package/dist/src/verbs/card.js

@@ -3,8 +3,8 @@ import { LOCK } from '@lapxo/topos/wire';
 import { baseOf, standingOr } from "../core/answer.js";
 import { valueOf } from "../core/lock.js";
 /**
- * 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 const cardAt = async (context, place) => {
@@ -12,5 +12,5 @@ export const cardAt = async (context, place) => {
     if ('said' in held)
         return held;
     const read = `${valueOf(context.lock, 'receipt/at')}:`, keys = ['head', 'person'].map((role) => context.device(role) ?? '');
-    return { card: createHash('sha256').update([baseOf(held.lines.filter((l) => !l.at?.startsWith(read))), ...keys].join('\n')).digest('hex').slice(0, 16) };
+    return { card: createHash('sha256').update([baseOf(held.lines.filter((l) => !l.at?.startsWith(read) && !l.scope?.startsWith(`${valueOf(context.lock, 'use/family')}/`))), ...keys].join('\n')).digest('hex').slice(0, 16) };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lapxo/head",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "description": "An MCP server that folds: it runs bound as a process, hands a model what bound printed, and lands what it read as receipts.",
   "license": "MIT",