@lapxo/head 0.1.7 → 0.2.1

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

@@ -0,0 +1,51 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Client as RemoteClient } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { aboutOf, valueOf } from "../../core/lock.js";
+import { fill } from "../../core/surface.js";
+import { shapeOf, shapeSchema } from "../surface.js";
+import { folderOf } from "../place.js";
+import { askedOf, headOf } from "../../doors/head.js";
+/** Incoming and outgoing SDK bindings; application decisions stay behind the existing ports. */
+export async function serve(lock, root, ext, doorName) {
+    const offered = (n) => (n ? { listChanged: false } : undefined);
+    const head = headOf(lock, root, ext, {
+        can: () => ((e) => ({ url: Boolean(e?.url), form: e !== undefined && (e.form !== undefined || Object.keys(e).length === 0) }))(server.getClientCapabilities()?.elicitation), elicit: (params) => server.elicitInput(params, { timeout: Number(valueOf(lock, 'access/wait').split('..')[1]) }),
+        roots: async () => (server.getClientCapabilities()?.roots ? (await server.listRoots()).roots.flatMap((root) => folderOf(root.uri) ?? []) : []), client: () => ((c) => (c ? `${c.name}@${c.version}` : undefined))(server.getClientVersion()), name: doorName,
+    }), surface = head.surface;
+    const server = new Server({ name: surface.name, version: surface.version }, { capabilities: { tools: offered(surface.tools.length), resources: offered(surface.resources.length), prompts: offered(surface.prompts.length) }, instructions: aboutOf(lock, 'prose/en/instructions') });
+    const schemaOf = (fields) => ({ type: 'object',
+        properties: Object.fromEntries(fields.map((f) => [f.name, { type: f.type, description: f.about }])), required: fields.filter((f) => f.required).map((f) => f.name) });
+    if (surface.tools.length)
+        server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: surface.tools.map((tool) => ({ name: tool.name, description: tool.about,
+                inputSchema: schemaOf([...tool.fields]), outputSchema: shapeSchema(lock), annotations: Object.fromEntries(tool.hints.map((hint) => [`${hint}Hint`, true])) })) }));
+    if (surface.tools.length)
+        server.setRequestHandler(CallToolRequestSchema, async (request, extra) => ((answer) => (answer === undefined ? { isError: true, content: [] } : { content: [{ type: 'text', text: answer.join('\n') }], structuredContent: shapeOf(answer) }))(await head.call(request.params.name, request.params.arguments, extra.signal)));
+    if (surface.resources.length)
+        server.setRequestHandler(ListResourcesRequestSchema, () => ({ resources: [] }));
+    if (surface.resources.length)
+        server.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({ resourceTemplates: surface.resources.map((r) => ({ name: r.name, uriTemplate: r.template, description: r.about, mimeType: r.mime })) }));
+    if (surface.resources.length)
+        server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => ((got) => ({ contents: got === undefined ? [] : [{ uri: request.params.uri, mimeType: got.mime, text: got.lines.join('\n') }] }))(await head.resource(request.params.uri, extra.signal)));
+    if (surface.prompts.length)
+        server.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: surface.prompts.map((p) => ({ name: p.name, description: p.about, arguments: p.fields.map((f) => ({ name: f.name, description: f.about, required: f.required })) })) }));
+    if (surface.prompts.length)
+        server.setRequestHandler(GetPromptRequestSchema, (request) => ((p) => ({ messages: p === undefined ? [] : [{ role: 'user', content: { type: 'text', text: [p.text, p.line].filter(Boolean).map((t) => fill(t, askedOf(request.params.arguments))).join('\n') } }] }))(surface.prompts.find((one) => one.name === request.params.name)));
+    await server.connect(new StdioServerTransport());
+}
+/** Concrete outgoing SDK transport. Every network operation still goes through the separately permitted host capability. */
+export const remoteFactory = async (endpoint, send, options) => {
+    const client = new RemoteClient({ name: 'head', version: '0' });
+    const transport = new StreamableHTTPClientTransport(new URL(endpoint), { fetch: (input, init) => send(String(input), init ?? {}), reconnectionOptions: { maxRetries: 0, maxReconnectionDelay: 0, initialReconnectionDelay: 0, reconnectionDelayGrowFactor: 1 } });
+    try {
+        await client.connect(transport, options);
+    }
+    catch (error) {
+        await client.close();
+        throw error;
+    }
+    return { list: async (after, opts) => { const got = await client.listTools(after ? { cursor: after } : {}, opts); return { tools: got.tools, ...(got.nextCursor ? { next: got.nextCursor } : {}) }; },
+        callTool: (params, opts) => client.callTool(params, undefined, opts), close: () => client.close() };
+};

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

@@ -0,0 +1,13 @@
+import { type ConfiguredSource, type Limits, type PermittedFetch } from './mcp.ts';
+import type { Prepared } from './request.ts';
+export interface RemotePort {
+    readonly discover: (endpoint: string) => Promise<{
+        readonly tools: readonly import('./mcp.ts').Tool[];
+        readonly digest: string;
+    }>;
+    readonly prepare: (source: ConfiguredSource, tool: string, args: Record<string, unknown>, authorize: () => Promise<boolean>) => Prepared;
+}
+/** This port owns no permission. Callers bind the receiver's consent and existing access flow; SDK hints grant nothing. */
+export declare function remoteAt(limits: Limits & {
+    readonly wireBytes: number;
+}, signal?: AbortSignal, network?: (endpoint: string) => PermittedFetch): RemotePort;

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

@@ -0,0 +1,33 @@
+import { createHash } from 'node:crypto';
+import { transportFor, withCatalogue, withConfiguredSource, remoteFactory } from "./mcp.js";
+import { networkFor } from "./network.js";
+/** This port owns no permission. Callers bind the receiver's consent and existing access flow; SDK hints grant nothing. */
+export function remoteAt(limits, signal, network = networkFor) {
+    return {
+        discover: endpoint => withCatalogue(options => remoteFactory(endpoint, transportFor(endpoint, network(endpoint), limits.wireBytes, options), options), limits, signal, session => session.read()),
+        prepare: (source, tool, args, authorize) => {
+            if (!source.offers.includes(tool))
+                return { refused: 'mcp-tool' };
+            const sentArgs = JSON.parse(JSON.stringify(args));
+            const key = createHash('sha256').update(JSON.stringify([source.endpoint, source.catalogue, tool, sentArgs])).digest('hex');
+            return { key, describe: `${source.endpoint} · ${tool} · sha256:${key}`, send: async (attachment, most) => {
+                    if (!Number.isSafeInteger(most) || most < 1 || Object.keys(attachment?.query ?? {}).length)
+                        return { kind: 'failed', why: 'mcp/access-location' };
+                    try {
+                        const permitted = network(source.endpoint);
+                        const result = await withConfiguredSource(source, remoteFactory, (url, init) => {
+                            const headers = new Headers(init.headers);
+                            for (const [key, value] of Object.entries(attachment?.headers ?? {}))
+                                headers.set(key, value);
+                            return permitted(url, { ...init, headers });
+                        }, limits, signal, call => call(tool, sentArgs, authorize));
+                        const bytes = Buffer.from(JSON.stringify(result));
+                        return bytes.length > most ? { kind: 'over' } : { kind: 'got', status: 200, bytes, type: 'application/json' };
+                    }
+                    catch (error) {
+                        return { kind: 'failed', why: error instanceof Error && /^mcp\/[a-z-]+$/.test(error.message) ? error.message : 'mcp/transport' };
+                    }
+                } };
+        },
+    };
+}

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

@@ -14,7 +14,6 @@ export type Folded = {
 } | {
     readonly refused: string;
 };
-/** 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>;
 /** A sign or a land: in a host of its own for this one call, signed by head's signer through the port of the key it names, the lot handed in as the host's input. */

package/dist/src/ports/bound.js

@@ -4,10 +4,9 @@ import { dirname, join } from 'node:path';
 import { canonical, LOCK, parse } from '@lapxo/topos/wire';
 import { factsOf } from "../core/lock.js";
 import { spawned } from "./process.js";
-import { hosted, hosting, signedIn } from "./host.js";
+import { capturedViews, hosted, hosting, signedIn } from "./host.js";
 import { cleared, scratchOf } from "./scratch.js";
 import { folded } from "../ahead/fold.js";
-import { readingOf } from "./reading.js";
 const binOf = (name) => {
     try {
         const manifest = createRequire(import.meta.url).resolve(join(name, 'package.json'));
@@ -40,21 +39,21 @@ const isRecord = (line) => line.startsWith('{') && recordOf(line) !== undefined;
 const apart = (printed) => ((record) => (record === undefined ? printed : { ...printed, refusal: recordOf(record) }))([...printed.err].reverse().find(isRecord));
 const why = (printed) => printed?.err.filter((line) => !isRecord(line)).at(-1);
 const readOf = (printed) => (printed === undefined || printed.code !== 0 ? { refused: why(printed) ?? '' } : { lines: factsOf(printed.out) });
-/** Native identities and expected-identity results come from the same public CLI contract. Without it, read fresh. */
-const nativeView = (name, place, view, signal) => {
-    const read = async (expected) => {
-        if (expected === undefined)
-            return readOf(await run(name, place, [words.read, words.view, view], {}, signal));
-        const result = readingOf(await run(name, place, [words.read, words.view, `${words.identity}@${view}@${expected}`], {}, signal), view, expected);
-        return 'refused' in result ? result : { lines: factsOf(result.text.split('\n')) };
-    };
-    return !words.identity ? read() : folded(`${name}/${view}`, place, async () => { const result = readingOf(await run(name, place, [words.read, words.view, `${words.identity}@${view}`], {}, signal), view); return 'refused' in result ? undefined : result.identity; }, read);
+/** Only the requested views are captured by Bound; every result binds its text to the actual current native identity. */
+const nativeViews = async (name, place, views, signal) => {
+    const captured = capturedViews(place, views, signal);
+    if (captured?.kind === 'refuse' && captured.code === 'host/instrument-pin')
+        return views.map(() => ({ refused: captured.diagnostic }));
+    return Promise.all(views.map(async (view) => {
+        const result = captured?.kind === 'fact' ? captured.views.find((one) => one.view === view) : undefined;
+        const read = result ? await folded(`${name}/${view}`, place, async () => result.identity, async () => ({ lines: factsOf(result.text.split('\n')) })) : readOf(await run(name, place, [words.read, words.view, view], {}, signal));
+        return 'refused' in read || view !== words.standing || read.lines.some((line) => line.scope === words.profile) ? read
+            : { 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` };
+    }));
 };
-/** 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 policyAt = async (name, place, signal) => (await nativeViews(name, place, [words.standing], signal))[0];
 export const standingAt = async (name, place, devicesOf, isHistory, signal) => {
-    const [folded, evidence] = await Promise.all([policyAt(name, place, signal), nativeView(name, place, words.evidence, signal)]);
+    const [folded, evidence] = await nativeViews(name, place, [words.standing, words.evidence], signal);
     if ('refused' in folded)
         return folded;
     if ('refused' in evidence)

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

@@ -10,6 +10,11 @@ export declare const hosting: {
     bytes: number;
     heap: number;
     queued: number;
+    authority: {
+        clock: string;
+        unit: string;
+        items: number;
+    };
     http: NativeHostOptions["http"];
 };
 /** Receiver permissions and work budgets are declared by head's own lock, never inferred from a redirect. */
@@ -21,6 +26,8 @@ export declare const configureHost: (lock: readonly Said[], bounds: {
 export declare const cooled: () => void;
 /** The process a place's fold host runs as, while one is held for it. */
 export declare const hostOf: (place: string) => number | undefined;
+/** Native read-only snapshots use Bound's actual caller environment; their identities are not borrowed from a different CLI context. */
+export declare const capturedViews: (place: string, views: readonly string[], signal?: AbortSignal, from?: string) => import("@lapxo/bound/host").NativeViewIdentitiesResult | undefined;
 /**
  * A read of a place's view through the place's own fold host, which only folds and never holds a signer: started on the first
  * read, kept while it is asked within its idle and its life, the installed bound checked file by file before every call.
@@ -33,3 +40,14 @@ export declare const hosted: (place: string, args: readonly string[], signal?: A
  * host at a time; the lot goes in as the host's input, never a file of head's.
  */
 export declare const signedIn: (place: string, args: readonly string[], lot: readonly string[] | undefined, signers: NonNullable<NativeHostOptions["signers"]>, keyId?: string, signal?: AbortSignal, from?: string) => Promise<Printed>;
+export type AuthorityObservation = {
+    readonly refused: string;
+    readonly code: string;
+} | {
+    readonly authority: string;
+    readonly request: string;
+    readonly decision: 'allow' | 'ask' | 'deny' | 'open';
+    readonly needs: readonly string[];
+};
+/** Configuration-only observations at an explicit receiver clock; no signing, admission or API execution occurs here. */
+export declare const authorityAt: (place: string, key: string, kind: string, records: readonly string[], now: number, signal?: AbortSignal, presented?: string) => Promise<AuthorityObservation>;

package/dist/src/ports/host.js

@@ -1,20 +1,21 @@
 import { createHash } from 'node:crypto';
-import { mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { tmpdir } from 'node:os';
 import { dirname, join, relative, sep } from 'node:path';
-import { installedHostInstrument, nativeHostEnvironment, startNativeHost } from '@lapxo/bound/host';
+import { installedHostInstrument, nativeHostEnvironment, prepareNativeViewIdentities, prepareNativeAuthorityCard, answerNativeAuthorityCard, nativeAuthorityRequestIdentity, startNativeHost } from '@lapxo/bound/host';
+import { decodeAuthorityCard } from '@lapxo/topos/contract';
 import { members, valueOf } from "../core/lock.js";
 /** What a place's fold host is held to, from head's lock: the installed instrument it must be, how long it stays idle and lives, and its limits. */
-export const hosting = { installed: '', idle: 0, life: 0, wait: 0, bytes: 0, heap: 0, queued: 0, http: undefined };
+export const hosting = { installed: '', idle: 0, life: 0, wait: 0, bytes: 0, heap: 0, queued: 0, authority: { clock: '', unit: '', items: 0 }, http: undefined };
 /** Receiver permissions and work budgets are declared by head's own lock, never inferred from a redirect. */
-export const configureHost = (lock, bounds) => { Object.assign(hosting, { installed: valueOf(lock, 'dep/bound/installed'), wait: bounds.wait, bytes: bounds.most, ...Object.fromEntries(['idle', 'life', 'heap', 'queued'].map((k) => [k, Number(valueOf(lock, `bound/host/${k}`).split('..')[1])])), http: { origins: members(valueOf(lock, 'bound/receiver/origins')), redirects: { maxRedirects: Number(valueOf(lock, 'bound/receiver/redirects').split('..')[1]), headerBytes: Number(valueOf(lock, 'bound/receiver/header-bytes').split('..')[1]) } } }); };
+export const configureHost = (lock, bounds) => { Object.assign(hosting, { installed: valueOf(lock, 'dep/bound/installed'), wait: bounds.wait, bytes: bounds.most, ...Object.fromEntries(['idle', 'life', 'heap', 'queued'].map((k) => [k, Number(valueOf(lock, `bound/host/${k}`).split('..')[1])])), authority: { clock: valueOf(lock, 'bound/authority/clock'), unit: valueOf(lock, 'bound/authority/unit'), items: Number(valueOf(lock, 'bound/authority/items').split('..')[1]) }, http: { origins: members(valueOf(lock, 'bound/receiver/origins')), redirects: { maxRedirects: Number(valueOf(lock, 'bound/receiver/redirects').split('..')[1]), headerBytes: Number(valueOf(lock, 'bound/receiver/header-bytes').split('..')[1]) } } }); };
 const root = dirname(createRequire(import.meta.url).resolve('@lapxo/bound/package.json'));
-const walk = (at) => (statSync(at).isDirectory() ? readdirSync(at).flatMap((e) => walk(join(at, e))) : [at]);
+const walk = (at) => readdirSync(at, { withFileTypes: true }).flatMap((e) => e.isDirectory() ? walk(join(at, e.name)) : [join(at, e.name)]);
 /** Every file of the installed bound by its coordinate and digest: what its identity is computed from, and what is checked again before each call. */
 const inventory = (at) => walk(at).map((f) => ({ coordinate: relative(at, f).split(sep).join('/'), digest: `sha256:${createHash('sha256').update(readFileSync(f)).digest('hex')}` })).sort((a, b) => (a.coordinate < b.coordinate ? -1 : 1));
-/** The hosts held, those starting, those closing — a place gets its next host once its last one is gone — and the folders head made for their scratch, each removed once its host is. */
-const [live, starting, closing, scratches] = [new Map(), new Map(), new Map(), new Set()];
+/** Held, starting and closing hosts, their owned scratch, and one instrument descriptor reused only after its complete current byte inventory matches. */
+const [live, starting, closing, scratches, selected] = [new Map(), new Map(), new Map(), new Set(), { root: '', members: '', instrument: undefined }];
 const cleared = (dir) => { rmSync(dir, { recursive: true, force: true }); scratches.delete(dir); };
 const shut = (at) => { const one = live.get(at); live.delete(at); if (one) {
     clearTimeout(one.idle);
@@ -27,13 +28,34 @@ export const cooled = () => { for (const at of [...live.keys()])
 export const hostOf = (place) => live.get(realpathSync(place))?.host.pid;
 process.once('exit', () => { cooled(); for (const dir of [...scratches])
     cleared(dir); });
+/** One verified installed descriptor, reused only after hashing every current installed member. */
+const instrumentAt = (from) => {
+    const members = inventory(from), current = JSON.stringify(members);
+    const instrument = selected.root === from && selected.members === current ? selected.instrument : Object.assign(selected, { root: from, members: current, instrument: installedHostInstrument({ directory: from, shape: 'package', members, exports: [['exports', './engine', 'default']], pins: [], limits: { members: 4096, bytes: 1 << 27, responseBytes: 1 << 22 } }, join(from, 'dist/cli/verb.js')) }).instrument;
+    return { members: current, instrument };
+};
+const pinnedInstrument = (from) => { const { instrument } = instrumentAt(from); if (instrument.installed?.digest !== hosting.installed)
+    throw Error('REFUSE·host/instrument-pin'); return instrument; };
+/** Native read-only snapshots use Bound's actual caller environment; their identities are not borrowed from a different CLI context. */
+export const capturedViews = (place, views, signal, from = root) => {
+    try {
+        if (signal?.aborted)
+            return undefined;
+        const instrument = pinnedInstrument(from);
+        return prepareNativeViewIdentities({ place, views, instrument });
+    }
+    catch (error) {
+        cooled();
+        return { kind: 'refuse', code: 'host/instrument-pin', diagnostic: error.message };
+    }
+};
 /** A host started on a place, on the installed instrument the lock pins and in a scratch folder of head's own; with signers only for one call's sign or land. */
 const opened = async (at, from, signers) => {
-    const members = inventory(from), instrument = installedHostInstrument({ directory: from, shape: 'package', members, exports: [['exports', './engine', 'default']], pins: [], limits: { members: 4096, bytes: 1 << 27, responseBytes: 1 << 22 } }, join(from, 'dist/cli/verb.js'));
+    const { members, instrument } = instrumentAt(from);
     const scratch = mkdtempSync(join(tmpdir(), 'head-host-'));
     scratches.add(scratch);
     const host = await startNativeHost({ place: at, instrument, expectedInstrument: hosting.installed, environment: nativeHostEnvironment({ ...process.env }), scratchParent: scratch, ...(hosting.http ? { http: hosting.http } : {}), ...(signers ? { signers } : {}), limits: { requestBytes: hosting.bytes, responseBytes: hosting.bytes, timeoutMs: hosting.wait, heapMiB: hosting.heap, queuedRequests: hosting.queued } }).catch((e) => { cleared(scratch); throw e; });
-    return { host, members: JSON.stringify(members), born: Date.now(), scratch, busy: 0 };
+    return { host, members, born: Date.now(), scratch, busy: 0 };
 };
 const started = async (at, from) => ((one) => (live.set(at, one), one))(await opened(at, from));
 const lines = (text) => text.split('\n').filter(Boolean), refused = (why) => ({ code: -1, out: [], err: [why] });
@@ -106,3 +128,30 @@ export const signedIn = async (place, args, lot, signers, keyId, signal, from =
         cleared(one.scratch);
     }
 };
+/** Configuration-only observations at an explicit receiver clock; no signing, admission or API execution occurs here. */
+export const authorityAt = async (place, key, kind, records, now, signal, presented) => {
+    const current = () => { if (signal?.aborted)
+        throw Error('REFUSE·authority-preflight/cancelled'); };
+    try {
+        current();
+        const instrument = pinnedInstrument(root);
+        const action = { kind, records }, clock = { name: hosting.authority.clock, unit: hosting.authority.unit, now };
+        const context = { root: realpathSync(place), place: '.', key, instrument, clock, horizon: { clock: clock.name, unit: clock.unit, from: now, through: now }, limits: { bytes: hosting.bytes, items: hosting.authority.items }, actions: ['record-coverage', 'admission'].includes(kind) ? [action] : [] };
+        if (!clock.name || !clock.unit || !Number.isSafeInteger(now) || hosting.authority.items < 1)
+            throw Error('REFUSE·authority-preflight/context');
+        const prepared = await prepareNativeAuthorityCard(context);
+        if (prepared.kind !== 'fact')
+            return { refused: prepared.diagnostic, code: prepared.code };
+        const request = nativeAuthorityRequestIdentity(action), card = presented ? decodeAuthorityCard(presented, context.limits) : prepared.value.card;
+        const answer = await answerNativeAuthorityCard(card, request, context);
+        current();
+        if ('kind' in answer)
+            return { refused: answer.diagnostic, code: answer.code };
+        if (answer.status === 'refused')
+            return { refused: `REFUSE·${answer.code}`, code: answer.code };
+        return { authority: prepared.value.line, request, decision: answer.status === 'observed' ? answer.decision : 'open', needs: answer.status === 'open' ? answer.needs : prepared.value.needs };
+    }
+    catch (error) {
+        return { refused: error instanceof Error ? error.message : String(error), code: 'authority-preflight/context' };
+    }
+};

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

@@ -17,5 +17,6 @@ type Connection = {
     readonly connected: boolean;
 };
 type Laid = (source: string, document: string, doc: Read, overlay: Read | undefined, started: number) => Promise<Connection>;
+export declare const received: (context: Context, place: string, document: string, bytes: Uint8Array, named: string, laid: Laid, account: string, publicFiles?: ReadonlyMap<string, Uint8Array | undefined>) => Promise<readonly string[]>;
 export declare const laidIn: (context: Context, place: string, account: string) => Laid;
 export {};

package/dist/src/sources/connect.js

@@ -1,6 +1,8 @@
+import { discoverConfigured, configuredRefusal, configuredProtocol } from "../ports/adapters/configured.js";
+import { receiverConnect } from "../core/receiver.js";
 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 +11,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,8 +26,8 @@ import { attachedFor } from "./access.js";
  * its pins rest in, its pin held to the package's; one that differs is refused by name, and the place holds what it
  * compiled. Nothing the sharing place was granted comes with it: access is asked here, issuer by issuer.
  */
-export const connected = async (asked, context, covered = false) => ((asked['document'] ?? '').startsWith(valueOf(context.lock, 'link/prefix')) ? linked(asked, context)
-    : ((got) => ('said' in got ? got.said : connectedAs(got.asked, context, covered)))(await resolved(asked, context)));
+export const connected = async (asked, context, covered = false) => (await receiverConnect(asked, context)) ?? (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)))(asked['protocol'] === configuredProtocol.id ? { asked } : await resolved(asked, context)));
 const connectedAs = async (asked, context, covered = false) => (asked['source'] && !(await placeOf(asked, context)) ? firstRun(asked, context, (dir, covered) => connected({ ...asked, place: dir }, context, covered))
     : ((started) => inPlace(asked, context, async (place) => {
         const say = sayIn(context.lock), digest = digestIn(context.lock), { documentOf, fetchedAs, kindOf } = context.files.read;
@@ -34,7 +37,7 @@ const connectedAs = async (asked, context, covered = false) => (asked['source']
             return [say('parent-lock', { place, parent: source || document })];
         if (!source && !lock)
             return [say('missing-param', { operation: 'connect', param: 'source' })];
-        const root = rootIn(context, place);
+        const root = await rootIn(context, place);
         if ('said' in root)
             return root.said;
         if (named && !/^sha256:[0-9a-f]{64}$/.test(named))
@@ -48,7 +51,7 @@ const connectedAs = async (asked, context, covered = false) => (asked['source']
         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];
+        const [read, overlay] = [asked['protocol'] === configuredProtocol.id ? await discoverConfigured(context, asked, source) : 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))
@@ -56,13 +59,14 @@ const connectedAs = async (asked, context, covered = false) => (asked['source']
         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 })] : (await laidIn(context, place, root.account)(source, document, read, overlay, started)).said;
-    }))(context.machine()));
-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)))];
+    }))(context.machine())).catch(error => { if (asked['protocol'] === configuredProtocol.id || error instanceof Error && error.message.startsWith(configuredProtocol.failurePrefix))
+    return configuredRefusal(context, error); throw error; });
+export const received = async (context, place, document, bytes, named, laid, account, publicFiles) => {
+    const [say, got] = [sayIn(context.lock), unpacked(context, document, bytes, publicFiles ?? 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(', ') || '—' }));
+    const refused = publicFiles || 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)
@@ -76,8 +80,8 @@ export const laidIn = (context, place, account) => (source, document, doc, overl
     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);
+    const configured = configuredProtocol.connection(doc.bytes, source, overlay !== undefined, v);
+    const [pin, worlds] = [pinIn(context, place, lands, line, configured?.verify), await adopted(context, place, lands, line, configured?.worlds ?? [])];
     if ('refused' in worlds)
         return { said: [say('not-landed', { why: worlds.refused })], connected: false };
     const laid = [[`${word('place/connected')}/${source}.${doc.kind}`, doc.bytes], ...(overlay ? [[`${word('place/connected')}/${source}.overlay.${overlay.kind}`, overlay.bytes]] : [])];

package/dist/src/tools/card.js

@@ -1,8 +1,9 @@
-import { inStanding, printedOr } 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) => inStanding(asked, context, async (place, lines) => {
+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 view = lines.find((f) => f.scope?.startsWith('view/') && !f.shape && members(f.value ?? '').includes(word('cells')));
     if (view === undefined)

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

@@ -1,3 +1,4 @@
+import { receiverQuestion } from "../core/receiver.js";
 import { join } from 'node:path';
 import { LOCK } from '@lapxo/topos/wire';
 import { answerOf, placeOf } from "../core/answer.js";
@@ -10,6 +11,11 @@ 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) => {
+    const packaged = await receiverQuestion(asked, context);
+    if (packaged && 'said' in packaged)
+        return packaged.said;
+    if (packaged)
+        asked = { ...asked, place: packaged.place };
     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)];
@@ -22,7 +28,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') : founded && asked['view'] === valueOf(context.lock, 'claim/view') ? await viewed(asked, context) : 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/verbs/do.js

@@ -2,6 +2,7 @@ import { answerOf, placeOf } from "../core/answer.js";
 import { members, valueOf } from "../core/lock.js";
 import { sayIn } from "../core/surface.js";
 import { cardAt } from "./card.js";
+import { LOCK } from '@lapxo/topos/wire';
 /**
  * What a person does, carried out by the action it names and only on the card it was asked on: an act on a place that
  * moved since is refused before anything is done. An action the place does not allow is said not to be in the card, by
@@ -16,7 +17,7 @@ export const done = async (asked, context) => {
     const place = asked['place'] || asked['dir'] || await placeOf(asked, context), held = await cardAt(context, place);
     if ('said' in held)
         return held.said;
-    if (held.card !== asked['card'])
+    if (held.card !== asked['card'] && !(action === 'place' && place !== undefined && !context.files.has(place, LOCK) && !context.files.has(place, '.bound')))
         return [say('card-stale', { action, place: place ?? '', card: asked['card'] ?? '' })];
     const answer = await (await answerOf('tools', action))(asked, context);
     const [bound, own] = [members(word('do/not-in-card/bound')), members(word('do/not-in-card/head'))];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lapxo/head",
-  "version": "0.1.7",
+  "version": "0.2.1",
   "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",
@@ -18,7 +18,8 @@
   "files": [
     "dist/src",
     "TARGET.bound",
-    "LICENSE"
+    "LICENSE",
+    "runtime.bundle.json"
   ],
   "scripts": {
     "build": "tsc -p . --incremental false --tsBuildInfoFile null",
@@ -26,12 +27,12 @@
     "test": "node --test test/*.test.ts && node --test --test-concurrency=1 test/time/*.test.ts"
   },
   "dependencies": {
-    "@lapxo/bound": "0.2.7",
+    "@lapxo/bound": "0.2.8",
     "@lapxo/topos": "0.2.4",
-    "@modelcontextprotocol/sdk": "1.32.1"
+    "@modelcontextprotocol/sdk": "1.32.1",
+    "@anthropic-ai/mcpb": "2.1.2"
   },
   "devDependencies": {
-    "@anthropic-ai/mcpb": "2.1.2",
     "@types/node": "22.20.5",
     "typescript": "5.9.3"
   }