@lapxo/head 0.0.0-stage → 0.1.3

package/dist/src/ports/warm.js

@@ -0,0 +1,46 @@
+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;
+    void kept(program);
+    spare.child.stdio[3].end(`${JSON.stringify({ cwd: at.cwd, args, env: at.env })}\n`);
+    return watched(spare.child, bounds);
+};

package/dist/src/resources/view.d.ts

@@ -0,0 +1 @@
+export { answer } from '../tools/look.ts';

package/dist/src/resources/view.js

@@ -0,0 +1 @@
+export { answer } from "../tools/look.js";

package/dist/src/signer.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/signer.js

@@ -0,0 +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);
+try {
+    process.stdout.write(signLot(readFileSync(0, 'utf8'), secret, key, algorithm));
+}
+catch {
+    process.exit(1);
+}

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

@@ -0,0 +1,17 @@
+import type { Asked, Context } from '../core/answer.ts';
+import type { Call } from '../core/read.ts';
+import type { Attachment } from '../access/contract.ts';
+/**
+ * Access to a source obtained ahead of any call, at the origin the person picked once where several are declared: the
+ * way its document says access is proven, run by the adapter of
+ * that kind — the person's own page, or the provider they are sent to with a client registered for the visit — its
+ * secret kept in this keychain and its obtaining landed as a receipt the device key signs. Nothing is called. What it
+ * attaches is what a fetch made as that source carries, to that source's own origin alone.
+ */
+export declare const accessed: (asked: Asked, context: Context) => Promise<readonly string[]>;
+export declare const attachedFor: (context: Context, place: string, source: string, asked?: string) => Promise<{
+    readonly plan: Call;
+    readonly attachment: Attachment | undefined;
+} | {
+    readonly said: readonly string[];
+}>;

package/dist/src/sources/access.js

@@ -0,0 +1,39 @@
+import { inPlace, placeNameOf } from "../core/answer.js";
+import { uncoveredIn } from "../core/device.js";
+import { valueOf } from "../core/lock.js";
+import { planRead, vocabOf } from "../core/read.js";
+import { sayIn } from "../core/surface.js";
+import { attachmentFor } from "../access/obtain.js";
+import { pickedOrigin } from "../flows/call.js";
+import { standingFor } from "../flows/world.js";
+/**
+ * Access to a source obtained ahead of any call, at the origin the person picked once where several are declared: the
+ * way its document says access is proven, run by the adapter of
+ * that kind — the person's own page, or the provider they are sent to with a client registered for the visit — its
+ * secret kept in this keychain and its obtaining landed as a receipt the device key signs. Nothing is called. What it
+ * attaches is what a fetch made as that source carries, to that source's own origin alone.
+ */
+export const accessed = (asked, context) => inPlace(asked, context, async (place) => {
+    const got = await attachedFor(context, place, asked['source'] ?? '', asked['operation']);
+    return 'said' in got ? got.said : [sayIn(context.lock)(got.plan.access.account === undefined ? 'access-anonymous' : 'access-kept', { source: got.plan.source })];
+});
+export const attachedFor = async (context, place, source, asked) => {
+    const [say, v] = [sayIn(context.lock), vocabOf(context.lock)];
+    const held = await standingFor(context, place);
+    if ('unsettled' in held)
+        return { said: [say('unsettled', { source, why: held.unsettled })] };
+    const operation = asked || held.lines.filter((l) => l.measure === v.class && l.value === v.callable && l.scope?.startsWith(`${v.offers}/${source}/`)).map((l) => l.scope.split('/').slice(2).join('/')).sort()[0];
+    if (operation === undefined)
+        return { said: [say('unread', { source })] };
+    const picked = await pickedOrigin(context, place, held.lines, source, planRead(held.lines, context.lock, source, operation, placeNameOf(place)));
+    if ('said' in picked)
+        return picked;
+    const plan = planRead(picked.lines, context.lock, source, operation, placeNameOf(place));
+    if (plan.kind === 'said')
+        return { said: [say(plan.key, plan.fields)] };
+    const stopped = uncoveredIn(context.lock, held.lines, context.device('head'), place, [], [`${valueOf(context.lock, 'access/family')}/${source}/${plan.access.scheme || v.anonymous}/obtained`]);
+    if (stopped)
+        return { said: stopped };
+    const got = await attachmentFor(context, place, picked.lines, plan);
+    return 'said' in got ? { said: [say(got.said, { source, operation, kinds: plan.access.kind, input: got.input })] } : { plan, attachment: got.attachment };
+};

package/dist/src/sources/connect.d.ts

@@ -0,0 +1,13 @@
+import type { Asked, Context } from '../core/answer.ts';
+/**
+ * A source connected to a place, once the person said yes; a lock is no source, and adopting one as a parent is refused
+ * by name, since composing two places' policies is bound's. A document — and an overlay beside it — is laid whatever its
+ * kind, with every world head carries adopted, and the fold decides which reads it: what no world compiles is open, the
+ * bytes taken back and the line that pays it handed on. What one does is compiled once per digest of what it read — the
+ * same bytes again find their compiled standing by name — and pinned from the place's store: a new pin lands with the
+ * old one's withdraw, said at its own time, since a withdrawn saying stays withdrawn. A lock named by its digest is a
+ * package another place shared: checked whole, then — on one yes to all it names — each source connected in the order
+ * 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 declare const connected: (asked: Asked, context: Context, covered?: boolean) => Promise<readonly string[]>;

package/dist/src/sources/connect.js

@@ -0,0 +1,130 @@
+import { join } from 'node:path';
+import { canonical, EXTENSION, LOCK } from '@lapxo/topos/wire';
+import { inPlace, placeOf, unless } from "../core/answer.js";
+import { valueOf } from "../core/lock.js";
+import { fieldsOf, vocabOf } from "../core/read.js";
+import { fill, redIn, sayIn } from "../core/surface.js";
+import { digestIn, linesOf } from "../core/worlds.js";
+import { coveredIn, owedIn, unpacked } from "../core/package.js";
+import { paidBy, pinIn } from "../compile/pin.js";
+import { adopted } from "../adopt/adopt.js";
+import { firstRun } from "../onboard/first.js";
+import { rootIn } from "../flows/device.js";
+import { bornAt } from "../places/found.js";
+import { untilOf } from "../core/act.js";
+import { attachedFor } from "./access.js";
+/**
+ * A source connected to a place, once the person said yes; a lock is no source, and adopting one as a parent is refused
+ * by name, since composing two places' policies is bound's. A document — and an overlay beside it — is laid whatever its
+ * kind, with every world head carries adopted, and the fold decides which reads it: what no world compiles is open, the
+ * bytes taken back and the line that pays it handed on. What one does is compiled once per digest of what it read — the
+ * same bytes again find their compiled standing by name — and pinned from the place's store: a new pin lands with the
+ * old one's withdraw, said at its own time, since a withdrawn saying stays withdrawn. A lock named by its digest is a
+ * package another place shared: checked whole, then — on one yes to all it names — each source connected in the order
+ * 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['source'] && !(await placeOf(asked, context)) ? firstRun(asked, context, (dir, covered) => connected({ ...asked, place: dir }, context, covered))
+    : !asked['source'] && /^([a-z]+:\/\/)?[^/\s]+\/?$/.test(asked['document'] ?? '') ? used(asked, context) : ((started) => inPlace(asked, context, async (place) => {
+        const say = sayIn(context.lock), digest = digestIn(context.lock), { documentOf, fetchedAs, kindOf } = context.files.read;
+        const [source, document] = [(asked['source'] ?? '').toLowerCase().replace(/[^a-z0-9-]+/g, '-'), asked['document'] ?? ''];
+        const [via, named, accept, lock] = [asked['via'] ?? '', asked['digest'] ?? '', /^[\w.+-]+\/[\w.+-]+$/.test(asked['accept'] ?? '') ? asked['accept'] : undefined, `.${kindOf(document)}` === EXTENSION];
+        if (lock && !named)
+            return [say('parent-lock', { place, parent: source || document })];
+        if (!source && !lock)
+            return [say('missing-param', { operation: 'connect', param: 'source' })];
+        const root = rootIn(context, place);
+        if ('said' in root)
+            return root.said;
+        if (named && !/^sha256:[0-9a-f]{64}$/.test(named))
+            return [say('document-digest', { document, digest: named, got: '' })];
+        if (lock)
+            return ((read) => (read === undefined ? [say('document-unread', { document })] : digest(read.bytes) !== named ? [say('document-digest', { document, digest: named, got: digest(read.bytes) })]
+                : received(context, place, document, read.bytes, named, laidIn(context, place, root.account), root.account)))(await documentOf(context, place, document, named));
+        const refused = covered ? undefined : await unless(context, say('elicit-connect', { source, document, place, overlay: asked['overlay'] ?? '' }));
+        if (refused)
+            return refused;
+        const got = via ? await attachedFor(context, place, via) : undefined;
+        if (got && 'said' in got)
+            return got.said;
+        const [read, overlay] = [got ? await fetchedAs(context, document, via, got, named, accept) : await documentOf(context, place, document, named), asked['overlay'] ? await documentOf(context, place, asked['overlay']) : undefined];
+        if (read !== undefined && 'said' in read)
+            return read.said;
+        if (read === undefined || (asked['overlay'] && overlay === undefined))
+            return [say('document-unread', { document })];
+        if (named && digest(read.bytes) !== named)
+            return [say('document-digest', { document, digest: named, got: digest(read.bytes) })];
+        return `.${read.kind}` === EXTENSION ? [say('parent-lock', { place, parent: source })] : laidIn(context, place, root.account)(source, document, read, overlay, started);
+    }))(context.machine()));
+const used = async (asked, context) => {
+    const [say, word, until] = [sayIn(context.lock), (k) => valueOf(context.lock, k), untilOf(valueOf(context.lock, 'access/period'), context.now())], at = /^[a-z]+:\/\//.test(asked['document'] ?? '') ? asked['document'] : `${word('use/scheme')}//${asked['document'] ?? ''}`;
+    if (!URL.canParse(at))
+        return [say('document-unread', { document: asked['document'] ?? '' })];
+    const [origin, source] = [new URL(at).origin, new URL(at).hostname.replace(/[^a-z0-9-]+/g, '-')], dir = join(fill(word('use/folder'), { home: context.home() }), source);
+    if (context.files.has(dir, LOCK))
+        return [say('use-held', { origin, dir })];
+    const refused = await unless(context, say('elicit-use', { origin, dir, until }));
+    if (refused)
+        return refused;
+    const born = await bornAt(context, dir, source), root = rootIn(context, dir), tried = [];
+    if (born[0] !== say('born', { name: source, dir }) || 'said' in root)
+        return 'said' in root ? [...born, ...root.said] : born;
+    for (const document of await context.files.read.describedAt(context, origin)) {
+        const read = await context.files.read.documentOf(context, dir, document);
+        if (read === undefined || `.${read.kind}` === EXTENSION) {
+            tried.push(document);
+            continue;
+        }
+        const said = await laidIn(context, dir, root.account)(source, document, read, undefined, context.machine()), held = await context.policy(dir);
+        if ('refused' in held || !held.lines.some((l) => l.scope === `uses/${source}`)) {
+            tried.push(document);
+            continue;
+        }
+        const line = (scope, measure, value, form = 'alphabet') => canonical({ at: 'policy:head/use', by: 'target', form, measure, role: 'writes', scope, value });
+        const landed = await context.landRoot(dir, [line(`${word('allow/family')}/${source}`, 'calls', '0..0', 'interval'), line(word('grant/family'), 'sources', source), line(word('grant/family'), 'until', until)], root.account);
+        return [say('used', { origin, dir, source, until }), ...said, ...('refused' in landed ? [say('not-landed', { why: landed.refused })] : landed.lines)];
+    }
+    return [...born, say('use-none', { origin, tried: tried.join(', ') || '—' })];
+};
+const received = async (context, place, document, bytes, named, laid, account) => {
+    const [say, got] = [sayIn(context.lock), unpacked(context, document, bytes, await context.files.read.besideOf(context, document, linesOf(bytes)))];
+    if (!got.sources)
+        return got.said ?? [];
+    const [names, said, before] = [got.sources.map((s) => s.source).join(', '), [], await context.policy(place)];
+    const refused = coveredIn(context, 'refused' in before ? [] : before.lines, got.sources, named) ? undefined : await unless(context, say('elicit-receive', { place, package: named, sources: names || '—', open: (got.open ?? []).map((o) => o.source).join(', ') || '—' }));
+    if (refused)
+        return refused;
+    for (const s of got.sources)
+        said.push(...(await laid(s.source, s.document.at, s.document, s.overlay, context.machine())));
+    const held = await context.policy(place), [pinOf, owed] = [(source) => ('refused' in held ? '' : held.lines.find((l) => l.scope === `uses/${source}`)?.value ?? ''), owedIn(context, 'refused' in held ? [] : held.lines, got.sources, got.open ?? [], named)];
+    const [off, landed] = [got.sources.filter((s) => pinOf(s.source) !== s.pin), owed.length ? await context.landRoot(place, owed, account) : undefined];
+    return [...said, ...(off.length ? off.map((s) => say('package-pin', { source: s.source, pin: s.pin, got: pinOf(s.source) || 'none' })) : names ? [say('received', { place, package: named, sources: names })] : []),
+        ...(got.open ?? []).map((o) => say('received-open', { source: o.source, waits: o.waits })), ...(landed && 'refused' in landed ? [say('not-landed', { why: landed.refused })] : [])];
+};
+const laidIn = (context, place, account) => (source, document, doc, overlay, started) => (async () => {
+    const say = sayIn(context.lock), v = vocabOf(context.lock), word = (k) => valueOf(context.lock, k), digest = digestIn(context.lock);
+    const lands = (lot) => context.landRoot(place, lot, account);
+    const line = (scope, measure, value, more = {}) => canonical({ at: 'policy:head/connect', by: 'target', form: 'alphabet', measure, role: 'writes', scope, value, ...more });
+    const pin = pinIn(context, place, lands, line);
+    const worlds = await adopted(context, place, lands, line);
+    if ('refused' in worlds)
+        return [say('not-landed', { why: worlds.refused })];
+    const laid = [[`${word('place/connected')}/${source}.${doc.kind}`, doc.bytes], ...(overlay ? [[`${word('place/connected')}/${source}.overlay.${overlay.kind}`, overlay.bytes]] : [])];
+    for (const [at, bytes] of laid)
+        context.files.lay(place, at, bytes);
+    const pinned = await pin(source, laid.map(([at, bytes]) => `${at} ${digest(bytes)}`));
+    if ('said' in pinned) {
+        if (pinned.open || pinned.dropped)
+            for (const [at] of laid)
+                context.files.drop(place, at);
+        return pinned.open ? [say('no-world', { kind: doc.kind, document }), line(`${word('place/needs')}/${doc.kind}`, 'id', valueOf(context.lock, 'birth/view/place'), { role: 'demands' })] : pinned.said;
+    }
+    const declared = fieldsOf(pinned.lines, `${v.region}/${source}`)[v.origins] ?? [], fetched = URL.canParse(document) && !declared.some((o) => URL.canParse(o)) && ((held) => 'lines' in held && !held.lines.some((l) => l.scope === `${v.pick}/${source}`))(await context.policy(place));
+    const picked = fetched ? await lands([line(`${v.pick}/${source}`, 'id', new URL(declared[0] ?? '/', document).href.replace(/\/$/, ''))]) : undefined;
+    const [owed, paid] = [pinned.lines.filter((l) => l.measure === v.unresolved).map((l) => l.value ?? ''), await paidBy(context, place, pin, laid[0][0])];
+    const classes = pinned.lines.filter((l) => l.measure === v.class && l.scope?.startsWith(`${v.offers}/${source}/`) && l.scope.split('/').length === 3);
+    return [say('connected', { source, place, offers: String(classes.length), reads: String(classes.filter((l) => l.value === v.callable).length), pin: pinned.pin }),
+        ...(owed.length ? [say('unresolved', { source, refs: owed.join(', ') })] : []), ...paid.flatMap((p) => ('said' in p.pinned ? p.pinned.said : [say('resolved', { source: p.source, by: source, pin: p.pinned.pin })])),
+        ...pinned.lines.filter((l) => l.scope === `${v.region}/${source}` || (l.scope?.startsWith(`${v.keys}/${source}/`) && l.measure === v.scheme)).map((l) => canonical(l)),
+        ...(picked === undefined ? [] : 'refused' in picked ? [say('not-landed', { why: picked.refused })] : picked.lines)];
+})().then((lines) => [...lines, ...redIn(context.lock)('connect/seconds', `connect/${source}`, started, context.machine())]);

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

@@ -0,0 +1 @@
+export { accessed as answer } from '../sources/access.ts';

package/dist/src/tools/access.js

@@ -0,0 +1 @@
+export { accessed as answer } from "../sources/access.js";

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

@@ -0,0 +1 @@
+export { act as answer } from '../flows/act.ts';

package/dist/src/tools/act.js

@@ -0,0 +1 @@
+export { act as answer } from "../flows/act.js";

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

@@ -0,0 +1 @@
+export { admitted as answer } from '../places/admit.ts';

package/dist/src/tools/admit.js

@@ -0,0 +1 @@
+export { admitted as answer } from "../places/admit.js";

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

@@ -0,0 +1,3 @@
+import type { Answer } from '../core/answer.ts';
+/** What is open for a key: the cells view the place's standing declares, as bound folded it, narrowed to the key; a refused fold is said, never read as no view. */
+export declare const answer: Answer;

package/dist/src/tools/card.js

@@ -0,0 +1,13 @@
+import { inPlace, printedOr, standingOr } from "../core/answer.js";
+import { aboutOf, members, valueOf } from "../core/lock.js";
+/** What is open for a key: the cells view the place's standing declares, as bound folded it, narrowed to the key; a refused fold is said, never read as no view. */
+export const answer = (asked, context) => inPlace(asked, context, async (place) => {
+    const word = (scope) => valueOf(context.lock, `bound/${scope}`);
+    const held = await standingOr(context, place, context.policy);
+    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')));
+    if (view === undefined)
+        return [aboutOf(context.lock, 'said/no-cells')];
+    return printedOr(context, await context.bound(place, [word('read'), word('view'), view.scope.split('/')[1], ...(asked['key'] ? [word('key'), asked['key']] : [])]));
+});

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

@@ -0,0 +1 @@
+export { connected as answer } from '../sources/connect.ts';

package/dist/src/tools/connect.js

@@ -0,0 +1 @@
+export { connected as answer } from "../sources/connect.js";

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

@@ -0,0 +1,3 @@
+import type { Answer } from '../core/answer.ts';
+/** The lines that admit this device: its key is read from the keychain, or made there once; only its public half goes out. */
+export declare const answer: Answer;

package/dist/src/tools/key.js

@@ -0,0 +1,11 @@
+import { admissionOf, deviceOf } from "../core/device.js";
+import { aboutOf } from "../core/lock.js";
+import { deviceKey } from "../flows/device.js";
+/** The lines that admit this device: its key is read from the keychain, or made there once; only its public half goes out. */
+export const answer = async (asked, context) => {
+    const role = asked['who'] || undefined;
+    if (!deviceOf(context.lock, role).account)
+        return [aboutOf(context.lock, 'said/no-role')];
+    const key = deviceKey(context, role);
+    return key === undefined ? [aboutOf(context.lock, 'said/no-keychain')] : admissionOf(context.lock, key, role);
+};

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

@@ -0,0 +1 @@
+export { landLot as answer } from '../flows/plan.ts';

package/dist/src/tools/land.js

@@ -0,0 +1 @@
+export { landLot as answer } from "../flows/plan.js";

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

@@ -0,0 +1,8 @@
+import type { Answer } from '../core/answer.ts';
+/**
+ * One view of a place, folded by bound at the resolution asked; or, of a source, what it offers as typed lines — at the
+ * first resolution where it is reached and each offer's class, by default its forms and how access is proven too, with
+ * its flows in the order of trust, never what only a transport reads — and, at the call resolution, one read of an offer of the class head reads. Each answer
+ * is measured against answer/seconds and reads red past it, with the question it answered as its coordinate.
+ */
+export declare const answer: Answer;

package/dist/src/tools/look.js

@@ -0,0 +1,41 @@
+import { canonical } from '@lapxo/topos/wire';
+import { inPlace, printedOr } from "../core/answer.js";
+import { valueOf } from "../core/lock.js";
+import { vocabOf } from "../core/read.js";
+import { redIn, sayIn } from "../core/surface.js";
+import { readSource } from "../flows/read.js";
+import { standingFor } from "../flows/world.js";
+import { trustOf } from "../core/trust.js";
+/**
+ * One view of a place, folded by bound at the resolution asked; or, of a source, what it offers as typed lines — at the
+ * first resolution where it is reached and each offer's class, by default its forms and how access is proven too, with
+ * its flows in the order of trust, never what only a transport reads — and, at the call resolution, one read of an offer of the class head reads. Each answer
+ * is measured against answer/seconds and reads red past it, with the question it answered as its coordinate.
+ */
+export const answer = (asked, context) => ((started) => inPlace(asked, context, async (place) => {
+    const word = (scope) => valueOf(context.lock, scope);
+    const source = asked['source'];
+    if (source) {
+        if (asked['operation'] && (asked['at'] === word('look/call') || asked['history'] === 'true'))
+            return readSource(asked, context);
+        const held = await standingFor(context, place);
+        if ('unsettled' in held)
+            return [sayIn(context.lock)('unsettled', { source, why: held.unsettled })];
+        const [v, first, shallow] = [vocabOf(context.lock), (asked['at'] ?? word('look/default')) === '0', word('look/first').split('|')];
+        const offer = `${v.offers}/${source}/${asked['operation'] ?? ''}`;
+        const shown = held.lines.filter((l) => {
+            const scope = l.scope ?? '';
+            if (scope === `${v.region}/${source}`)
+                return true;
+            if (scope.startsWith(`${v.keys}/${source}/`))
+                return !first;
+            const ofOffer = asked['operation'] ? scope === offer || scope.startsWith(`${offer}/`) : scope.startsWith(offer);
+            if (!ofOffer || 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))] : [sayIn(context.lock)('unread', { source })];
+    }
+    const view = `${asked['view'] || word('bound/standing')}${asked['at'] ? `${word('bound/at')}${asked['at']}` : ''}`;
+    return printedOr(context, await context.bound(place, [word('bound/read'), word('bound/view'), view]));
+}).then((lines) => [...lines, ...redIn(context.lock)('answer/seconds', `answer/${asked['source'] ? `${asked['source']}/${asked['operation'] ?? ''}` : asked['view'] || valueOf(context.lock, 'bound/standing')}@${asked['at'] ?? valueOf(context.lock, 'look/default')}`, started, context.machine())]))(context.machine());

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

@@ -0,0 +1 @@
+export { bornPlace as answer } from '../places/found.ts';

package/dist/src/tools/place.js

@@ -0,0 +1 @@
+export { bornPlace as answer } from "../places/found.js";

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

@@ -0,0 +1,7 @@
+import type { Answer } from '../core/answer.ts';
+/**
+ * What this device has connected, read off each place's lines as bound folds them and the receipts its own keys signed:
+ * every place head's index names — or the one asked — the sources it pinned, the grants that stand today and the last
+ * read it kept a receipt of. Nothing is asked, called or signed.
+ */
+export declare const answer: Answer;

package/dist/src/tools/places.js

@@ -0,0 +1,32 @@
+import { LOCK } from '@lapxo/topos/wire';
+import { standingOr } from "../core/answer.js";
+import { under, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+/**
+ * What this device has connected, read off each place's lines as bound folds them and the receipts its own keys signed:
+ * every place head's index names — or the one asked — the sources it pinned, the grants that stand today and the last
+ * read it kept a receipt of. Nothing is asked, called or signed.
+ */
+export const answer = async (asked, context) => {
+    const [say, word, home, today] = [sayIn(context.lock), (k) => valueOf(context.lock, k), context.home(), new Date(context.now()).toISOString().slice(0, 10)];
+    const index = context.files.has(home, LOCK) ? await standingOr(context, home, context.policy) : { lines: [] };
+    if ('said' in index)
+        return index.said;
+    const places = index.lines.filter((l) => l.scope?.startsWith(`${word('home/family')}/`) && (!asked['place'] || l.value === asked['place']));
+    if (!places.length)
+        return [say('places-none', { place: asked['place'] ?? '' })];
+    const said = [];
+    for (const p of places) {
+        const held = await standingOr(context, p.value);
+        if ('said' in held) {
+            said.push(...held.said);
+            continue;
+        }
+        const at = word('receipt/at'), last = held.lines.filter((l) => l.scope?.startsWith(`${word('receipt/family')}/`) && l.at?.startsWith(`${at}:`)).sort((a, b) => (a.at < b.at ? 1 : -1))[0];
+        said.push(say('place-held', { name: p.scope.split('/')[1], dir: p.value,
+            sources: held.lines.filter((l) => l.scope?.startsWith('uses/') && under(context.lock, 'place/compiled', l.needs)).map((l) => l.scope.slice('uses/'.length)).join(', ') || '—',
+            grants: held.lines.filter((l) => l.scope?.startsWith('allow/') && !(l.measure === 'until' && (l.value ?? '') < today)).map((l) => `${l.scope} ${l.measure} ${l.value}`).join('; ') || '—',
+            last: last ? `${last.scope.split('/').slice(1, 3).join('/')} at ${last.at.slice(at.length + 1)}` : '—' }));
+    }
+    return said;
+};

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

@@ -0,0 +1 @@
+export { planLot as answer } from '../flows/plan.ts';

package/dist/src/tools/plan.js

@@ -0,0 +1 @@
+export { planLot as answer } from "../flows/plan.js";

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

@@ -0,0 +1 @@
+export { shared as answer } from '../core/package.ts';

package/dist/src/tools/share.js

@@ -0,0 +1 @@
+export { shared as answer } from "../core/package.js";

package/dist/src/walk/context.d.ts

@@ -0,0 +1,7 @@
+import type { Context, Outcome } from '../core/answer.ts';
+/**
+ * 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
+ * root, so a peer selects it by digest. Its history is offered only as its walk view declares, and only when its own key walks it.
+ */
+export declare const walkable: (context: Context, dir: string, account: string) => Promise<Outcome>;

package/dist/src/walk/context.js

@@ -0,0 +1,23 @@
+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";
+/**
+ * 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
+ * root, so a peer selects it by digest. Its history is offered only as its walk view declares, and only when its own key walks it.
+ */
+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);
+    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,38 @@
 {
   "name": "@lapxo/head",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.3",
+  "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",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lapxo/head.git"
+  },
+  "author": "Lapxo",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "bin": {
+    "head": "./dist/src/index.js"
+  },
+  "files": [
+    "dist/src",
+    "TARGET.bound",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p . --incremental false --tsBuildInfoFile null",
+    "prepack": "npm run build && node --test test/pack.test.ts",
+    "test": "node --test test/*.test.ts && node --test --test-concurrency=1 test/time/*.test.ts"
+  },
+  "dependencies": {
+    "@lapxo/bound": "0.2.1",
+    "@lapxo/topos": "0.2.0",
+    "@modelcontextprotocol/sdk": "1.32.1"
+  },
+  "devDependencies": {
+    "@anthropic-ai/mcpb": "2.1.2",
+    "@types/node": "22.20.5",
+    "typescript": "5.9.3"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.