@lapxo/head 0.1.3 → 0.1.5

package/dist/src/links/inspect.js

@@ -0,0 +1,41 @@
+import { decodeReference } from '@lapxo/bound/reference';
+import { canonical } from '@lapxo/topos/wire';
+import { inPlace, standingOr } from "../core/answer.js";
+import { members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+import { linesOf } from "../core/worlds.js";
+import { rootIn } from "../flows/device.js";
+/**
+ * A #bound: link connected: inspected by the instrument in the person's place, never authenticated — its bytes are the
+ * link's, and nothing shows who shared it — and what it names is shown; nothing is connected or granted, since a package
+ * is received by the digest its sharer sent apart. A place that admits no content transport is handed the lines that admit
+ * one, to sign; bytes that do not arrive are owed by the link until they do; bytes that are not what it names are refused.
+ */
+export const linked = (asked, context) => inPlace(asked, context, async (place) => {
+    const [say, word, link] = [sayIn(context.lock), (k) => valueOf(context.lock, k), asked['document'] ?? ''], [held, admits] = [await standingOr(context, place, context.policy), members(valueOf(context.lock, 'link/transport'))];
+    if ('said' in held)
+        return held.said;
+    const lines = context.lock.filter((l) => admits.some((s) => l.scope === `birth/${s}`)).map(({ about: _about, scope, ...l }) => canonical({ ...l, scope: scope.slice('birth/'.length), at: 'policy:person/transport', by: 'target' }));
+    let reference;
+    try {
+        reference = decodeReference(link);
+    }
+    catch (refused) {
+        return [say('link-refused', { link, why: refused instanceof Error ? refused.message : String(refused) })];
+    }
+    if (![admits[0], `transport/${new URL(reference.source).protocol.slice(0, -1)}`].every((s) => held.lines.some((l) => l.scope === s)))
+        return [say('transport-missing', { place, lines: lines.join('\n') })];
+    const [printed, scope] = [await context.bound(place, [word('bound/read'), link]), `${word('place/needs')}/bytes/${reference.blob.slice(reference.algorithm.length + 1, reference.algorithm.length + 17)}`];
+    const [owed, root, why] = [held.lines.find((l) => l.scope === scope && l.role === 'demands' && l.value === link), rootIn(context, place), printed?.err.filter((l) => !l.startsWith('{')).at(-1) ?? ''];
+    if ('said' in root)
+        return root.said;
+    if (printed?.code !== 0 && !why.includes(word('link/unarrived')))
+        return [say('link-refused', { link, why })];
+    const settled = (lot) => (lot.length ? context.landRoot(place, lot, root.account).then((got) => ('refused' in got ? say('not-landed', { why: got.refused }) : got.lines)) : Promise.resolve([]));
+    const due = { at: 'policy:head/link', by: 'target', form: 'alphabet', measure: 'id', role: 'demands', scope, value: link };
+    if (printed?.code !== 0)
+        return [say('link-owed', { place, source: reference.source }), ...await settled(owed ? [] : [canonical(due)])];
+    const named = linesOf(new TextEncoder().encode(printed.out.filter((l) => l.startsWith('TOPOS ')).map((l) => l.slice('TOPOS '.length)).join('\n')));
+    const sources = named.filter((l) => /^sources\/[^/]+$/.test(l.scope ?? '')).map((l) => l.scope.split('/')[1]);
+    return [say('inspected', { source: reference.source, sources: sources.join(', ') || '—', digest: reference.digest }), say('sharer-unverified', {}), ...await settled(owed ? [canonical({ ...due, value: 'withdraw' })] : [])];
+});

package/dist/src/links/link.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '../core/answer.ts';
+/**
+ * A package's link: its lines as one standing document, laid in its folder as it is to be published — the link names that
+ * document's bytes, never the package's files — and the #bound: link to it at the address the person publishes it at.
+ * With no address there is no link, said so: a link needs where its bytes are published, and the digest still goes apart.
+ */
+export declare const linkOf: (context: Context, to: string, lines: readonly string[], urls: Readonly<Record<string, string>>) => readonly string[];

package/dist/src/links/link.js

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { encodeReference } from '@lapxo/bound/reference';
+import { semanticStandingBytes } from '@lapxo/topos/standing';
+import { members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+const sha = (bytes) => createHash('sha256').update(bytes).digest('hex');
+/**
+ * A package's link: its lines as one standing document, laid in its folder as it is to be published — the link names that
+ * document's bytes, never the package's files — and the #bound: link to it at the address the person publishes it at.
+ * With no address there is no link, said so: a link needs where its bytes are published, and the digest still goes apart.
+ */
+export const linkOf = (context, to, lines, urls) => {
+    const say = sayIn(context.lock), [name, profile, [kind, algorithm]] = [valueOf(context.lock, 'link/document'), valueOf(context.lock, 'link/profile'), members(valueOf(context.lock, 'link/reference'))];
+    const standing = semanticStandingBytes(lines), bytes = new TextEncoder().encode(JSON.stringify({ profile, standing })), at = urls[name], document = join(to, name);
+    context.files.lay(to, name, bytes);
+    if (at === undefined || !URL.canParse(at))
+        return [say('shared-unlinked', { document })];
+    try {
+        return [say('shared-link', { document, at, link: encodeReference({ class: kind, algorithm, digest: sha(standing), blob: `${algorithm}:${sha(bytes)}`, source: new URL(at).href }) })];
+    }
+    catch (refused) {
+        return [say('link-refused', { link: at, why: refused instanceof Error ? refused.message : String(refused) })];
+    }
+};

package/dist/src/marks/compare.d.ts

@@ -0,0 +1,9 @@
+import type { Asked, Context } from '../core/answer.ts';
+/**
+ * One question asked of several sources at once — the same operation, the same arguments — and their typed answers
+ * compared field by field. Where they agree, the field is marked by the sources that say it, each mark resting on the
+ * receipt of its read: ● for each its own, ○ for one that is the same source in another form or declared to share its
+ * lineage, with what the place declares of that lineage and nothing more. Where they differ, each is shown with its source
+ * and hour, and the loss between them is not measured. None is ever picked.
+ */
+export declare const compared: (asked: Asked, context: Context, place: string) => Promise<readonly string[]>;

package/dist/src/marks/compare.js

@@ -0,0 +1,48 @@
+import { join } from 'node:path';
+import { standingOr } from "../core/answer.js";
+import { members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+import { linesOf } from "../core/worlds.js";
+import { readSource } from "../flows/read.js";
+import { shapeOf } from "../ports/surface.js";
+/** What one source answered the question: its typed fields by name, the hour it said them, and the receipt the read rests on; or what it said instead. */
+const readOf = async (asked, context, place, source) => {
+    const [word, raw] = [(k) => valueOf(context.lock, k), await readSource({ ...asked, sources: undefined, source, place }, context)], got = shapeOf(raw);
+    const cell = got.cells.filter((c) => ['head/answered', 'head/reused', 'head/kept', 'head/reread'].includes(c.code)).at(-1), family = `${word('receipt/family')}/${source}/`;
+    const receipt = got.lines.map((l) => linesOf(new TextEncoder().encode(l))[0]).find((l) => l?.scope?.startsWith(family) && l.measure === 'digest')?.value ?? cell?.fields['receipt'];
+    const typed = cell?.code === 'head/kept' ? new TextDecoder().decode(context.cache.held(cell.fields['digest'] ?? '') ?? new Uint8Array()).split('\n') : got.lines;
+    const fields = new Map(linesOf(new TextEncoder().encode(typed.join('\n'))).flatMap((l) => ((m) => (m ? [[m[1], l.value ?? '']] : []))(new RegExp(`^${word('vocab/answer')}/[0-9a-f]{16}/(.+)$`).exec(l.scope ?? ''))));
+    return cell === undefined || receipt === undefined || !fields.size ? { said: raw.filter((l) => l.startsWith('said/')) } : { source, at: cell.fields['at'] ?? '', receipt, fields };
+};
+/**
+ * One question asked of several sources at once — the same operation, the same arguments — and their typed answers
+ * compared field by field. Where they agree, the field is marked by the sources that say it, each mark resting on the
+ * receipt of its read: ● for each its own, ○ for one that is the same source in another form or declared to share its
+ * lineage, with what the place declares of that lineage and nothing more. Where they differ, each is shown with its source
+ * and hour, and the loss between them is not measured. None is ever picked.
+ */
+export const compared = async (asked, context, place) => {
+    const [say, word, held] = [sayIn(context.lock), (k) => valueOf(context.lock, k), await standingOr(context, place)], [own, mark] = [members(word('marks/own-signers')), members(word('marks/mark'))];
+    if ('said' in held)
+        return held.said;
+    const got = [];
+    for (const source of members(asked['sources'] ?? ''))
+        got.push(await readOf(asked, context, place, source));
+    const reads = got.filter((g) => 'fields' in g), line = (scope, measure) => held.lines.find((l) => l.scope === scope && (!measure || l.measure === measure));
+    const pinned = (s) => linesOf(context.files.take(join(place, line(`uses/${s}`)?.needs ?? '')) ?? new Uint8Array()).filter((l) => l.scope === `${word('vocab/region')}/${s}`);
+    const origin = (s) => ((region) => ({ origins: members(region.find((l) => l.measure === word('vocab/origins'))?.value ?? ''), pin: region.find((l) => l.measure === word('vocab/documents'))?.value, by: ((b) => (b && !own.includes(b) ? b : undefined))(region.find((l) => l.by)?.by) }))(pinned(s));
+    const same = (a, b) => ((x, y) => x.origins.some((o) => y.origins.includes(o)) || (x.pin !== undefined && x.pin === y.pin) || (x.by !== undefined && x.by === y.by))(origin(a), origin(b));
+    const shares = (s) => ((l) => (l === undefined ? undefined : members(l.value ?? '')))(line(`${word('marks/shares')}/${s}`));
+    const kin = (s, earlier) => earlier.find((e) => same(s, e.source) || shares(s)?.includes(e.source) || shares(e.source)?.includes(s));
+    return [...got.flatMap((g) => ('said' in g ? g.said : [])), ...[...new Set(reads.flatMap((r) => [...r.fields.keys()]))].flatMap((field) => {
+            const values = reads.filter((r) => r.fields.has(field));
+            if (new Set(values.map((r) => r.fields.get(field))).size > 1)
+                return [...values.map((r) => say('forked', { field, source: r.source, value: r.fields.get(field), at: r.at })), say('unmeasured', { what: `${word('marks/loss')} ${values.map((r) => r.source).join(', ')}`, needs: word('marks/loss-needs') })];
+            if (values.length < 2 || values.length < reads.length)
+                return values.map((r) => say('partial', { field, source: r.source, value: r.fields.get(field), at: r.at }));
+            const kinOf = values.map((r, i) => kin(r.source, values.slice(0, i))), first = kinOf.findIndex((k) => k !== undefined);
+            const base = { field, value: values[0].fields.get(field), sources: values.map((r) => r.source).join(', '), marks: kinOf.map((k) => (k ? mark[1] : mark[0])).join(''), receipts: values.map((r) => r.receipt).join('|') };
+            return [first >= 0 ? say('agreed-lineage', { ...base, source: values[first].source, other: kinOf[first].source })
+                    : values.every((r) => line(`${word('marks/shares')}/${r.source}`)?.value === word('marks/undeclared')) ? say('agreed-undeclared', base) : say('agreed-unknown', base)];
+        })];
+};

package/dist/src/onboard/first.d.ts

@@ -1,7 +1,9 @@
 import { type Asked, type Context } from '../core/answer.ts';
 /**
- * The first source a person connects with no place named and none to read from: their place is founded in the folder
- * the lock names under their own home, and the source connected to it, on one yes for both. A folder that already holds
- * a place is used as it stands, never founded again, and its connect asks its own yes.
+ * The first source a person connects with no place named and none to read from, on one yes that says all it grants:
+ * their place founded in the folder the lock names under their own home, the source connected to it, and reads of it
+ * granted until the access period ends. A document that does not arrive is no refusal: the place is founded owing it
+ * by its address. Either way the question asked comes back as what to ask next. A folder that already holds a place is
+ * used as it stands, never founded again, and its connect asks its own yes.
  */
 export declare const firstRun: (asked: Asked, context: Context, then: (place: string, covered: boolean) => Promise<readonly string[]>) => Promise<readonly string[]>;

package/dist/src/onboard/first.js

@@ -1,21 +1,38 @@
 import { basename, join } from 'node:path';
-import { LOCK } from '@lapxo/topos/wire';
+import { canonical, LOCK } from '@lapxo/topos/wire';
 import { unless } from "../core/answer.js";
+import { untilOf } from "../core/act.js";
 import { valueOf } from "../core/lock.js";
 import { sayIn } from "../core/surface.js";
+import { rootIn } from "../flows/device.js";
 import { bornAt } from "../places/found.js";
+import { attachedFor } from "../sources/access.js";
 /**
- * The first source a person connects with no place named and none to read from: their place is founded in the folder
- * the lock names under their own home, and the source connected to it, on one yes for both. A folder that already holds
- * a place is used as it stands, never founded again, and its connect asks its own yes.
+ * The first source a person connects with no place named and none to read from, on one yes that says all it grants:
+ * their place founded in the folder the lock names under their own home, the source connected to it, and reads of it
+ * granted until the access period ends. A document that does not arrive is no refusal: the place is founded owing it
+ * by its address. Either way the question asked comes back as what to ask next. A folder that already holds a place is
+ * used as it stands, never founded again, and its connect asks its own yes.
  */
 export const firstRun = async (asked, context, then) => {
-    const say = sayIn(context.lock), dir = join(context.personal(), valueOf(context.lock, 'first-run/folder')), name = basename(dir);
+    const say = sayIn(context.lock), word = (k) => valueOf(context.lock, k), dir = join(context.personal(), word('first-run/folder')), name = basename(dir);
     if (context.files.has(dir, LOCK))
         return then(dir, false);
-    const refused = await unless(context, say('elicit-first-run', { dir, source: asked['source'] ?? '', document: asked['document'] ?? '' }));
+    const [source, document, until] = [(asked['source'] ?? '').toLowerCase().replace(/[^a-z0-9-]+/g, '-'), asked['document'] ?? '', untilOf(word('access/period'), context.now())];
+    const refused = await unless(context, say('elicit-first-run', { dir, source, document, until }));
     if (refused)
         return refused;
-    const born = await bornAt(context, dir, name);
-    return born[0] === say('born', { name, dir }) ? [...born, ...(await then(dir, true))] : born;
+    const born = await bornAt(context, dir, name), root = rootIn(context, dir);
+    if (born[0] !== say('born', { name, dir }) || 'said' in root)
+        return 'said' in root ? [...born, ...root.said] : born;
+    const connected = await then(dir, true), unread = connected.some((l) => l.startsWith('said/head/document-unread ')), held = unread ? undefined : await context.policy(dir);
+    if (held !== undefined && ('refused' in held || !held.lines.some((l) => l.scope === `uses/${source}`)))
+        return [...born, ...connected];
+    const line = (scope, measure, value, role = 'writes') => canonical({ at: 'policy:head/first-run', by: 'target', form: 'alphabet', measure, role, scope, value });
+    const owed = unread ? [line(`${word('place/needs')}/bytes/${source}`, 'id', document, 'demands')] : [];
+    const landed = await context.landRoot(dir, [line(word('grant/family'), 'sources', source), line(word('grant/family'), 'until', until), ...owed], root.account);
+    if ('refused' in landed)
+        return [...born, ...connected, say('not-landed', { why: landed.refused })];
+    const access = unread ? undefined : await attachedFor(context, dir, source);
+    return [...born, ...(unread ? [] : connected), ...landed.lines, ...(access !== undefined && 'said' in access ? access.said : []), say(unread ? 'bytes-owed' : 'ready', { source, place: dir, document, operation: asked['operation'], args: asked['args'] })];
 };

package/dist/src/onboard/owed.d.ts

@@ -0,0 +1,10 @@
+import { type Asked, type Context } from '../core/answer.ts';
+/**
+ * What a place founded on a first connect still owes: its source's document, by the address the person gave. Asked again,
+ * it is read there; once it arrives, the source is connected from those bytes and pinned by their digest, the demand is
+ * withdrawn and the question is answered. Until then it is not: what is owed is said, and nothing else is asked.
+ */
+export declare const paidIn: (asked: Asked, context: Context, place: string) => Promise<{
+    readonly said: readonly string[];
+    readonly answer: boolean;
+}>;

package/dist/src/onboard/owed.js

@@ -0,0 +1,28 @@
+import { canonical } from '@lapxo/topos/wire';
+import { standingOr } from "../core/answer.js";
+import { valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+import { rootIn } from "../flows/device.js";
+import { laidIn } from "../sources/connect.js";
+/**
+ * What a place founded on a first connect still owes: its source's document, by the address the person gave. Asked again,
+ * it is read there; once it arrives, the source is connected from those bytes and pinned by their digest, the demand is
+ * withdrawn and the question is answered. Until then it is not: what is owed is said, and nothing else is asked.
+ */
+export const paidIn = async (asked, context, place) => {
+    const say = sayIn(context.lock), word = (k) => valueOf(context.lock, k), source = asked['source'] ?? '';
+    const held = await standingOr(context, place), scope = `${word('place/needs')}/bytes/${source}`;
+    const owed = 'said' in held ? undefined : held.lines.find((l) => l.scope === scope && l.role === 'demands' && l.value !== 'withdraw');
+    if (owed === undefined)
+        return { said: [], answer: true };
+    const document = owed.value ?? '', read = await context.files.read.documentOf(context, place, document), root = rootIn(context, place);
+    if ('said' in root)
+        return { said: root.said, answer: false };
+    if (read === undefined)
+        return { said: [say('bytes-owed', { source, place, document })], answer: false };
+    const laid = await laidIn(context, place, root.account)(source, document, read, undefined, context.machine());
+    if (!laid.connected)
+        return { said: laid.said, answer: false };
+    const landed = await context.landRoot(place, [canonical({ ...Object.fromEntries(Object.entries(owed).filter(([k]) => !['sig', 'epoch'].includes(k))), by: 'target', value: 'withdraw' })], root.account);
+    return 'refused' in landed ? { said: [...laid.said, say('not-landed', { why: landed.refused })], answer: false } : { said: [...laid.said, ...landed.lines], answer: true };
+};

package/dist/src/onboard/site.d.ts

@@ -0,0 +1,12 @@
+import type { Asked, Context } from '../core/answer.ts';
+/**
+ * What a person names as a source's document, made a document head can read, before anything is founded or connected:
+ * an address or a file is as given; a site alone is looked for where it says its documents are (its API catalog) and at
+ * the paths the lock names, the first that reads taken; a folder, at the same names inside it. A source the person names
+ * none for is named after the site or the folder. A site where nothing reads is said, with what was tried.
+ */
+export declare const resolved: (asked: Asked, context: Context) => Promise<{
+    readonly asked: Asked;
+} | {
+    readonly said: readonly string[];
+}>;

package/dist/src/onboard/site.js

@@ -0,0 +1,22 @@
+import { basename, dirname, join } from 'node:path';
+import { EXTENSION } from '@lapxo/topos/wire';
+import { members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+/**
+ * What a person names as a source's document, made a document head can read, before anything is founded or connected:
+ * an address or a file is as given; a site alone is looked for where it says its documents are (its API catalog) and at
+ * the paths the lock names, the first that reads taken; a folder, at the same names inside it. A source the person names
+ * none for is named after the site or the folder. A site where nothing reads is said, with what was tried.
+ */
+export const resolved = async (asked, context) => {
+    const [at, word] = [asked['document'] ?? '', (k) => valueOf(context.lock, k)], named = (name) => asked['source'] || name.toLowerCase().replace(/[^a-z0-9-]+/g, '-');
+    if (/^([a-z]+:\/\/)?[^/\s]+\.[^/\s]+\/?$/.test(at) && URL.canParse(/^[a-z]+:\/\//.test(at) ? at : `${word('use/scheme')}//${at}`)) {
+        const site = new URL(/^[a-z]+:\/\//.test(at) ? at : `${word('use/scheme')}//${at}`), tried = await context.files.read.describedAt(context, site.origin);
+        for (const document of tried)
+            if (((read) => read !== undefined && `.${read.kind}` !== EXTENSION)(await context.files.read.documentOf(context, '', document)))
+                return { asked: { ...asked, document, source: named(site.hostname) } };
+        return { said: [sayIn(context.lock)('use-none', { origin: site.origin, tried: tried.join(', ') || '—' })] };
+    }
+    const inside = at.startsWith('/') && context.files.list(dirname(at), basename(at)).length ? members(word('use/documents')).map((p) => basename(p)).find((n) => context.files.has(at, n)) : undefined;
+    return { asked: inside === undefined ? asked : { ...asked, document: join(at, inside), source: named(basename(at)) } };
+};

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

@@ -57,5 +57,6 @@ export declare const words: {
     profile: string;
     receipts: string;
     refusal: string;
+    identity: string;
 };
 export declare const settledView: (name: string, place: string, view: string, signal?: AbortSignal) => Promise<Folded>;

package/dist/src/ports/bound.js

@@ -5,6 +5,8 @@ import { dirname, join } from 'node:path';
 import { parse } from '@lapxo/topos/wire';
 import { spawned } from "./process.js";
 import { cooled, kept, warmed } from "./warm.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'));
@@ -34,6 +36,16 @@ export const warm = (name) => ((bin) => (bin === undefined ? Promise.resolve() :
 export { cooled };
 const facts = (out) => out.flatMap((line) => ((got) => (got.kind === 'fact' ? [got.value.fields] : []))(parse(line)));
 const readOf = (printed) => (printed === undefined || printed.code !== 0 ? { refused: why(printed) ?? '' } : { lines: facts(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: facts(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);
+};
 /**
  * The lines a place stands on, from bound's public views alone: its folded normative standing (the lines view) — its
  * policy, all that a reader of its pins, keys and views needs, read alone where nothing else is — and from
@@ -43,12 +55,12 @@ const readOf = (printed) => (printed === undefined || printed.code !== 0 ? { ref
  * name. A place whose land prints no act result is refused before anything lands in it. Any refusal of bound is no standing.
  */
 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` }))(readOf(await run(name, place, [words.read, words.view, words.standing], {}, signal)));
+    : { 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 standingAt = async (name, place, devicesOf, isHistory, signal) => {
     const folded = await policyAt(name, place, signal);
     if ('refused' in folded)
         return folded;
-    const evidence = readOf(await run(name, place, [words.read, words.view, words.evidence], {}, signal));
+    const evidence = await nativeView(name, place, words.evidence, signal);
     if ('refused' in evidence)
         return evidence;
     const ids = new Set(devicesOf(folded.lines)), own = evidence.lines.filter((line) => ids.has(line.by ?? ''));
@@ -81,5 +93,5 @@ export const pinnedAt = async (name, place, file, signal) => {
     return pin === undefined || !bytes ? undefined : { pin, bytes, lines: read.lines };
 };
 export const founded = async (name, place, key, signer, env, signal) => ((got) => (got !== undefined && got.code === 0 ? { lines: got.out } : { refused: why(got) ?? '' }))(await run(name, place, [words.land, words.key, key, words.signer, signer], env, signal));
-export const words = { read: '', view: '', sign: '', land: '', key: '', signer: '', pin: '', topos: '', standing: '', evidence: '', act: '', profile: '', receipts: '', refusal: '' };
+export const words = { read: '', view: '', sign: '', land: '', key: '', signer: '', pin: '', topos: '', standing: '', evidence: '', act: '', profile: '', receipts: '', refusal: '', identity: '' };
 export const settledView = async (name, place, view, signal) => readOf(await run(name, place, [words.read, words.view, view], {}, signal));

package/dist/src/ports/documents.js

@@ -32,7 +32,7 @@ export const fetchedAs = async (context, at, via, got, named, accept) => {
             return { said: [say('fetch-redirect', { document: at })] };
         return ((bytes) => (bytes ? { bytes, kind: kindOf(at) } : { said: [say('document-unread', { document: at })] }))(await transport.published(new URL(answer.location, at).href, named, most, wait));
     }
-    return answer.status < 300 ? { bytes: answer.bytes, kind: kindOf(at, answer.type) } : { said: [say('fetch-status', { document: at, via, status: String(answer.status) })] };
+    return answer.status < 300 ? { bytes: answer.bytes, kind: kindOf(at, answer.type) } : { said: [say('fetch-status', { document: at, via, status: String(answer.status), at: new Date(context.now()).toISOString() })] };
 };
 /**
  * Every byte a package's lines name, by the path each names: read where a line of the same scope says — an encrypted

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

@@ -0,0 +1,8 @@
+import type { Printed } from './process.ts';
+/** Only the installed instrument names a view's identity and the result bound to it. */
+export declare const readingOf: (printed: Printed | undefined, view: string, expected?: string) => {
+    readonly identity: string;
+    readonly text?: string;
+} | {
+    readonly refused: string;
+};

package/dist/src/ports/reading.js

@@ -0,0 +1,14 @@
+/** Only the installed instrument names a view's identity and the result bound to it. */
+export const readingOf = (printed, view, expected) => {
+    if (!printed || printed.code !== 0)
+        return { refused: printed?.refusal?.['code'] ?? 'reading-identity/unavailable' };
+    try {
+        const value = printed.out.length === 1 ? JSON.parse(printed.out[0]) : undefined;
+        if (value?.['kind'] !== 'fact' || value['view'] !== view || typeof value['identity'] !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(value['identity']) || (expected !== undefined && (value['identity'] !== expected || typeof value['text'] !== 'string')))
+            return { refused: 'reading-identity/context' };
+        return { identity: value['identity'], ...(expected === undefined ? {} : { text: value['text'] }) };
+    }
+    catch {
+        return { refused: 'reading-identity/format' };
+    }
+};

package/dist/src/ports/spare.js

@@ -18,7 +18,7 @@ import { pathToFileURL } from 'node:url';
 const [program] = process.argv.slice(2);
 const url = pathToFileURL(program), pipe = new Socket({ fd: 3, readable: true, writable: true });
 const asked = new Promise((resolve) => { let text = ''; pipe.setEncoding('utf8').on('data', (chunk) => { text += chunk; }).on('error', () => undefined).on('close', () => resolve(text)); });
-await Promise.all([...readFileSync(program, 'utf8').matchAll(/^import [^'"]*['"](\.{1,2}\/[^'"]+)['"];?$/gm)].map(([, path]) => import(__rewriteRelativeImportExtension(new URL(path, url).href)).catch(() => undefined)));
+await Promise.all([...readFileSync(program, 'utf8').matchAll(/(?:^|[;\n])\s*import\s*(?:(?:[^'";]*?)\s*from\s*)?['"](\.{1,2}\/[^'"]+)['"]/g)].map(([, path]) => import(__rewriteRelativeImportExtension(new URL(path, url).href)).catch(() => undefined)));
 pipe.write('ready\n');
 const text = await asked;
 if (!text)

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

@@ -28,10 +28,14 @@ export interface Surface {
     readonly name: string;
     readonly version: string;
     readonly tools: readonly Tool[];
+    readonly catalogue: readonly Tool[];
     readonly resources: readonly Resource[];
     readonly prompts: readonly Prompt[];
 }
-/** Everything a client is offered, read off the lock alone: its tools, resources and prompts, each with the words a model sees. */
+/**
+ * Everything a client is offered, read off the lock alone, each with the words a model sees: the tools surface/tools
+ * names, out of the catalogue the tool lines are (every one of them where it names none), its resources and prompts.
+ */
 export declare const surfaceOf: (lock: readonly Said[]) => Surface;
 export declare const refusedOn: (lock: readonly Said[], platform: string) => string | undefined;
 /**

package/dist/src/ports/surface.js

@@ -4,13 +4,15 @@ const nameOf = (line) => line.scope.split('/')[1];
 const fieldsOf = (lock, scope) => ((required) => members(valueOf(lock, scope)).map((name) => ({
     name, about: aboutOf(lock, `${scope}/${name}`), type: valueOf(lock, `${scope}/${name}`), required: required.includes(name)
 })))(members(valueOf(lock, `${scope}/required`)));
-/** Everything a client is offered, read off the lock alone: its tools, resources and prompts, each with the words a model sees. */
-export const surfaceOf = (lock) => ({
-    name: valueOf(lock, 'name'), version: valueOf(lock, 'version'),
-    tools: below(lock, 'tool').map((line) => ({ name: nameOf(line), about: line.about ?? '', fields: fieldsOf(lock, line.scope), hints: members(valueOf(lock, `${line.scope}/hints`)) })),
+/**
+ * Everything a client is offered, read off the lock alone, each with the words a model sees: the tools surface/tools
+ * names, out of the catalogue the tool lines are (every one of them where it names none), its resources and prompts.
+ */
+export const surfaceOf = (lock) => ((catalogue, offered) => ({
+    name: valueOf(lock, 'name'), version: valueOf(lock, 'version'), catalogue, tools: offered.length ? catalogue.filter((t) => offered.includes(t.name)) : catalogue,
     resources: below(lock, 'resource').map((line) => ({ name: nameOf(line), about: line.about ?? '', template: line.value ?? '', mime: valueOf(lock, `${line.scope}/mime`) })),
     prompts: below(lock, 'prompt').map((line) => ({ name: nameOf(line), about: line.about ?? '', text: aboutOf(lock, `${line.scope}/text`), line: aboutOf(lock, `${line.scope}/line`), fields: fieldsOf(lock, line.scope) })),
-});
+}))(below(lock, 'tool').map((line) => ({ name: nameOf(line), about: line.about ?? '', fields: fieldsOf(lock, line.scope), hints: members(valueOf(lock, `${line.scope}/hints`)) })), members(valueOf(lock, 'surface/tools')));
 export const refusedOn = (lock, platform) => ((supported) => (supported.includes(platform) ? undefined : sayIn(lock)('platform', { platform, supported: supported.join('|') })))(members(valueOf(lock, 'platform/supported')));
 /**
  * The fields a URI gives a resource template, or none when it is not one of its URIs: {name} matches one path step,

package/dist/src/ports/warm.js

@@ -40,7 +40,6 @@ export const warmed = (program, args, at, bounds) => {
     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);
+    return watched(spare.child, bounds).finally(() => { void kept(program); });
 };

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

@@ -1,4 +1,5 @@
 import type { Asked, Context } from '../core/answer.ts';
+import type { Read } from '../ports/documents.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
@@ -11,3 +12,10 @@ import type { Asked, Context } from '../core/answer.ts';
  * 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[]>;
+type Connection = {
+    readonly said: readonly string[];
+    readonly connected: boolean;
+};
+type Laid = (source: string, document: string, doc: Read, overlay: Read | undefined, started: number) => Promise<Connection>;
+export declare const laidIn: (context: Context, place: string, account: string) => Laid;
+export {};

package/dist/src/sources/connect.js

@@ -1,17 +1,16 @@
-import { join } from 'node:path';
-import { canonical, EXTENSION, LOCK } from '@lapxo/topos/wire';
+import { canonical, EXTENSION } 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 { 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 { resolved } from "../onboard/site.js";
+import { linked } from "../links/inspect.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
@@ -24,8 +23,10 @@ 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['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) => {
+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)));
+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;
         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];
@@ -54,38 +55,8 @@ export const connected = async (asked, context, covered = false) => (asked['sour
             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);
+        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 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)
@@ -95,20 +66,20 @@ const received = async (context, place, document, bytes, named, laid, account) =
     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())));
+        said.push(...(await laid(s.source, s.document.at, s.document, s.overlay, context.machine())).said);
     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 () => {
+export 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 })];
+        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]] : [])];
     for (const [at, bytes] of laid)
         context.files.lay(place, at, bytes);
@@ -117,14 +88,14 @@ const laidIn = (context, place, account) => (source, document, doc, overlay, sta
         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;
+        return { said: 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, connected: false };
     }
     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())]);
+    return { connected: picked === undefined || !('refused' in picked), said: [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((result) => ({ ...result, said: [...result.said, ...redIn(context.lock)('connect/seconds', `connect/${source}`, started, context.machine())] }));

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

@@ -0,0 +1,7 @@
+import { type Context } from '../core/answer.ts';
+import { type Said } from '../core/lock.ts';
+import type { Call } from '../core/read.ts';
+/** A read refused with the access head attached: its secret kept marked spent, never in a line, so the next call obtains it once; the refusal lands as a receipt without it. */
+export declare const refusedAccess: (context: Context, place: string, lines: readonly Said[], plan: Call, operation: string) => Promise<readonly string[]>;
+/** The access a place was refused and has not obtained since, by its newest receipt: what its card shows as open. */
+export declare const pendingIn: (context: Context, place: string) => Promise<readonly string[]>;