@lapxo/head 0.1.6 → 0.2.0

package/dist/src/ports/scratch.js

@@ -0,0 +1,10 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+const made = new Set();
+/** A file one bound run reads, in a folder of its own under this device's temporary folder, kept only until that run ends. */
+export const scratchOf = (prefix, name, text) => ((dir) => { made.add(dir); writeFileSync(join(dir, name), text); return join(dir, name); })(mkdtempSync(join(tmpdir(), prefix)));
+/** The folders made for what a run read, removed once it ended, however it ended; any other path is left as it is. */
+export const cleared = (paths) => { for (const at of paths)
+    if (made.delete(dirname(at)))
+        rmSync(dirname(at), { recursive: true, force: true }); };

package/dist/src/signer.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { readFileSync } from 'node:fs';
-import { signLot } from "./ports/keys.js";
-import { keychain } from "./ports/keychain.js";
-const [service = '', account = '', key = '', algorithm = '', store = 'keychain'] = process.argv.slice(2);
-const secret = keychain(service, store).read(account);
-if (secret === undefined)
-    process.exit(1);
+import { newKey, publicOf, signLot } from "./ports/keys.js";
+import { secretsOf } from "./ports/keychain.js";
+/** The one process that reads a signing secret, and it prints a public half at most: `make` keeps a key made once, `exists` says whether one is kept, else it signs the lot on stdin. */
+const [first = '', ...rest] = process.argv.slice(2), half = first === 'make' || first === 'exists', [service = '', account = '', key = '', algorithm = '', store = 'keychain'] = half ? [rest[0], rest[1], '', '', rest[2]] : [first, ...rest], keys = secretsOf(service, store);
+const kept = keys.read(account) ?? (first === 'make' ? ((made) => { keys.write(account, made.secret); return keys.read(account) === made.secret ? made.secret : undefined; })(newKey()) : undefined);
+if (kept === undefined)
+    process.exit(half ? 3 : 1);
 try {
-    process.stdout.write(signLot(readFileSync(0, 'utf8'), secret, key, algorithm));
+    process.stdout.write(half ? publicOf(kept) : signLot(readFileSync(0, 'utf8'), kept, key, algorithm));
 }
 catch {
     process.exit(1);

package/dist/src/sources/connect.js

@@ -1,6 +1,6 @@
 import { canonical, EXTENSION } from '@lapxo/topos/wire';
 import { inPlace, placeOf, unless } from "../core/answer.js";
-import { valueOf } from "../core/lock.js";
+import { members, valueOf } from "../core/lock.js";
 import { fieldsOf, vocabOf } from "../core/read.js";
 import { redIn, sayIn } from "../core/surface.js";
 import { digestIn, linesOf } from "../core/worlds.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 { receivedBirth } from "../links/birth.js";
 import { linked } from "../links/inspect.js";
 import { rootIn } from "../flows/device.js";
 import { attachedFor } from "./access.js";
@@ -23,7 +24,7 @@ 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) => ((asked['document'] ?? '').startsWith(valueOf(context.lock, 'link/prefix')) ? linked(asked, context)
+export const connected = async (asked, context, covered = false) => (await receivedBirth(asked, context)) ?? (members(valueOf(context.lock, 'link/prefixes')).some(prefix => (asked['document'] ?? '').startsWith(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) => {

package/dist/src/tools/card.js

@@ -1,13 +1,11 @@
-import { inPlace, printedOr, standingOr } from "../core/answer.js";
+import { authorityFor } from "../flows/plan.js";
+import { inStanding, inPlace, printedOr } from "../core/answer.js";
 import { members, valueOf } from "../core/lock.js";
 import { sayIn } from "../core/surface.js";
 /** What is open for a key: the cells view the place's standing declares, as bound folded it at the resolution asked, narrowed to the key; a refused fold is said, never read as no view. The standing is the one the card was read off, folded once a call. */
-export const answer = (asked, context) => inPlace(asked, context, async (place) => {
+export const answer = (asked, context) => asked['lines'] !== undefined || asked['preflight'] !== undefined || asked['authority'] !== undefined ? inPlace(asked, context, async (place) => (await authorityFor(context, place, asked['key'] ?? '', asked['preflight'] ?? 'record-coverage', (asked['lines'] ?? '').split('\n').filter(Boolean), true, asked['authority']))) : inStanding(asked, context, async (place, lines) => {
     const word = (scope) => valueOf(context.lock, `bound/${scope}`);
-    const held = await standingOr(context, place);
-    if ('said' in held)
-        return held.said;
-    const view = held.lines.find((f) => f.scope?.startsWith('view/') && !f.shape && members(f.value ?? '').includes(word('cells')));
+    const view = lines.find((f) => f.scope?.startsWith('view/') && !f.shape && members(f.value ?? '').includes(word('cells')));
     if (view === undefined)
         return [sayIn(context.lock)('no-cells', { place })];
     return printedOr(context, await context.bound(place, [word('read'), word('view'), `${view.scope.split('/')[1]}${asked['at'] ? `${word('at')}${asked['at']}` : ''}`, ...(asked['key'] ? [word('key'), asked['key']] : [])]));

package/dist/src/use/named.js

@@ -5,16 +5,16 @@ 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}/`);
+export const offersOf = (lock, lines, source) => ((v) => ((at) => lines.filter((l) => l.measure === v.class && l.scope?.startsWith(at)).map((l) => l.scope.slice(at.length)))(`${v.offers}/${source}/`))(vocabOf(lock));
 /** 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 [family, name] = [word('use/family'), words(asked).join('-')], uses = lines.filter((l) => l.scope?.startsWith(`${family}/${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 found = ((offers) => offers.includes(asked) ? [asked] : offers.filter((op) => words(asked).length > 0 && words(asked).every((w) => named(op).includes(w))))(offersOf(context.lock, lines, source));
     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 };

package/dist/src/verbs/ask.js

@@ -6,6 +6,7 @@ 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";
 /** Route a question at the declared resolution, then attach the card of the place it read. */
 export const asked = async (asked, context) => {
@@ -21,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 = carded && (asked['lines'] !== undefined || asked['preflight'] !== undefined || asked['authority'] !== undefined) ? await read('card', 'card', { place }) : 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.js

@@ -11,6 +11,6 @@ export const cardAt = async (context, place) => {
     const held = place === undefined || !context.files.has(place, LOCK) ? { lines: [] } : await standingOr(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) && !l.scope?.startsWith(`${valueOf(context.lock, 'use/family')}/`))), ...keys].join('\n')).digest('hex').slice(0, 16) };
+    const read = `${valueOf(context.lock, 'receipt/at')}:`, use = `${valueOf(context.lock, 'use/family')}/`, keys = ['head', 'person'].map((role) => context.device(role) ?? '');
+    return { card: createHash('sha256').update([baseOf(held.lines.filter((l) => !l.at?.startsWith(read) && !l.scope?.startsWith(use))), ...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.6",
+  "version": "0.2.0",
   "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.8",
+    "@lapxo/topos": "0.2.4",
     "@modelcontextprotocol/sdk": "1.32.1"
   },
   "devDependencies": {

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

@@ -1,8 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/** 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/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); });
-};