@lapxo/head 0.1.0 → 0.1.4

package/dist/src/ports/surface.js

@@ -0,0 +1,50 @@
+import { aboutOf, below, members, valueOf } from "../core/lock.js";
+import { sayIn } from "../core/surface.js";
+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, 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,
+ * {?a,b} names query fields any of which may be absent, in any order, each decoded.
+ */
+export const matchTemplate = (template, uri) => {
+    const [path = '', query = ''] = template.split('{?');
+    const names = [...path.matchAll(/\{(\w+)\}/g)].map((m) => m[1]);
+    const pattern = new RegExp(`^${path.split(/\{\w+\}/).map((part) => part.replace(/[.*+?^$()|[\]\\]/g, '\\$&')).join('([^/?#]+)')}(?:\\?(.*))?$`);
+    const got = pattern.exec(uri);
+    if (got === null)
+        return undefined;
+    const params = new URLSearchParams(got[names.length + 1] ?? '');
+    return { ...Object.fromEntries(names.map((name, i) => [name, decodeURIComponent(got[i + 1])])),
+        ...Object.fromEntries(query.replace('}', '').split(',').filter(Boolean).flatMap((name) => ((v) => (v === null ? [] : [[name, v]]))(params.get(name)))) };
+};
+/** A said code as the cell head answers with: its state and next from the lock, the next's arguments read from the cell's own fields; a bound refusal a field carries keeps bound's code, head's own beside it. */
+export const cellOf = (lock, key, given) => {
+    const fields = Object.fromEntries(Object.entries(given).filter((e) => e[1] !== undefined)), bound = Object.values(fields).map((v) => /^REFUSE·[\w-]+/.exec(v)?.[0]).find(Boolean);
+    const [tool, args] = [valueOf(lock, `said/${key}/next`), members(valueOf(lock, `said/${key}/next/args`)).map((a) => ((k, v) => [k, v.startsWith('$') ? fields[v.slice(1)] ?? '' : v])(a.split(':')[0], a.slice(a.indexOf(':') + 1)))];
+    return { code: bound ?? `head/${key}`, state: valueOf(lock, `said/${key}/state`), next: tool === 'none' ? { none: aboutOf(lock, `said/${key}/next`) } : { tool, args: Object.fromEntries(args) }, fields, ...(bound ? { head: `head/${key}` } : {}) };
+};
+export const cellLine = (cell) => [`said/${cell.code} state=${cell.state}`, ...('tool' in cell.next ? [`next=${cell.next.tool}`, ...Object.entries(cell.next.args).map(([k, v]) => `next.${k}=${JSON.stringify(v)}`)] : ['next=none', `next.why=${JSON.stringify(cell.next.none)}`]),
+    ...(cell.head ? [`head=${JSON.stringify(cell.head)}`] : []), ...Object.entries(cell.fields).map(([k, v]) => `${k}=${JSON.stringify(v)}`)].join(' ');
+/** An answer as cells and the lines bound printed beside them, read back from what head said: the shape every tool result has. */
+export const shapeOf = (answer) => ({ lines: answer.filter((l) => !l.startsWith('said/')),
+    cells: answer.filter((l) => l.startsWith('said/')).map((l) => ((code, rest) => ((t) => ({ code, state: t['state'] ?? '', next: t['next'] === 'none' || t['next'] === undefined ? { none: t['next.why'] ?? '' } : { tool: t['next'], args: Object.fromEntries(Object.entries(t).filter(([k]) => k.startsWith('next.')).map(([k, v]) => [k.slice(5), v])) },
+        fields: Object.fromEntries(Object.entries(t).filter(([k]) => !['state', 'next', 'head'].includes(k) && !k.startsWith('next.'))), ...(t['head'] ? { head: t['head'] } : {}) }))(Object.fromEntries([...rest.matchAll(/(\S+?)=("(?:[^"\\]|\\.)*"|\S+)/g)].map((m) => [m[1], m[2].startsWith('"') ? JSON.parse(m[2]) : m[2]]))))(l.slice('said/'.length, l.indexOf(' ')), l.slice(l.indexOf(' ') + 1))) });
+/** The one output schema every tool declares: cells in the states the lock names, and the lines bound printed. */
+export const shapeSchema = (lock) => ({ type: 'object', required: ['cells', 'lines'], properties: {
+        cells: { type: 'array', items: { type: 'object', required: ['code', 'state', 'next', 'fields'], properties: { code: { type: 'string' }, state: { enum: [...members(valueOf(lock, 'shape/states'))] }, head: { type: 'string' },
+                    next: { oneOf: [{ type: 'object', required: ['tool', 'args'], properties: { tool: { type: 'string' }, args: { type: 'object', additionalProperties: { type: 'string' } } } }, { type: 'object', required: ['none'], properties: { none: { type: 'string' } } }] },
+                    fields: { type: 'object', additionalProperties: { type: 'string' } } } } },
+        lines: { type: 'array', items: { type: 'string' } }
+    } });

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

@@ -0,0 +1,19 @@
+import type { Bounds, Printed } from './process.ts';
+/** How many processes head keeps started ahead of each program while it answers a call, and the variables node reads as it starts: a process started under other values of them is never asked. */
+export declare const warmth: {
+    spares: number;
+    boot: readonly string[];
+};
+/** Keeps as many processes started ahead of a program as head's lock says; resolved when each has loaded what it runs. */
+export declare const kept: (program: string) => Promise<unknown>;
+/** Every process still waiting to be asked is stopped: head keeps none past the call it started them for. */
+export declare const cooled: () => void;
+/**
+ * A program run in a process started ahead under the same starting variables, handed the folder, arguments and
+ * variables a process started now would get, and watched within the same bounds; undefined when none is held ready,
+ * so the caller starts one as before and never waits on one still loading. Each process answers one ask and ends.
+ */
+export declare const warmed: (program: string, args: readonly string[], at: {
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+}, bounds: Bounds) => Promise<Printed> | undefined;

package/dist/src/ports/warm.js

@@ -0,0 +1,46 @@
+import { fileURLToPath } from 'node:url';
+import { grouped, watched } from "./process.js";
+/** How many processes head keeps started ahead of each program while it answers a call, and the variables node reads as it starts: a process started under other values of them is never asked. */
+export const warmth = { spares: 0, boot: [] };
+const spares = new Map();
+const alive = (one) => one.child.exitCode === null && one.child.signalCode === null;
+const entry = fileURLToPath(new URL(`./spare${import.meta.url.slice(import.meta.url.lastIndexOf('.'))}`, import.meta.url));
+const bootOf = (env) => JSON.stringify(Object.entries(env).filter(([name]) => warmth.boot.some((p) => name.startsWith(p))).sort(([a], [b]) => (a < b ? -1 : 1)));
+const stop = (one) => { try {
+    process.kill(-one.child.pid, 'SIGKILL');
+}
+catch {
+    one.child.kill('SIGKILL');
+} };
+const started = (program) => {
+    const env = { ...process.env }, child = grouped(process.execPath, [entry, program], { env }, 4);
+    child.stdin.on('error', () => undefined).end('');
+    const spare = { child, boot: bootOf(env), ready: new Promise((resolve) => { child.stdio[3].on('error', () => undefined).once('data', () => { spare.loaded = true; resolve(); }); child.once('close', () => resolve()); }), loaded: false };
+    return spare;
+};
+/** Keeps as many processes started ahead of a program as head's lock says; resolved when each has loaded what it runs. */
+export const kept = (program) => {
+    const live = (spares.get(program) ?? []).filter(alive);
+    while (live.length < warmth.spares)
+        live.push(started(program));
+    spares.set(program, live);
+    return Promise.all(live.map((one) => one.ready));
+};
+/** Every process still waiting to be asked is stopped: head keeps none past the call it started them for. */
+export const cooled = () => { for (const one of [...spares.values()].flat())
+    stop(one); spares.clear(); };
+process.once('exit', cooled);
+/**
+ * A program run in a process started ahead under the same starting variables, handed the folder, arguments and
+ * variables a process started now would get, and watched within the same bounds; undefined when none is held ready,
+ * so the caller starts one as before and never waits on one still loading. Each process answers one ask and ends.
+ */
+export const warmed = (program, args, at, bounds) => {
+    const live = spares.get(program) ?? [], index = live.findIndex((one) => one.loaded && alive(one) && one.boot === bootOf(at.env));
+    const spare = index < 0 ? undefined : live.splice(index, 1)[0];
+    if (spare === undefined)
+        return undefined;
+    void kept(program);
+    spare.child.stdio[3].end(`${JSON.stringify({ cwd: at.cwd, args, env: at.env })}\n`);
+    return watched(spare.child, bounds);
+};

package/dist/src/signer.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from 'node:fs';
-import { signLot } from "./core/keys.js";
+import { signLot } from "./ports/keys.js";
 import { keychain } from "./ports/keychain.js";
 const [service = '', account = '', key = '', algorithm = '', store = 'keychain'] = process.argv.slice(2);
 const secret = keychain(service, store).read(account);

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

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

package/dist/src/sources/access.js

@@ -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

@@ -1,10 +1,21 @@
 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
  * 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[]>;
+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,55 +1,83 @@
-import { extname, isAbsolute, resolve, sep } from 'node:path';
 import { canonical, EXTENSION } from '@lapxo/topos/wire';
-import { inPlace, unless } from "../core/answer.js";
+import { inPlace, placeOf, unless } from "../core/answer.js";
 import { valueOf } from "../core/lock.js";
-import { vocabOf } from "../core/read.js";
+import { fieldsOf, vocabOf } from "../core/read.js";
 import { redIn, sayIn } from "../core/surface.js";
-import { digestIn } from "../core/worlds.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 { 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 { 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) => ((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];
+        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 })] : (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)))];
+    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())).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 })] : [])];
+};
+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);
-    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 })];
+        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);
@@ -58,11 +86,14 @@ export const connected = (asked, context) => ((started) => inPlace(asked, contex
         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))];
-}).then((lines) => [...lines, ...redIn(context.lock)('connect/seconds', `connect/${asked['source'] ?? ''}`, started, context.machine())]))(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[]>;

package/dist/src/sources/refused.js

@@ -0,0 +1,16 @@
+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 { opened, sealed } from "../access/obtain.js";
+/** 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 const refusedAccess = async (context, place, lines, plan, operation) => {
+    const [account, word] = [plan.access.account ?? '', (k) => valueOf(context.lock, k)], kept = opened(context.keys.read(account));
+    if (kept !== undefined)
+        context.keys.write(account, sealed({ ...kept, expires: 0 }));
+    const landed = await context.landAs(place, [canonical({ at: `${word('receipt/at')}:${new Date(context.now()).toISOString()}`, by: 'target', form: 'alphabet', measure: 'status', role: 'writes', scope: `${word('access/family')}/${plan.access.flow}/refused`, value: 'present' })], 'head', lines);
+    return [sayIn(context.lock)('access-refused', { source: plan.source, operation, place }), ...('lines' in landed ? landed.lines : [])];
+};
+/** The access a place was refused and has not obtained since, by its newest receipt: what its card shows as open. */
+export const pendingIn = async (context, place) => ((held, family) => [...new Map(('said' in held ? [] : held.lines).filter((l) => l.scope?.startsWith(family) && /\/(refused|obtained|renewed|entered)$/.test(l.scope)).sort((a, b) => ((a.at ?? '') < (b.at ?? '') ? -1 : 1))
+        .map((l) => [l.scope.slice(family.length).replace(/\/[^/]+$/, ''), l.scope.endsWith('/refused')]))].filter(([, refused]) => refused).map(([flow]) => sayIn(context.lock)('access-pending', { source: flow.split('/')[0], flow, place })))(await standingOr(context, place), `${valueOf(context.lock, 'access/family')}/`);

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

@@ -0,0 +1 @@
+export { asked as answer } from '../verbs/ask.ts';

package/dist/src/tools/ask.js

@@ -0,0 +1 @@
+export { asked as answer } from "../verbs/ask.js";

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

@@ -1,3 +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. */
+/** 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 declare const answer: Answer;

package/dist/src/tools/card.js

@@ -1,6 +1,7 @@
 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. */
+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) => inPlace(asked, context, async (place) => {
     const word = (scope) => valueOf(context.lock, `bound/${scope}`);
     const held = await standingOr(context, place);
@@ -8,6 +9,6 @@ export const answer = (asked, context) => inPlace(asked, context, async (place)
         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']] : [])]));
+        return [sayIn(context.lock)('no-cells', { place })];
+    return printedOr(context, await context.bound(place, [word('read'), word('view'), `${view.scope.split('/')[1]}${asked['at'] ? `${word('at')}${asked['at']}` : ''}`, ...(asked['key'] ? [word('key'), asked['key']] : [])]));
 });

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

@@ -0,0 +1 @@
+export { done as answer } from '../verbs/do.ts';

package/dist/src/tools/do.js

@@ -0,0 +1 @@
+export { done as answer } from "../verbs/do.js";

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

@@ -1,8 +1,9 @@
 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.
+ * A view of a place, folded by bound at the resolution asked; or the region of a source, or of one operation in it, as
+ * typed lines at the resolution asked: at 0 where it is reached and each offer's class, past it their forms and access,
+ * flows in the order of trust, never what only a transport reads. An operation asked no why is read once, if of the class
+ * head reads; asked why, its region is followed by why its newest answer stands. Each answer reads red past answer/seconds
+ * from the call's start, all head did for it included, with the question it answered as its coordinate.
  */
 export declare const answer: Answer;

package/dist/src/tools/look.js

@@ -5,36 +5,38 @@ 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
- * is measured against answer/seconds and reads red past it, with the question it answered as its coordinate.
+ * A view of a place, folded by bound at the resolution asked; or the region of a source, or of one operation in it, as
+ * typed lines at the resolution asked: at 0 where it is reached and each offer's class, past it their forms and access,
+ * flows in the order of trust, never what only a transport reads. An operation asked no why is read once, if of the class
+ * head reads; asked why, its region is followed by why its newest answer stands. Each answer reads red past answer/seconds
+ * from the call's start, all head did for it included, with the question it answered as its coordinate.
  */
-export const answer = (asked, context) => ((started) => inPlace(asked, context, async (place) => {
+export const answer = (asked, context) => 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'))
+        const [operation, why] = [asked['operation'], asked['why'] === 'true'];
+        if (operation && !why)
             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 [v, first, shallow] = [vocabOf(context.lock), asked['at'] === '0', word('look/first').split('|')];
+        const region = `${v.offers}/${source}/${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}`))
+            if (!(operation ? scope === region || scope.startsWith(`${region}/`) : scope.startsWith(region)) || 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 })];
+        return shown.length ? [...shown.map((l) => canonical(l)).sort(), ...(first ? [] : trustOf(context.lock, held.lines, source)), ...(operation ? await readSource(asked, context) : [])] : [sayIn(context.lock)('unread', { source })];
     }
-    const view = `${asked['view'] || word('bound/standing')}${asked['at'] ? `${word('bound/at')}${asked['at']}` : ''}`;
+    const view = `${asked['view'] ?? ''}${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());
+}).then((lines) => [...lines, ...redIn(context.lock)('answer/seconds', `answer/${asked['source'] ? `${asked['source']}/${asked['operation'] ?? ''}` : asked['view'] ?? ''}`, context.begun, context.machine())]);

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/dist/src/verbs/ask.d.ts

@@ -0,0 +1,11 @@
+import type { Answer } from '../core/answer.ts';
+/**
+ * What a person asks, answered by the question it is. A view, or the region of a source or of one operation in it (what
+ * it offers, one read of it, why that answer stands, what was kept of it), is answered by look; drafted lines by plan;
+ * what is open by card; anything else by places. Each form is read with no resolution unless the lock declares one for a
+ * person; asked why, at the one it declares to explain, and where it declares none, the same answer, said so. Nothing
+ * here writes one. An answer about one place ends with its card, taken off the fold the answer reads, valid from it.
+ * With no place at all, nothing is founded: it says so, and that connecting an API founds the person's place, the question
+ * carried along. A place still owing a source's bytes is answered only once they arrive.
+ */
+export declare const asked: Answer;