@lapxo/head 0.1.5 → 0.1.7

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

@@ -6,18 +6,11 @@ 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 { viewed } from "../claims/view.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';
@@ -29,7 +22,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['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')
+    const answer = asked['sources'] && founded ? await compared(asked, context, place) : asked['lines'] ? await read('plan', 'plan') : founded && asked['view'] === valueOf(context.lock, 'claim/view') ? await viewed(asked, context) : 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<{

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/dist/src/walk/context.js

@@ -2,6 +2,7 @@ import { join } from 'node:path';
 import { canonical, LOCK } from '@lapxo/topos/wire';
 import { members, valueOf } from "../core/lock.js";
 import { linesOf } from "../core/worlds.js";
+import { pinnedAs } from "../compile/pin.js";
 /**
  * A place made walkable once it is founded: the context another place authenticates it by — its wire, its keys and its
  * origin, read off the lines it was born with — folded by bound into a standing, laid beside its lock and pinned by its
@@ -11,13 +12,9 @@ export const walkable = async (context, dir, account) => {
     const [word, at] = [(k) => valueOf(context.lock, k), valueOf(context.lock, 'walk/context/file')];
     const reads = members(word('walk/context/reads'));
     const born = linesOf(context.files.take(join(dir, LOCK)) ?? new Uint8Array()).filter((l) => reads.some((r) => (r.endsWith('/**') ? l.scope?.startsWith(r.slice(0, -2)) : l.scope === r)) && l.value !== 'withdraw');
-    const draft = at.replace(/\.bound$/, '.draft.bound');
-    context.files.lay(dir, draft, new TextEncoder().encode(`${[...born.map(({ sig: _s, epoch: _e, ...l }) => canonical({ ...l, by: 'target' })),
-        canonical({ at: 'policy:head/walk', by: 'target', form: 'alphabet', measure: 'reads', role: 'writes', scope: word('walk/context/region'), value: reads.join('|') })].join('\n')}\n`));
-    const pinned = await context.pinned(dir, draft);
-    context.files.drop(dir, draft);
+    const pinned = await pinnedAs(context, dir, at, [...born.map(({ sig: _s, epoch: _e, ...l }) => canonical({ ...l, by: 'target' })),
+        canonical({ at: 'policy:head/walk', by: 'target', form: 'alphabet', measure: 'reads', role: 'writes', scope: word('walk/context/region'), value: reads.join('|') })]);
     if (pinned === undefined || 'refused' in pinned)
         return { refused: pinned === undefined ? 'walk context folded nothing' : pinned.refused };
-    context.files.lay(dir, at, new TextEncoder().encode(pinned.bytes));
     return context.landRoot(dir, [canonical({ at: 'policy:head/walk', by: 'target', form: 'alphabet', measure: 'digest', needs: at, role: 'writes', scope: 'walk/context', value: pinned.pin })], account);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lapxo/head",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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",
@@ -26,8 +26,8 @@
     "test": "node --test test/*.test.ts && node --test --test-concurrency=1 test/time/*.test.ts"
   },
   "dependencies": {
-    "@lapxo/bound": "0.2.5",
-    "@lapxo/topos": "0.2.1",
+    "@lapxo/bound": "0.2.7",
+    "@lapxo/topos": "0.2.4",
     "@modelcontextprotocol/sdk": "1.32.1"
   },
   "devDependencies": {

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

@@ -1,6 +0,0 @@
-/**
- * The host's registry bound reads to bind a declared signer name to a program: head's own signer, started by this node,
- * told the keychain service, the account its secret is kept under, the key it signs as, the algorithm and the store this
- * host keeps secrets in. It holds no secret; it lives beside nothing a repository ships.
- */
-export declare const registryFor: (name: string, service: string, account: string, key: string, algorithm: string, store?: string) => string;

package/dist/src/ports/signers.js

@@ -1,14 +0,0 @@
-import { writeFileSync, mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-/**
- * The host's registry bound reads to bind a declared signer name to a program: head's own signer, started by this node,
- * told the keychain service, the account its secret is kept under, the key it signs as, the algorithm and the store this
- * host keeps secrets in. It holds no secret; it lives beside nothing a repository ships.
- */
-export const registryFor = (name, service, account, key, algorithm, store = 'keychain') => {
-    const at = join(mkdtempSync(join(tmpdir(), 'head-signers-')), 'signers.json');
-    writeFileSync(at, JSON.stringify({ [name]: { kind: 'command', executable: process.execPath, args: [fileURLToPath(new URL(`../signer${import.meta.url.slice(import.meta.url.lastIndexOf('.'))}`, import.meta.url)), service, account, key, algorithm, store] } }));
-    return at;
-};

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

@@ -1 +0,0 @@
-export {};

package/dist/src/ports/spare.js

@@ -1,33 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { readFileSync } from 'node:fs';
-import { Socket } from 'node:net';
-import { pathToFileURL } from 'node:url';
-/**
- * A process started before it is asked: it loads what the program it will run imports, says it is ready on its fourth
- * pipe, and waits there for one ask, the folder, the arguments and the variables a process started then would have been
- * given. It takes them as its own, closes that pipe and runs the program once, as that process would have. An ask that
- * never comes ends it.
- */
-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(/(?:^|[;\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)
-    process.exit(0);
-const { cwd, args, env } = JSON.parse(text);
-for (const name of Object.keys(process.env))
-    if (!(name in env))
-        delete process.env[name];
-Object.assign(process.env, env);
-process.chdir(cwd);
-process.argv = [process.argv[0], program, ...args];
-await import(__rewriteRelativeImportExtension(url.href));

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

@@ -1,19 +0,0 @@
-import type { Bounds, Printed } from './process.ts';
-/** How many processes head keeps started ahead of each program while it answers a call, and the variables node reads as it starts: a process started under other values of them is never asked. */
-export declare const warmth: {
-    spares: number;
-    boot: readonly string[];
-};
-/** Keeps as many processes started ahead of a program as head's lock says; resolved when each has loaded what it runs. */
-export declare const kept: (program: string) => Promise<unknown>;
-/** Every process still waiting to be asked is stopped: head keeps none past the call it started them for. */
-export declare const cooled: () => void;
-/**
- * A program run in a process started ahead under the same starting variables, handed the folder, arguments and
- * variables a process started now would get, and watched within the same bounds; undefined when none is held ready,
- * so the caller starts one as before and never waits on one still loading. Each process answers one ask and ends.
- */
-export declare const warmed: (program: string, args: readonly string[], at: {
-    readonly cwd: string;
-    readonly env: NodeJS.ProcessEnv;
-}, bounds: Bounds) => Promise<Printed> | undefined;

package/dist/src/ports/warm.js

@@ -1,45 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { grouped, watched } from "./process.js";
-/** How many processes head keeps started ahead of each program while it answers a call, and the variables node reads as it starts: a process started under other values of them is never asked. */
-export const warmth = { spares: 0, boot: [] };
-const spares = new Map();
-const alive = (one) => one.child.exitCode === null && one.child.signalCode === null;
-const entry = fileURLToPath(new URL(`./spare${import.meta.url.slice(import.meta.url.lastIndexOf('.'))}`, import.meta.url));
-const bootOf = (env) => JSON.stringify(Object.entries(env).filter(([name]) => warmth.boot.some((p) => name.startsWith(p))).sort(([a], [b]) => (a < b ? -1 : 1)));
-const stop = (one) => { try {
-    process.kill(-one.child.pid, 'SIGKILL');
-}
-catch {
-    one.child.kill('SIGKILL');
-} };
-const started = (program) => {
-    const env = { ...process.env }, child = grouped(process.execPath, [entry, program], { env }, 4);
-    child.stdin.on('error', () => undefined).end('');
-    const spare = { child, boot: bootOf(env), ready: new Promise((resolve) => { child.stdio[3].on('error', () => undefined).once('data', () => { spare.loaded = true; resolve(); }); child.once('close', () => resolve()); }), loaded: false };
-    return spare;
-};
-/** Keeps as many processes started ahead of a program as head's lock says; resolved when each has loaded what it runs. */
-export const kept = (program) => {
-    const live = (spares.get(program) ?? []).filter(alive);
-    while (live.length < warmth.spares)
-        live.push(started(program));
-    spares.set(program, live);
-    return Promise.all(live.map((one) => one.ready));
-};
-/** Every process still waiting to be asked is stopped: head keeps none past the call it started them for. */
-export const cooled = () => { for (const one of [...spares.values()].flat())
-    stop(one); spares.clear(); };
-process.once('exit', cooled);
-/**
- * A program run in a process started ahead under the same starting variables, handed the folder, arguments and
- * variables a process started now would get, and watched within the same bounds; undefined when none is held ready,
- * so the caller starts one as before and never waits on one still loading. Each process answers one ask and ends.
- */
-export const warmed = (program, args, at, bounds) => {
-    const live = spares.get(program) ?? [], index = live.findIndex((one) => one.loaded && alive(one) && one.boot === bootOf(at.env));
-    const spare = index < 0 ? undefined : live.splice(index, 1)[0];
-    if (spare === undefined)
-        return undefined;
-    spare.child.stdio[3].end(`${JSON.stringify({ cwd: at.cwd, args, env: at.env })}\n`);
-    return watched(spare.child, bounds).finally(() => { void kept(program); });
-};