@lapxo/head 0.1.0 → 0.1.3

package/dist/src/sources/access.js

@@ -10,25 +10,30 @@ 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.
+ * 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 [say, v, source] = [sayIn(context.lock), vocabOf(context.lock), asked['source'] ?? ''];
+    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 [say('unsettled', { source, why: held.unsettled })];
-    const operation = asked['operation'] || 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];
+        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 [say('unread', { source })];
+        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.said;
+        return picked;
     const plan = planRead(picked.lines, context.lock, source, operation, placeNameOf(place));
     if (plan.kind === 'said')
-        return [say(plan.key, plan.fields)];
+        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 stopped;
+        return { said: stopped };
     const got = await attachmentFor(context, place, picked.lines, plan);
-    return 'said' in got ? [say(got.said, { source, operation, kinds: plan.access.kind, input: got.input })] : [say(plan.access.account === undefined ? 'access-anonymous' : 'access-kept', { source })];
-});
+    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

@@ -5,6 +5,9 @@ import type { Asked, Context } from '../core/answer.ts';
  * 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.
+ * 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) => Promise<readonly string[]>;
+export declare const connected: (asked: Asked, context: Context, covered?: boolean) => Promise<readonly string[]>;

package/dist/src/sources/connect.js

@@ -1,52 +1,111 @@
-import { extname, isAbsolute, resolve, sep } from 'node:path';
-import { canonical, EXTENSION } from '@lapxo/topos/wire';
-import { inPlace, unless } from "../core/answer.js";
+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 { vocabOf } from "../core/read.js";
-import { redIn, sayIn } from "../core/surface.js";
-import { digestIn } from "../core/worlds.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";
-/** 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);
-};
+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.
+ * 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 = (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'] ?? '' }));
+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;
-    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);
+    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);
-    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 })];
@@ -60,9 +119,12 @@ export const connected = (asked, context) => ((started) => inPlace(asked, contex
                 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))];
-}).then((lines) => [...lines, ...redIn(context.lock)('connect/seconds', `connect/${asked['source'] ?? ''}`, started, context.machine())]))(context.machine());
+        ...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/card.js

@@ -3,7 +3,7 @@ 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);
+    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')));

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

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

@@ -5,10 +5,11 @@ 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, never
- * what only a transport reads — and, at the call resolution, one read of an offer of the class head reads. Each answer
+ * 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) => {
@@ -33,7 +34,7 @@ export const answer = (asked, context) => ((started) => inPlace(asked, context,
                 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 })];
+        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]));

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lapxo/head",
-  "version": "0.1.0",
+  "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",
@@ -22,15 +22,16 @@
   ],
   "scripts": {
     "build": "tsc -p . --incremental false --tsBuildInfoFile null",
-    "prepack": "npm run build",
-    "test": "node --test test/*.test.ts"
+    "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.1.6",
-    "@lapxo/topos": "0.1.12",
+    "@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"
   }