@lapxo/head 0.0.0-stage → 0.1.0

package/dist/src/sources/connect.js

@@ -0,0 +1,68 @@
+import { extname, isAbsolute, resolve, sep } from 'node:path';
+import { canonical, EXTENSION } from '@lapxo/topos/wire';
+import { inPlace, unless } from "../core/answer.js";
+import { valueOf } from "../core/lock.js";
+import { vocabOf } from "../core/read.js";
+import { redIn, sayIn } from "../core/surface.js";
+import { digestIn } from "../core/worlds.js";
+import { paidBy, pinIn } from "../compile/pin.js";
+import { adopted } from "../adopt/adopt.js";
+import { rootIn } from "../flows/device.js";
+/** The kind a document is named by, never read for: its file's extension, its address's, or the media type it was served as; bytes that say none are octet-stream. */
+const kindOf = (at, type = '') => (extname(URL.canParse(at) ? new URL(at).pathname : at).slice(1)
+    || (type.split(';')[0].split('/')[1] ?? '').split('+').at(-1).replace(/^x-/, '') || 'octet-stream').toLowerCase();
+/** A document the person names: an encrypted address, or a file inside the place or a folder the client shares; anything else is not read. */
+const documentOf = async (context, place, at) => {
+    if (URL.canParse(at))
+        return ((got) => got && { bytes: got.bytes, kind: kindOf(at, got.type) })(await (await context.adapter(at))?.get(at, Number(valueOf(context.lock, 'adapter/request/wait').split('..')[1])));
+    const inside = [place, ...(await context.roots())].some((root) => resolve(at).startsWith(`${resolve(root)}${sep}`));
+    return ((bytes) => bytes && { bytes, kind: kindOf(at) })(isAbsolute(at) && inside ? context.files.take(at) : undefined);
+};
+/**
+ * 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.
+ */
+export const connected = (asked, context) => ((started) => inPlace(asked, context, async (place) => {
+    const say = sayIn(context.lock), v = vocabOf(context.lock), word = (k) => valueOf(context.lock, k), digest = digestIn(context.lock);
+    const [source, document] = [(asked['source'] ?? '').toLowerCase().replace(/[^a-z0-9-]+/g, '-'), asked['document'] ?? ''];
+    if (!source)
+        return [say('missing-param', { operation: 'connect', param: 'source' })];
+    if (`.${kindOf(document)}` === EXTENSION)
+        return [say('parent-lock', { place, parent: source })];
+    const root = rootIn(context, place);
+    if ('said' in root)
+        return root.said;
+    const refused = await unless(context, say('elicit-connect', { source, document, place, overlay: asked['overlay'] ?? '' }));
+    if (refused)
+        return refused;
+    const [doc, overlay] = [await documentOf(context, place, document), asked['overlay'] ? await documentOf(context, place, asked['overlay']) : undefined];
+    if (doc === undefined || (asked['overlay'] && overlay === undefined))
+        return [say('document-unread', { document })];
+    const lands = (lot) => context.landRoot(place, lot, root.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);
+    if (`.${doc.kind}` === EXTENSION)
+        return [say('parent-lock', { place, parent: source })];
+    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 [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))];
+}).then((lines) => [...lines, ...redIn(context.lock)('connect/seconds', `connect/${asked['source'] ?? ''}`, started, context.machine())]))(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);
+    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, 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,40 @@
+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";
+/**
+ * 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, 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() : [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/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/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,37 @@
 {
   "name": "@lapxo/head",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.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",
+  "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",
+    "test": "node --test test/*.test.ts"
+  },
+  "dependencies": {
+    "@lapxo/bound": "0.1.6",
+    "@lapxo/topos": "0.1.12",
+    "@modelcontextprotocol/sdk": "1.32.1"
+  },
+  "devDependencies": {
+    "@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.