@lapxo/head 0.0.0-stage → 0.1.3

package/dist/src/core/package.d.ts

@@ -0,0 +1,54 @@
+import { type Asked, type Context } from './answer.ts';
+import { type Said } from './lock.ts';
+/** A line no package carries: one that is not a world, or a source's document, overlay or pin, said once by digest — with, beside a digest that names bytes, the encrypted address they are read at. */
+export declare const foreignIn: (lines: readonly Said[]) => Said | undefined;
+/** A place packed as its published lock would name it, into a folder inside it or one the client shares, apart from what head and bound keep: each world its sources were compiled under, and each source — document, overlay, and compiled pin resting on the sources whose issuers it names — by digest, beside the bytes those digests name, and where the person says they are also published, at that encrypted address. No line of access, key or grant: a package grants nothing, and nothing is asked, signed or landed. */
+export declare const shared: (asked: Asked, context: Context) => Promise<readonly string[]>;
+/** What a package names, checked whole before anything is asked: every line a world or a source's document, overlay or pin, by digest; each world the one this head pins; an order its pins rest in. A source whose bytes did not arrive, or did not hash to their line, is open, and so is every source resting on it: absence is not a refusal, and the rest arrives. */
+export declare const unpacked: (context: Context, document: string, bytes: Uint8Array, read: ReadonlyMap<string, Uint8Array | undefined>) => {
+    said: string[];
+    sources?: undefined;
+    open?: undefined;
+} | {
+    sources: ({
+        overlay: {
+            at: string;
+            bytes: Uint8Array<ArrayBufferLike>;
+            kind: string;
+        };
+        source: string;
+        pin: string;
+        document: {
+            at: string;
+            bytes: Uint8Array<ArrayBufferLike>;
+            kind: string;
+        };
+    } | {
+        overlay?: undefined;
+        source: string;
+        pin: string;
+        document: {
+            at: string;
+            bytes: Uint8Array<ArrayBufferLike>;
+            kind: string;
+        };
+    })[];
+    open: {
+        source: string;
+        owed: string;
+        waits: string;
+    }[];
+    said?: undefined;
+};
+/** Whether the person-s yes to a package already covers what arrives now: every source either pinned as the package names it, or owed by a demand that yes to this same package landed. */
+export declare const coveredIn: (context: Context, held: readonly Said[], arrived: readonly {
+    readonly source: string;
+    readonly pin: string;
+}[], named: string) => boolean;
+/** What a received package leaves owed in the place: a demand per open source naming what it waits on, and the withdraw of a demand a source that arrived has paid, or one a new package names otherwise. */
+export declare const owedIn: (context: Context, held: readonly Said[], arrived: readonly {
+    readonly source: string;
+}[], open: readonly {
+    readonly source: string;
+    readonly owed: string;
+}[], named: string) => readonly string[];

package/dist/src/core/package.js

@@ -0,0 +1,65 @@
+import { dirname, extname, join, relative, sep } from 'node:path';
+import { canonical, LOCK, parse } from '@lapxo/topos/wire';
+import { inPlace, standingOr, within } from "./answer.js";
+import { members, under, valueOf } from "./lock.js";
+import { fieldsOf, vocabOf } from "./read.js";
+import { sayIn } from "./surface.js";
+import { digestIn, linesOf } from "./worlds.js";
+/** A line no package carries: one that is not a world, or a source's document, overlay or pin, said once by digest — with, beside a digest that names bytes, the encrypted address they are read at. */
+export const foreignIn = (lines) => lines.find((l) => !/^(sources\/[a-z0-9-]+(\/overlay)?|uses\/[a-z0-9-]+)$/.test(l.scope ?? '') || lines.some((o) => o !== l && o.scope === l.scope && o.measure === l.measure)
+    || (l.measure !== 'digest' && !(l.measure === 'id' && URL.canParse(l.value ?? '') && lines.some((o) => o.scope === l.scope && o.measure === 'digest' && o.needs))));
+const orderOf = (all, out = []) => ((next) => (next === undefined ? (out.length === all.length ? out : undefined) : orderOf(all, [...out, next])))(all.find((s) => !out.includes(s) && s.rests.every((r) => out.some((o) => o.source === r))));
+const packed = (context, place, own, urls) => {
+    const [word, v, digest, held] = [(k) => valueOf(context.lock, k), vocabOf(context.lock), digestIn(context.lock), (rel) => context.files.take(join(place, rel)) ?? new Uint8Array()];
+    const row = (scope, value, more = {}) => [canonical({ at: 'policy:head/share', by: 'target', form: 'alphabet', measure: 'digest', role: 'writes', scope, value, ...more }),
+        ...(more['needs'] && URL.canParse(urls[more['needs']] ?? '') ? [canonical({ at: 'policy:head/share', by: 'target', form: 'alphabet', measure: 'id', role: 'writes', scope, value: urls[more['needs']] })] : [])];
+    const pins = own.filter((l) => l.scope?.startsWith('uses/') && under(context.lock, 'place/compiled', l.needs)).map((l) => ((source) => ({ source, pin: l.value, needs: l.needs, lines: linesOf(held(l.needs)), laid: context.files.read.laidOf(context, place, source) }))(l.scope.slice('uses/'.length)));
+    const declares = new Map(pins.flatMap((p) => (fieldsOf(p.lines, `${v.region}/${p.source}`)[v.issuers] ?? []).map((issuer) => [issuer, p.source])));
+    const rested = pins.map((p) => ({ ...p, rests: [...new Set(p.lines.filter((l) => l.measure === 'issuer').flatMap((l) => declares.get(l.value ?? '') ?? []))].filter((s) => s !== p.source).sort() })), sources = orderOf(rested) ?? rested;
+    return { names: sources.map((s) => s.source), files: sources.flatMap((s) => [...s.laid, [s.needs, held(s.needs)]]), lines: [...own.filter((l) => members(word('world/adopts')).some((w) => l.scope === `uses/${w}`)).flatMap((l) => row(l.scope, l.value)),
+            ...sources.flatMap((s) => [...s.laid.flatMap(([rel, bytes]) => row(/\.overlay\.[^.]+$/.test(rel) ? `sources/${s.source}/overlay` : `sources/${s.source}`, digest(bytes), { needs: rel })),
+                ...row(`uses/${s.source}`, s.pin, { needs: s.needs, ...(s.rests.length ? { restsOn: s.rests.map((r) => `uses/${r}`).join('|') } : {}) })])] };
+};
+/** A place packed as its published lock would name it, into a folder inside it or one the client shares, apart from what head and bound keep: each world its sources were compiled under, and each source — document, overlay, and compiled pin resting on the sources whose issuers it names — by digest, beside the bytes those digests name, and where the person says they are also published, at that encrypted address. No line of access, key or grant: a package grants nothing, and nothing is asked, signed or landed. */
+export const shared = (asked, context) => inPlace(asked, context, async (place) => {
+    const [say, to, held] = [sayIn(context.lock), asked['to'] ?? '', await standingOr(context, place, context.policy)], [rel, there] = [relative(place, to), linesOf(context.files.take(join(to, LOCK)) ?? new Uint8Array())];
+    if (!(await within(context, place, to)) || (!rel.startsWith('..') && (rel === '' || rel.startsWith('.') || [valueOf(context.lock, 'place/connected'), ...members(valueOf(context.lock, 'place/compiled')), valueOf(context.lock, 'walk/context/file'), valueOf(context.lock, 'place/worlds')].some((at) => rel.split(sep)[0] === at.split('/')[0]))) || foreignIn(there))
+        return [say('share-to', { place, to })];
+    if ('said' in held)
+        return held.said;
+    const pack = packed(context, place, held.lines, ((u) => (u && typeof u === 'object' ? u : {}))((() => { try {
+        return JSON.parse(asked['urls'] || '{}');
+    }
+    catch {
+        return {};
+    } })())), bytes = new TextEncoder().encode(`${pack.lines.join('\n')}\n`);
+    return !pack.names.length ? [say('share-none', { place })] : ([...pack.files, [LOCK, bytes]].forEach(([at, laid]) => context.files.lay(to, at, laid)), [say('shared', { place, to, sources: pack.names.join(', '), digest: digestIn(context.lock)(bytes) }), ...pack.lines]);
+});
+/** What a package names, checked whole before anything is asked: every line a world or a source's document, overlay or pin, by digest; each world the one this head pins; an order its pins rest in. A source whose bytes did not arrive, or did not hash to their line, is open, and so is every source resting on it: absence is not a refusal, and the rest arrives. */
+export const unpacked = (context, document, bytes, read) => {
+    const [say, word, digest, lines] = [sayIn(context.lock), (k) => valueOf(context.lock, k), digestIn(context.lock), linesOf(bytes)], said = lines.filter((l) => l.measure === 'digest'), at = (scope) => said.find((l) => l.scope === scope);
+    const unread = new TextDecoder().decode(bytes).split('\n').find((l) => l && parse(l).kind !== 'fact'), name = (l) => l.scope.split('/')[1];
+    const odd = unread === undefined ? foreignIn(lines) ?? said.find((l) => (l.scope.startsWith('uses/') ? (l.needs ? !at(`sources/${name(l)}`)?.needs : !word(`world/${name(l)}/standing`))
+        : !l.needs || !at(`uses/${name(l)}`)?.needs || l.needs.split('/').includes('..') || l.needs.startsWith('/'))) : { scope: unread.slice(0, 80) };
+    if (odd)
+        return { said: [say('package-line', { document, scope: odd.scope ?? '' })] };
+    const world = said.find((l) => !l.needs && l.value !== word(`world/${name(l)}/standing`)), where = (l) => lines.find((o) => o.scope === l.scope && o.measure === 'id')?.value ?? (URL.canParse(document) ? new URL(l.needs, document).href : join(dirname(document), l.needs));
+    if (world)
+        return { said: [say('package-world', { document, world: name(world), pin: world.value, held: word(`world/${name(world)}/standing`) })] };
+    const off = (l) => l.needs !== undefined && digest(read.get(l.needs) ?? '') !== l.value, of = (scope) => ((l) => l && { at: where(l), bytes: read.get(l.needs), kind: extname(l.needs).slice(1) })(at(scope));
+    const order = orderOf(said.filter((l) => l.scope.startsWith('uses/') && l.needs).map((l) => ({ source: name(l), pin: l.value, rests: (l.restsOn ?? '').split('|').filter(Boolean).map((r) => r.slice('uses/'.length)) })));
+    if (order === undefined)
+        return { said: [say('package-line', { document, scope: 'restsOn' })] };
+    const [open, missing] = [order.reduce((o, s) => (said.some((l) => name(l) === s.source && off(l)) || s.rests.some((r) => o.has(r)) ? o.add(s.source) : o), new Set()), (source) => said.filter((l) => name(l) === source && off(l))];
+    return { sources: order.filter((s) => !open.has(s.source)).map((s) => ({ source: s.source, pin: s.pin, document: of(`sources/${s.source}`), ...((o) => (o ? { overlay: o } : {}))(of(`sources/${s.source}/overlay`)) })),
+        open: order.filter((s) => open.has(s.source)).map((s) => ({ source: s.source, owed: missing(s.source).map((l) => l.value).join('|') || s.rests.filter((r) => open.has(r)).map((r) => `uses/${r}`).join('|'), waits: missing(s.source).map((l) => `${l.value} at ${where(l)}`).join(', ') || s.rests.filter((r) => open.has(r)).join(', ') })) };
+};
+/** Whether the person-s yes to a package already covers what arrives now: every source either pinned as the package names it, or owed by a demand that yes to this same package landed. */
+export const coveredIn = (context, held, arrived, named) => arrived.length > 0 && arrived.every((s) => held.some((l) => l.value !== 'withdraw'
+    && ((l.scope === `uses/${s.source}` && l.value === s.pin) || (l.scope === `${valueOf(context.lock, 'place/needs')}/bytes/${s.source}` && l.role === 'demands' && l.at === `policy:head/receive/${named.slice(7, 23)}`))));
+/** What a received package leaves owed in the place: a demand per open source naming what it waits on, and the withdraw of a demand a source that arrived has paid, or one a new package names otherwise. */
+export const owedIn = (context, held, arrived, open, named) => {
+    const scope = (source) => `${valueOf(context.lock, 'place/needs')}/bytes/${source}`, live = (source) => held.find((l) => l.scope === scope(source) && l.role === 'demands' && l.value !== 'withdraw');
+    const withdrawn = [...arrived.map((s) => live(s.source)), ...open.map((o) => ((l) => (l?.value !== o.owed ? l : undefined))(live(o.source)))].flatMap((l) => (l ? [canonical({ ...Object.fromEntries(Object.entries(l).filter(([k]) => !['sig', 'epoch'].includes(k))), by: 'target', value: 'withdraw' })] : []));
+    return [...withdrawn, ...open.filter((o) => live(o.source)?.value !== o.owed).map((o) => canonical({ at: `policy:head/receive/${named.slice(7, 23)}`, by: 'target', form: 'alphabet', measure: 'digest', role: 'demands', scope: scope(o.source), value: o.owed }))];
+};

package/dist/src/core/read.d.ts

@@ -0,0 +1,54 @@
+import type { Said } from './lock.ts';
+export type Plan = {
+    readonly kind: 'said';
+    readonly key: string;
+    readonly fields: Readonly<Record<string, string>>;
+};
+export type Fields = Readonly<Record<string, readonly string[]>>;
+export interface Access {
+    readonly kind: string;
+    readonly scheme: string;
+    readonly params: Fields;
+    readonly account: string | undefined;
+    readonly flow: string;
+    readonly probe?: true;
+    readonly from?: string;
+}
+export interface Call {
+    readonly kind: 'call';
+    readonly source: string;
+    readonly operation: string;
+    readonly origin: string;
+    readonly carry: Fields;
+    readonly form: Fields;
+    readonly classes: readonly string[];
+    readonly access: Access;
+}
+export declare const fieldsOf: (lines: readonly Said[], scope: string) => Fields;
+export declare const vocabOf: (lock: readonly Said[]) => {
+    offers: string;
+    keys: string;
+    region: string;
+    class: string;
+    access: string;
+    origin: string;
+    origins: string;
+    issuers: string;
+    unresolved: string;
+    unparsed: string;
+    unsupported: string;
+    collision: string;
+    scheme: string;
+    form: string;
+    carry: string;
+    anonymous: string;
+    unstated: string;
+    callable: string;
+    split: string;
+    pick: string;
+};
+export type Vocab = ReturnType<typeof vocabOf>;
+export declare const observedAt: (lock: readonly Said[], source: string, operation: string) => string;
+export declare const stepOf: (lines: readonly Said[], lock: readonly Said[], source: string, operation: string) => Call | Plan;
+export declare const planRead: (lines: readonly Said[], lock: readonly Said[], source: string, operation: string, place: string) => Call | Plan;
+export declare const planAct: (lines: readonly Said[], lock: readonly Said[], source: string, operation: string, place: string) => Call | Plan;

package/dist/src/core/read.js

@@ -0,0 +1,64 @@
+import { alphabet } from '@lapxo/topos/wire';
+import { valueOf } from "./lock.js";
+const said = (key, fields = {}) => ({ kind: 'said', key, fields });
+const membersOf = (line) => (line === undefined ? undefined : alphabet(line.value ?? '').members);
+export const fieldsOf = (lines, scope) => Object.fromEntries(lines.filter((l) => l.scope === scope && l.measure).map((l) => [l.measure, membersOf(l) ?? []]));
+export const vocabOf = (lock) => ((w) => ({
+    offers: w('offers'), keys: w('keys'), region: w('region'), class: w('class'), access: w('access'), origin: w('origin'), origins: w('origins'), issuers: w('issuers'), unresolved: w('unresolved'), unparsed: w('unparsed'), unsupported: w('unsupported'), collision: w('collision'),
+    scheme: w('scheme'), form: w('form'), carry: w('carry'), anonymous: w('anonymous'), unstated: w('unstated'), callable: w('callable'), split: w('split'), pick: w('pick'),
+}))((k) => valueOf(lock, `vocab/${k}`));
+/** Where a source is reached: the origin the person picked, or the one its document declares when it declares one; several and none picked is no call, and none is ever a default. */
+const originOf = (lines, v, source) => {
+    const at = fieldsOf(lines, `${v.region}/${source}`);
+    const picked = lines.find((l) => l.scope === `${v.pick}/${source}`)?.value;
+    if (picked !== undefined)
+        return picked;
+    const declared = at[v.origins] ?? [];
+    return declared.length === 1 ? declared[0] : said(declared.length ? 'pick-origin' : 'no-origin', { source, origins: declared.join(', ') });
+};
+export const observedAt = (lock, source, operation) => `${valueOf(lock, 'access/family')}/${source}/${operation}/${valueOf(lock, 'access/observed')}`;
+/** How access is proven for an offer: its first declared alternative that says how what it obtains rides a request — anonymous, or a scheme whose flow the one adapter runs, its own or its issuer's, kept once per issuer; none that says is no call, named. Unstated, it is a read with nothing attached: probed once, and anonymous once head observed it answer. */
+const accessOf = (lines, lock, v, source, operation, place) => {
+    const ways = fieldsOf(lines, `${v.offers}/${source}/${operation}`)[v.access] ?? [v.unstated];
+    const by = `${valueOf(lock, 'access/family')}/${source}/${valueOf(lock, 'access/authorizer')}`, account = (issuer) => valueOf(lock, issuer ? 'access/issuer-account' : 'access/account').split('{place}').join(place).split('{source}').join(source).split('{issuer}').join(issuer ?? '');
+    if (ways.includes(v.unstated) && lines.some((l) => l.scope === by))
+        return { kind: valueOf(lock, 'access/adapter'), scheme: valueOf(lock, 'access/authorizer'), params: fieldsOf(lines, by), flow: `${source}/${valueOf(lock, 'access/authorizer')}`, account: account(), from: by };
+    if (ways.includes(v.unstated))
+        return ((seen) => ({ kind: v.anonymous, scheme: '', params: {}, account: undefined, flow: '', ...(seen ? {} : { probe: true }) }))(lines.some((l) => l.scope === observedAt(lock, source, operation) && l.value === v.anonymous));
+    const kindOf = (way) => {
+        if (way === v.anonymous)
+            return [way, v.anonymous, {}, '', undefined];
+        const issuer = fieldsOf(lines, `${v.keys}/${source}/${way}`)['issuer']?.[0];
+        const flow = issuer ?? `${source}/${way}`;
+        const params = fieldsOf(lines, `${v.keys}/${flow}`);
+        return [way, params[v.scheme] ? valueOf(lock, 'access/adapter') : '', params, flow, issuer];
+    };
+    const kinds = ways.map(kindOf);
+    const usable = kinds.find(([, kind]) => kind !== '');
+    if (usable === undefined)
+        return said('no-adapter', { source, operation, kinds: ways.join(', ') });
+    const [scheme, kind, params, flow, issuer] = usable;
+    return { kind, scheme, params, flow, account: kind === v.anonymous ? undefined : account(issuer) };
+};
+export const stepOf = (lines, lock, source, operation) => {
+    const v = vocabOf(lock);
+    const offer = `${v.offers}/${source}/${operation}`;
+    const classes = fieldsOf(lines, offer)[v.class];
+    if (classes === undefined)
+        return said('unknown-operation', { source, operation });
+    const origin = originOf(lines, v, source);
+    return typeof origin !== 'string' ? origin : { kind: 'call', source, operation, origin, carry: fieldsOf(lines, `${offer}/${v.carry}`), form: fieldsOf(lines, `${offer}/${v.form}`), classes, access: { kind: v.anonymous, scheme: '', params: {}, account: undefined, flow: '' } };
+};
+/** The call an offer would make, from the place's lines alone, with the access it is proven by; or why there is none. An offer read two ways is never called. */
+const callOf = (lines, lock, source, operation, place) => {
+    const step = stepOf(lines, lock, source, operation);
+    if (step.kind === 'said')
+        return step;
+    if (step.classes.includes(vocabOf(lock).split))
+        return said('split-offer', { source, operation });
+    const access = accessOf(lines, lock, vocabOf(lock), source, operation, place);
+    return 'key' in access ? access : { ...step, access };
+};
+const isCallable = (lock, classes) => classes.length === 1 && classes[0] === vocabOf(lock).callable;
+export const planRead = (lines, lock, source, operation, place) => ((call) => (call.kind === 'call' && !isCallable(lock, call.classes) ? said('not-callable', { source, operation, class: call.classes.join(', ') }) : call))(callOf(lines, lock, source, operation, place));
+export const planAct = (lines, lock, source, operation, place) => ((call) => (call.kind === 'call' && isCallable(lock, call.classes) ? said('is-read', { source, operation }) : call.kind === 'call' && call.access.probe ? said('access-unstated', { source, operation }) : call))(callOf(lines, lock, source, operation, place));

package/dist/src/core/receipt.d.ts

@@ -0,0 +1,13 @@
+import type { Said } from './lock.ts';
+/** The scope a read is kept under: the source, the operation, and the first steps of the digest of the request and whom it was made as, so only the same request made as the same principal finds it again. The drafted receipt of one read names what was asked, the digest of what came back, and when; the device key signs it. */
+export declare const scopeOf: (family: string, api: string, operation: string, request: string, principal: string) => string;
+export declare const draftOf: (family: string, at: string, scope: string, digest: string, when: string) => string;
+/** What a typed answer stands on besides its body: the worlds the place uses and the code that interprets them, and what the source compiles to; what is kept under it holds only while these stand. */
+export declare const basisOf: (lines: readonly Said[], word: (scope: string) => string, source: string) => string;
+/** Head's own receipts under a scope, or under any scope below it, newest first: each once, by when it was made and what it names; a duplicate delivery is the same receipt. */
+export declare const receiptsOf: (lines: readonly Said[], at: string, scope: string, below?: boolean) => readonly {
+    readonly scope: string;
+    readonly at: string;
+    readonly digest: string;
+}[];
+export declare const spentOf: (lines: readonly Said[], family: string, at: string, api: string, now: number) => number;

package/dist/src/core/receipt.js

@@ -0,0 +1,12 @@
+import { createHash } from 'node:crypto';
+import { canonical } from '@lapxo/topos/wire';
+/** The scope a read is kept under: the source, the operation, and the first steps of the digest of the request and whom it was made as, so only the same request made as the same principal finds it again. The drafted receipt of one read names what was asked, the digest of what came back, and when; the device key signs it. */
+export const scopeOf = (family, api, operation, request, principal) => `${family}/${api}/${operation}/${createHash('sha256').update(`${request}\n${principal}`).digest('hex').slice(0, 16)}`;
+export const draftOf = (family, at, scope, digest, when) => canonical({ at: `${at}:${when}`, by: 'target', form: 'alphabet', measure: 'digest', role: 'writes', scope, value: digest });
+/** What a typed answer stands on besides its body: the worlds the place uses and the code that interprets them, and what the source compiles to; what is kept under it holds only while these stand. */
+export const basisOf = (lines, word, source) => createHash('sha256').update(lines.filter((l) => l.scope?.startsWith('uses/') || l.scope?.startsWith('dep/')
+    || l.scope === `${word('vocab/region')}/${source}` || [word('vocab/offers'), word('vocab/keys')].some((family) => l.scope?.startsWith(`${family}/${source}/`))).map((l) => canonical(l)).sort().join('\n')).digest('hex').slice(0, 16);
+/** Head's own receipts under a scope, or under any scope below it, newest first: each once, by when it was made and what it names; a duplicate delivery is the same receipt. */
+export const receiptsOf = (lines, at, scope, below = false) => [...new Map(lines.filter((l) => (l.scope === scope || (below && l.scope?.startsWith(`${scope}/`))) && l.measure === 'digest' && l.at?.startsWith(`${at}:`) && l.value?.startsWith('sha256:'))
+        .map((l) => [`${l.at} ${l.value}`, { scope: l.scope, at: l.at.slice(at.length + 1), digest: l.value }])).values()].sort((a, b) => (a.at < b.at ? 1 : a.at > b.at ? -1 : 0));
+export const spentOf = (lines, family, at, api, now) => lines.filter((l) => l.scope?.startsWith(`${family}/${api}/`) && l.at?.startsWith(`${at}:`) && now - Date.parse(l.at.slice(at.length + 1)) < 3_600_000).length;

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

@@ -0,0 +1,6 @@
+import type { Said } from './lock.ts';
+export declare const fill: (text: string, asked: Readonly<Record<string, string | undefined>>) => string;
+/** What head says: a cell, its code with its state and next; only a question the person reads is said in its lock words. */
+export declare const sayIn: (lock: readonly Said[]) => (key: string, fields?: Readonly<Record<string, string | undefined>>) => string;
+/** A red, when what head measured ran past a ceiling of its lock in whole seconds: said with the coordinate it ran at; within it, nothing. */
+export declare const redIn: (lock: readonly Said[]) => (scope: string, coordinate: string, started: number, now: number) => readonly string[];

package/dist/src/core/surface.js

@@ -0,0 +1,7 @@
+import { aboutOf, valueOf } from "./lock.js";
+import { cellLine, cellOf } from "../ports/surface.js";
+export const fill = (text, asked) => Object.entries(asked).reduce((at, [name, value]) => (value === undefined ? at : at.split(`{${name}}`).join(value)), text);
+/** What head says: a cell, its code with its state and next; only a question the person reads is said in its lock words. */
+export const sayIn = (lock) => (key, fields = {}) => (valueOf(lock, `said/${key}/state`) === 'asked' ? fill(aboutOf(lock, `said/${key}`), fields) : cellLine(cellOf(lock, key, fields)));
+/** A red, when what head measured ran past a ceiling of its lock in whole seconds: said with the coordinate it ran at; within it, nothing. */
+export const redIn = (lock) => (scope, coordinate, started, now) => ((seconds, ceiling) => (seconds > Number(ceiling.split('..')[1]) ? [sayIn(lock)('red', { coordinate, seconds: String(seconds), scope, ceiling })] : []))(Math.floor((now - started) / 1000), valueOf(lock, scope));

package/dist/src/core/trust.d.ts

@@ -0,0 +1,7 @@
+import type { Said } from './lock.ts';
+/**
+ * How a source proves access, the most trusted first: each flow by the least trusted kind of input it asks, in the order
+ * head's lock names — a flow that asks none of them asks no secret — and how many secrets the place's root lets a flow
+ * ask on head's page, none unless it signed a ceiling. A source that proves no access says nothing.
+ */
+export declare const trustOf: (lock: readonly Said[], lines: readonly Said[], source: string) => readonly string[];

package/dist/src/core/trust.js

@@ -0,0 +1,19 @@
+import { aboutOf, members, valueOf } from "./lock.js";
+import { vocabOf } from "./read.js";
+import { fill, sayIn } from "./surface.js";
+/**
+ * How a source proves access, the most trusted first: each flow by the least trusted kind of input it asks, in the order
+ * head's lock names — a flow that asks none of them asks no secret — and how many secrets the place's root lets a flow
+ * ask on head's page, none unless it signed a ceiling. A source that proves no access says nothing.
+ */
+export const trustOf = (lock, lines, source) => {
+    const [v, order, asks, root] = [vocabOf(lock), members(valueOf(lock, 'access/trust-order')), valueOf(lock, 'vocab/asks'), valueOf(lock, 'founding/root').split('/')[1]];
+    const flows = [...new Set(lines.flatMap((l) => ((parts) => (l.scope?.startsWith(`${v.keys}/${source}/`) && parts.length === v.keys.split('/').length + 2 ? [parts.at(-1)] : []))(l.scope?.split('/') ?? [])))];
+    if (!flows.length)
+        return [];
+    const kind = (flow) => ((asked) => order.find((k) => asked.includes(k)) ?? 'none')(members(lines.find((l) => l.scope === `${v.keys}/${source}/${flow}` && l.measure === asks)?.value ?? ''));
+    const rank = (k) => (k === 'none' ? 0 : order.length - order.indexOf(k));
+    const ranked = flows.map((flow) => ({ flow, kind: kind(flow) })).sort((a, b) => rank(a.kind) - rank(b.kind) || a.flow.localeCompare(b.flow));
+    const allowed = (lines.find((l) => l.scope === valueOf(lock, 'access/secrets') && l.by === root)?.value ?? '0..0').split('..')[1];
+    return [sayIn(lock)('trust', { source, flows: ranked.map((f) => fill(aboutOf(lock, `said/trust-${f.kind}`), { flow: f.flow })).join('; '), allowed: allowed ?? '0' })];
+};

package/dist/src/core/worlds.d.ts

@@ -0,0 +1,10 @@
+import type { Said } from './lock.ts';
+/** The facts bytes hold, in their order. */
+export declare const linesOf: (bytes: Uint8Array) => readonly Said[];
+/** Bytes named by their digest, under the algorithm the wire names: a pinned standing is exactly the bytes its pin hashes. */
+export declare const digestIn: (lock: readonly Said[]) => (bytes: Uint8Array | string) => string;
+/** A compiled standing as a place holds it: its pin, the digest of its bytes, and its lines; none when the place holds no such file. */
+export declare const pinnedOf: (lock: readonly Said[], bytes: Uint8Array | undefined) => {
+    readonly pin: string;
+    readonly lines: readonly Said[];
+} | undefined;

package/dist/src/core/worlds.js

@@ -0,0 +1,9 @@
+import { createHash } from 'node:crypto';
+import { parse } from '@lapxo/topos/wire';
+import { valueOf } from "./lock.js";
+/** The facts bytes hold, in their order. */
+export const linesOf = (bytes) => new TextDecoder().decode(bytes).split('\n').flatMap((line) => ((got) => (got.kind === 'fact' ? [got.value.fields] : []))(parse(line)));
+/** Bytes named by their digest, under the algorithm the wire names: a pinned standing is exactly the bytes its pin hashes. */
+export const digestIn = (lock) => (bytes) => ((algorithm) => `${algorithm}:${createHash(algorithm).update(bytes).digest('hex')}`)(valueOf(lock, 'wire/digest-algorithms'));
+/** A compiled standing as a place holds it: its pin, the digest of its bytes, and its lines; none when the place holds no such file. */
+export const pinnedOf = (lock, bytes) => (bytes === undefined ? undefined : { pin: digestIn(lock)(bytes), lines: linesOf(bytes) });

package/dist/src/flows/act.d.ts

@@ -0,0 +1,7 @@
+import type { Asked, Context } from '../core/answer.ts';
+/**
+ * One offer that is not of the class head reads: within a cap the person signed it is called as far as the cap goes;
+ * without one, each call asks the person once, and their yes is signed for exactly that request. The intent lands before
+ * the call, the receipt after; a call that never answered stays open until a look of what it would have changed closes it.
+ */
+export declare const act: (asked: Asked, context: Context) => Promise<readonly string[]>;

package/dist/src/flows/act.js

@@ -0,0 +1,43 @@
+import { actsOf, allowedOf, askedOf, cappedOf } from "../core/act.js";
+import { planAct } from "../core/read.js";
+import { draftOf } from "../core/receipt.js";
+import { sayIn } from "../core/surface.js";
+import { canonical } from '@lapxo/topos/wire';
+import { called } from "./call.js";
+/**
+ * One offer that is not of the class head reads: within a cap the person signed it is called as far as the cap goes;
+ * without one, each call asks the person once, and their yes is signed for exactly that request. The intent lands before
+ * the call, the receipt after; a call that never answered stays open until a look of what it would have changed closes it.
+ */
+export const act = (asked, context) => called(asked, context, planAct, async ({ word, say, lines, source, operation, prepared, typed, attach, send, lands, widen, uncovered }) => {
+    const [family, done] = [word('act/family'), word('act/done')];
+    const allowed = allowedOf(lines, word('allow/family'), source, operation);
+    const scope = `${family}/${source}/${operation}/${prepared.key.slice(0, 16)}`;
+    const acts = actsOf(lines, family, [done, word('act/closed')], source, operation, prepared.key);
+    if (acts.open)
+        return say('open', { source, operation, intent: scope });
+    const stopped = uncovered('head', [scope, `${scope}/${done}`]);
+    if (stopped)
+        return stopped;
+    const capped = cappedOf(lines, word('allow/family'), source, operation);
+    if (capped && acts.done >= allowed)
+        return say('not-allowed', { source, operation, allowed: String(allowed), done: String(acts.done) });
+    if (!capped || askedOf(lines, word('ask/family'), source, operation)) {
+        const yes = await widen(sayIn(context.lock)('elicit-act', { source, operation, call: prepared.describe }), [canonical({ at: 'policy:person/allows', by: 'target', form: 'alphabet', measure: 'status', role: 'writes', scope: `${word('allow/family')}/${source}/${operation}/${prepared.key.slice(0, 16)}`, value: 'present' })]);
+        if ('said' in yes)
+            return yes.said;
+    }
+    const attached = await attach();
+    if ('said' in attached)
+        return attached.said;
+    const when = () => new Date(context.now()).toISOString();
+    const intended = await lands(canonical({ at: `${word('receipt/at')}:${when()}`, by: 'target', form: 'alphabet', measure: 'status', role: 'writes', scope, value: 'present' }));
+    if ('refused' in intended)
+        return say('not-landed', { why: intended.refused });
+    const got = await send(attached.attachment);
+    if (got.kind !== 'got')
+        return say('act-failed', { source, operation, intent: scope });
+    const landed = await lands(draftOf(family, word('receipt/at'), `${scope}/${done}`, context.cache.keep(Buffer.concat([Buffer.from(`${got.status}\n`), got.bytes])), when()));
+    const answer = await typed(String(got.status), got.bytes);
+    return 'refused' in landed ? [...answer, ...say('not-landed', { why: landed.refused })] : [...answer, ...intended.lines, ...landed.lines];
+});

package/dist/src/flows/answer.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '../core/answer.ts';
+import type { Said } from '../core/lock.ts';
+/**
+ * What a source answered, as the world types it: the body is laid in the place's answers for as long as bound reads it,
+ * then taken away, and only the lines the world answers for this request come back — a value of each declared field, the
+ * counts, what it held back. A place that names no view to type it gets no answer at all, never the body.
+ */
+export declare const typedAnswer: (context: Context, place: string, lines: readonly Said[], source: string, operation: string, key: string, body: Uint8Array) => Promise<{
+    readonly lines: readonly string[];
+} | {
+    readonly untyped: string;
+}>;

package/dist/src/flows/answer.js

@@ -0,0 +1,25 @@
+import { canonical } from '@lapxo/topos/wire';
+import { valueOf } from "../core/lock.js";
+/**
+ * What a source answered, as the world types it: the body is laid in the place's answers for as long as bound reads it,
+ * then taken away, and only the lines the world answers for this request come back — a value of each declared field, the
+ * counts, what it held back. A place that names no view to type it gets no answer at all, never the body.
+ */
+export const typedAnswer = async (context, place, lines, source, operation, key, body) => {
+    const view = valueOf(context.lock, 'place/answer');
+    if (!lines.some((line) => line.scope === `view/${view}`))
+        return { untyped: '' };
+    const [request, family] = [key.slice(0, 16), valueOf(context.lock, 'vocab/answer')];
+    const at = `${valueOf(context.lock, 'place/answers')}/${source}/${encodeURIComponent(operation).replaceAll('.', '%2E')}/${request}.json`;
+    context.files.lay(place, at, body);
+    try {
+        const got = await context.world(place, view);
+        if ('refused' in got)
+            return { untyped: got.refused };
+        const mine = got.lines.filter((line) => line.scope === `${family}/${request}` || line.scope?.startsWith(`${family}/${request}/`));
+        return mine.length ? { lines: mine.map((line) => canonical(line)).sort() } : { untyped: '' };
+    }
+    finally {
+        context.files.drop(place, at);
+    }
+};

package/dist/src/flows/call.d.ts

@@ -0,0 +1,50 @@
+import type { Asked, Context, Outcome } from '../core/answer.ts';
+import type { Said } from '../core/lock.ts';
+import type { Call, Plan } from '../core/read.ts';
+import type { Attachment } from '../access/contract.ts';
+import type { Fetched, Prepared } from '../ports/adapters/request.ts';
+/**
+ * The origin of a source a person picks once for a place, when its document declares several: offered as a choice among
+ * them, none a default, and kept as the person's line; the lines a call stands on, with it.
+ */
+export declare const pickedOrigin: (context: Context, place: string, lines: readonly Said[], source: string, plan: Call | Plan) => Promise<{
+    readonly lines: readonly Said[];
+} | {
+    readonly said: readonly string[];
+}>;
+/** Calls of one place take turns, so one asked while another lands sees its receipt; nothing waits on a timer. */
+export declare const inTurn: <T>(place: string, act: () => Promise<T>) => Promise<T>;
+export interface Frame {
+    readonly say: (key: string, fields?: Readonly<Record<string, string | undefined>>) => readonly string[];
+    readonly lands: (...lot: readonly string[]) => Promise<Outcome>;
+    readonly most: (scope: string) => number;
+    readonly place: string;
+    readonly lines: readonly Said[];
+    readonly source: string;
+    readonly operation: string;
+    readonly plan: Call;
+    readonly prepared: Extract<Prepared, {
+        key: string;
+    }>;
+    readonly widen: (message: string, lot: readonly string[]) => Promise<{
+        readonly lines: readonly string[];
+    } | {
+        readonly said: readonly string[];
+    }>;
+    readonly word: (scope: string) => string;
+    readonly typed: (status: string, bytes: Uint8Array) => Promise<readonly string[]>;
+    readonly attach: () => Promise<{
+        readonly attachment: Attachment | undefined;
+        readonly principal: string | undefined;
+    } | {
+        readonly said: readonly string[];
+    }>;
+    readonly send: (attachment: Attachment | undefined) => Promise<Fetched>;
+    readonly uncovered: (role: string, scopes: readonly string[]) => readonly string[] | undefined;
+}
+/**
+ * The steps a read and an act share: the place, its turn, the lines it stands on once bound settled them, the offer's
+ * plan, the transport its origin names and the request it prepares; then what is particular, given a frame that says
+ * by the lock, attaches access when asked, types what came back and lands a line under head's key.
+ */
+export declare const called: (asked: Asked, context: Context, planOf: (lines: readonly Said[], lock: readonly Said[], source: string, operation: string, place: string) => Call | Plan, then: (frame: Frame) => Promise<readonly string[]>) => Promise<readonly string[]>;

package/dist/src/flows/call.js

@@ -0,0 +1,76 @@
+import { inPlace, placeNameOf, unless } from "../core/answer.js";
+import { fieldsOf, vocabOf } from "../core/read.js";
+import { canonical } from '@lapxo/topos/wire';
+import { sayIn } from "../core/surface.js";
+import { valueOf } from "../core/lock.js";
+import { uncoveredIn } from "../core/device.js";
+import { widening } from "./device.js";
+import { attachmentFor } from "../access/obtain.js";
+import { typedAnswer } from "./answer.js";
+import { standingFor } from "./world.js";
+/**
+ * The origin of a source a person picks once for a place, when its document declares several: offered as a choice among
+ * them, none a default, and kept as the person's line; the lines a call stands on, with it.
+ */
+export const pickedOrigin = async (context, place, lines, source, plan) => {
+    if (plan.kind !== 'said' || plan.key !== 'pick-origin')
+        return { lines };
+    const v = vocabOf(context.lock);
+    const origins = fieldsOf(lines, `${v.region}/${source}`)[v.origins] ?? [];
+    const line = (value) => ({ at: 'policy:person/picks', by: 'target', form: 'alphabet', measure: 'id', role: 'writes', scope: `${v.pick}/${source}`, value });
+    const by = widening(context, place, lines, origins.map((o) => canonical(line(o))));
+    if ('said' in by)
+        return { said: by.said };
+    const chosen = (await context.person.choose(sayIn(context.lock)('pick', { source }), [{ name: v.origin, options: origins.map((o) => ({ value: o, label: o })) }]))?.[v.origin];
+    if (chosen === undefined || !origins.includes(chosen))
+        return { said: [sayIn(context.lock)(plan.key, plan.fields)] };
+    const landed = await by.land([canonical(line(chosen))]);
+    return 'refused' in landed ? { said: [sayIn(context.lock)('not-landed', { why: landed.refused })] } : { lines: [...lines, line(chosen)] };
+};
+const turns = new Map();
+/** Calls of one place take turns, so one asked while another lands sees its receipt; nothing waits on a timer. */
+export const inTurn = (place, act) => { const next = (turns.get(place) ?? Promise.resolve()).then(act, act); turns.set(place, next.catch(() => undefined)); return next; };
+/**
+ * The steps a read and an act share: the place, its turn, the lines it stands on once bound settled them, the offer's
+ * plan, the transport its origin names and the request it prepares; then what is particular, given a frame that says
+ * by the lock, attaches access when asked, types what came back and lands a line under head's key.
+ */
+export const called = async (asked, context, planOf, then) => {
+    const say = (key, fields = {}) => [sayIn(context.lock)(key, fields)];
+    const [source, operation] = [asked['source'] ?? '', asked['operation'] ?? ''];
+    return inPlace(asked, context, (place) => inTurn(place, async () => {
+        const held = await standingFor(context, place);
+        if ('unsettled' in held)
+            return say('unsettled', { source, why: held.unsettled });
+        const widen = async (message, lot) => {
+            const by = widening(context, place, held.lines, lot);
+            if ('said' in by)
+                return { said: by.said };
+            const refused = await unless(context, message);
+            if (refused)
+                return { said: refused };
+            const landed = await by.land(lot);
+            return 'refused' in landed ? { said: say('not-landed', { why: landed.refused }) } : { lines: landed.lines };
+        };
+        const picked = await pickedOrigin(context, place, held.lines, source, planOf(held.lines, context.lock, source, operation, placeNameOf(place)));
+        if ('said' in picked)
+            return picked.said;
+        const lines = picked.lines;
+        const plan = planOf(lines, context.lock, source, operation, placeNameOf(place));
+        if (plan.kind === 'said')
+            return say(plan.key, plan.fields);
+        const prepared = ((transport) => transport?.prepare(plan, JSON.parse(asked['args'] || '{}'), context.lock))(await context.adapter(plan.origin));
+        if (prepared === undefined)
+            return say('no-transport', { source, origin: plan.origin });
+        if ('missing' in prepared)
+            return say('missing-param', { operation, param: prepared.missing });
+        if ('refused' in prepared)
+            return say(prepared.refused, { source, origin: plan.origin });
+        const most = (scope) => Number((lines.find((l) => l.scope === scope)?.value ?? '0..0').split('..')[1]);
+        const typed = async (status, bytes) => ((got) => ['lines' in got ? say('answered', { source, operation, status })[0] : say('untyped', { source, operation, status, why: got.untyped })[0], ...('lines' in got ? got.lines : [])])(await typedAnswer(context, place, lines, source, operation, prepared.key, bytes));
+        const lands = (...lot) => context.landAs(place, lot, 'head', lines);
+        const attach = async () => ((got) => ('said' in got ? { said: say(got.said, { source, operation, kinds: plan.access.kind, input: got.input }) } : got))(await attachmentFor(context, place, lines, plan));
+        const uncovered = (role, scopes) => uncoveredIn(context.lock, lines, context.device(role), place, [], scopes);
+        return then({ widen, word: (scope) => valueOf(context.lock, scope), say, place, lines, source, operation, plan, prepared, most, typed, attach, send: (attachment) => prepared.send(attachment, most('read/response-bytes')), lands, uncovered });
+    }));
+};

package/dist/src/flows/device.d.ts

@@ -0,0 +1,26 @@
+import type { Context, Outcome } from '../core/answer.ts';
+import type { Said } from '../core/lock.ts';
+/** A key of this device by its role: read from the keychain, or made there once; only its public half is ever handed on. */
+export declare const deviceKey: (context: Context, role?: string) => string | undefined;
+/** The keychain account of a place's root, when this keychain holds it — who configures the place is here; else what head says of that. */
+export declare const rootIn: (context: Context, place: string) => {
+    readonly account: string;
+} | {
+    readonly said: readonly string[];
+};
+/**
+ * Who signs a widening of a place: its root, when this keychain holds it and the place admits this device's person to
+ * witness it — the line is then the place's own policy, in its lock, binding every device it admits, and names as its
+ * witness the person who said yes, by the key the place knows them by; else this device's person key, when the place
+ * admits it for every line — an attestation only this device reads, once per scope and measure the place does not state,
+ * since a second needs a fold bound does not publish; else no one here, and the lines are handed on. A place that pins a
+ * lock as its parent has nothing signed here: what the parent would cut is bound's to judge.
+ */
+type By = {
+    readonly sign: (lot: readonly string[]) => Promise<Outcome>;
+    readonly land: (lot: readonly string[]) => Promise<Outcome>;
+};
+export declare const widening: (context: Context, place: string, lines: readonly Said[], lot: readonly string[]) => By | {
+    readonly said: readonly string[];
+};
+export {};