@lapxo/bound 0.2.4 → 0.2.5

package/dist/fold/kept.js

@@ -1,173 +1,12 @@
-import { encodeUTF8 } from "../host/io.js";
-import { actLines, committedLocalActs } from "../host/ports/local-act.js";
-import { readOnly } from "../host/read-only.js";
-import { createHash, dirname, existsSync, join, mkdirSync, readdirSync, renameSync, writeFileSync } from "../host/io.js";
-import { bytesDigest, coordinateDigest } from "./digests.js";
-import { viewsOf } from "./views.js";
-import { landMemo, ledgerLines, ledgerWriters, memoAt, shardFile, writerFile } from "../land/ledger.js";
-import { coordinatesUnder, observeFile, observeText } from "../observe/files.js";
-import { EXTENSION, fieldOf } from "./claims.js";
-import { keyFor, keyOf, lockSigners } from "./keys.js";
-import { sourceOf, vouching } from "../land/vouched.js";
-import { wordsOf } from "./wire.js";
-import { ownLock } from "../observe/runner.js";
-const text = encodeUTF8;
-const atOf = (line) => {
-    if (line.includes(' about='))
-        return fieldOf(line, 'at');
-    const from = line.indexOf(' at=') + ' at='.length;
-    return line.slice(from, line.indexOf(' ', from));
-};
-export function foldPoints(store, standing, under, keeper, instrument = '', observed = [], root = dirname(store), answered, reads) {
-    const said = new Map();
-    for (const line of answered === undefined ? observed : []) {
-        if (line.includes(' measure=observed '))
-            continue;
-        const key = `${fieldOf(line, 'by').split(':')[1] ?? ''} ${atOf(line)}`;
-        (said.get(key) ?? said.set(key, []).get(key)).push(line);
-    }
-    const coordinates = observed
-        .filter((line) => line.includes(' measure=observed ') && atOf(line).startsWith('place:') && (!under || fieldOf(line, 'scope').startsWith(under)))
-        .map((line) => ((key) => `${fieldOf(line, 'scope')} ${atOf(line)} ${answered?.get(key) ?? saidDigest(store, said.get(key) ?? [])}`)(`${fieldOf(line, 'by').split(':')[1] ?? ''} ${atOf(line)}`));
-    const signers = new Set(reads ? lockSigners(store) : []);
-    const tree = reads ? vouching(standing) : undefined;
-    const digestOf = (lines) => bytesDigest(store, text(lines.join('\n')));
-    const narrowed = reads === undefined ? [] : [
-        `lock ${digestOf([...reads.owned].sort())}`,
-        `judge ${digestOf(ledgerLines(store, 'judge').filter((line) => reads.scopes.has(fieldOf(line, 'scope'))))}`,
-        `take ${digestOf(ledgerLines(store, 'take').filter((line) => reads.scopes.has(fieldOf(line, 'scope').replace(/^take\//, ''))))}`,
-        `tree ${digestOf(ledgerLines(store, tree ?? '').filter((line) => (sourceOf(line) ?? '').startsWith(reads.place)))}`,
-    ];
-    const heads = ledgerWriters(store)
-        .filter((writer) => writer !== keeper && writer !== 'gate' && !writer.startsWith('reader') && !(reads && (signers.has(writer) || writer === 'judge' || writer === 'take' || writer === tree)))
-        .map((writer) => `${writer} ${writer === liveWriter(store, standing) ? lastWord(store, writer) : bytesDigest(store, text(ledgerLines(store, writer).join('\n')))}`);
-    const written = [...new Set([...viewsOf(standing).values()].flatMap((view) => ('regions' in view && view.shape ? [view.shape] : [])))].sort()
-        .map((shape) => `written ${shape} ${coordinateDigest(store, join(root, under ?? '', shape)) ?? 'absent'}`);
-    const lined = ownLock().filter((line) => fieldOf(line, 'scope').startsWith('region/') && fieldOf(line, 'measure') === 'lines' && fieldOf(line, 'value') !== 'withdraw')
-        .flatMap((line) => fieldOf(line, 'value').split('|').filter(Boolean)).sort().map((coordinate) => `lines ${coordinate} ${coordinateDigest(store, join(root, under ?? '', coordinate)) ?? 'absent'}`);
-    return [
-        `place ${under ?? '.'}`,
-        `instrument ${instrument}`,
-        `reading context ${readingContext(store)}`,
-        ...written,
-        ...lined,
-        ...[...new Set(coordinates)].sort(),
-        ...heads.sort(),
-        ...narrowed,
-        `lines ${bytesDigest(store, text([...standing].sort().join('\n')))}`,
-        ...(existsSync(join(store, 'cas', 'receipts')) ? readdirSync(join(store, 'cas', 'receipts')).sort() : []),
-    ];
-}
-/**
- * What a reader said at one digest, as one digest: every point of a fold that stands for an answer is this. The writer
- * whose class the lock names live is judged when read, so a fold keeps what it said — which lines it found standing and
- * which ledger it folded — and not when.
- */
-export const saidDigest = (store, lines) => bytesDigest(store, text([...new Set(lines
-        .filter((line) => !line.includes(' measure=observed ') && !line.includes(' scope=cost/'))
-        .map((line) => `${fieldOf(line, 'scope')} ${fieldOf(line, 'measure')} ${fieldOf(line, 'value')}`))].sort().join('\n')));
-function liveWriter(store, standing) {
-    if (!wordsOf(standing, 'live').includes('attest'))
-        return undefined;
-    try {
-        return keyFor(store, 'attest');
-    }
-    catch {
-        return undefined;
-    }
-}
-const lastWord = (store, writer) => ((last) => `${fieldOf(last, 'at')} ${fieldOf(last, 'restsOn')} ${fieldOf(last, 'value')}`)(ledgerLines(store, writer).filter((line) => fieldOf(line, 'scope') === `${writer}/target`).at(-1) ?? '');
-export function movedPoints(store, now, key) {
-    const last = observeText(memoAt(store, lastOf(now)))?.trim();
-    const held = last === undefined || last === key ? undefined : observeText(memoAt(store, `fold/${last}`));
-    if (held === undefined)
-        return undefined;
-    const was = new Set((JSON.parse(held).points ?? []));
-    const has = new Set(now);
-    return { gone: [...was].filter((one) => !has.has(one)), came: now.filter((one) => !was.has(one)) };
-}
-const lastOf = (points) => `last/${createHash('sha256').update(points[0] ?? '').digest('hex')}`;
-/**
- * A fold is kept under its key and a view's text under the key and the view's name, in the store's memos: the first to
- * keep a key keeps it, since one point set folds into one set of bytes, and a fold kept by another instrument is
- * another origin's, readable as history and never as this instrument's own state.
- */
-const elsewhere = { folds: 0 };
-export const foldsElsewhere = () => elsewhere.folds;
-const joined = (lines) => lines.join('\n');
-const split = (text) => (text === '' ? [] : text.split('\n'));
-const linesOf = (value) => value === undefined ? [] : typeof value === 'string' ? split(value) : value;
-/** Operational reader history guards file-fold reuse, never cell-region identity. */
-function readingContext(store) {
-    const speaker = keyOf(store, 'read');
-    const files = speaker === undefined ? [] : [writerFile(store, speaker), ...coordinatesUnder(dirname(shardFile(store, speaker, '')), store)
-            .filter(file => file.endsWith(EXTENSION)).map(file => join(store, file))];
-    const segments = speaker === undefined ? [] : committedLocalActs(store).flatMap(act => act.bundle.placements?.flatMap(placement => {
-        const records = actLines(placement.records).filter(line => fieldOf(line, 'by') === speaker);
-        return records.length ? [placement.place + '\n' + records.join('\n')] : [];
-    }) ?? []);
-    return bytesDigest(store, text([...files.filter(file => existsSync(file)).sort()
-            .map(file => bytesDigest(store, observeFile(file) ?? new Uint8Array())), ...segments].join('\n')));
-}
-/** A new judgment changes the result even when the files and reader history do not. */
-function judgmentContext(store, demands) {
-    const scopes = new Set(demands.map(line => fieldOf(line, 'scope')));
-    return bytesDigest(store, text(ledgerLines(store, 'judge')
-        .filter(line => scopes.has(fieldOf(line, 'scope'))).join('\n')));
-}
-export function keptPlace(store, under, currentInstrument) {
-    const key = observeText(memoAt(store, lastOf([`place ${under ?? '.'}`])))?.trim();
-    if (key === undefined || key === '')
-        return undefined;
-    const held = observeText(memoAt(store, `fold/${key}`));
-    if (held === undefined)
-        return undefined;
-    const blob = JSON.parse(held);
-    if (blob.readingContext !== readingContext(store))
-        return undefined;
-    const fold = blob.fold;
-    if (currentInstrument !== undefined && fold.instrument !== currentInstrument)
-        return undefined;
-    if (blob.judgmentContext !== judgmentContext(store, linesOf(fold.demands)))
-        return undefined;
-    return {
-        ...fold,
-        standing: linesOf(fold.standing),
-        observed: linesOf(fold.observed),
-        grey: linesOf(fold.grey),
-        refused: linesOf(fold.refused),
-        demands: linesOf(fold.demands),
-        paid: linesOf(fold.paid),
-        missing: linesOf(fold.missing),
-        history: linesOf(fold.history),
-        orphans: linesOf(fold.orphans),
-        signed: new Map(fold.signed),
-        kept: true,
-    };
-}
-export const keptRender = (store, key, name) => observeText(memoAt(store, `render/${key}/${name}`));
-export const keepRender = (store, _signer, key, name, _epoch, text_) => { if (!readOnly())
-    landMemo(store, `render/${key}/${name}`, text(text_)); };
-export function keepFold(store, key, fold, points, instrument = '') {
-    if (readOnly())
-        return;
-    const packed = {
-        ...fold,
-        standing: joined(fold.standing),
-        observed: joined(fold.observed),
-        grey: joined(fold.grey),
-        refused: joined(fold.refused),
-        demands: joined(fold.demands),
-        paid: joined(fold.paid),
-        missing: joined(fold.missing),
-        history: joined(fold.history),
-        orphans: joined(fold.orphans),
-        signed: [...fold.signed],
-        kept: false,
-    };
-    landMemo(store, `fold/${key}`, text(JSON.stringify({ fold: packed, points, instrument, readingContext: readingContext(store), judgmentContext: judgmentContext(store, fold.demands) })));
-    const at = memoAt(store, lastOf(points));
-    mkdirSync(dirname(at), { recursive: true });
-    writeFileSync(`${at}.${process.pid}.part`, `${key}\n`);
-    renameSync(`${at}.${process.pid}.part`, at);
-}
+var U=Object.defineProperty;var a=(e,s)=>U(e,"name",{value:s,configurable:!0});import{encodeUTF8 as R}from"../host/io.js";import{actLines as _,committedLocalActs as B}from"../host/ports/local-act.js";import{readOnly as F}from"../host/read-only.js";import{createHash as H,dirname as S,existsSync as M,join as x,mkdirSync as X,readdirSync as q,renameSync as z,writeFileSync as G}from"../host/io.js";import{bytesDigest as g,coordinateDigest as C}from"./digests.js";import{viewsOf as I}from"./views.js";import{landMemo as N,ledgerLines as h,ledgerWriters as K,memoAt as y,shardFile as Q,writerFile as V}from"../land/ledger.js";import{coordinatesUnder as Y,observeFile as Z,observeText as b}from"../observe/files.js";import{EXTENSION as ee,fieldOf as r}from"./claims.js";import{keyFor as ne,keyOf as te,lockSigners as se}from"./keys.js";import{sourceOf as ie,vouching as re}from"../land/vouched.js";import{wordsOf as oe}from"./wire.js";import{ownLock as de}from"../observe/runner.js";const l=R,j=a(e=>{if(e.includes(" about="))return r(e,"at");const s=e.indexOf(" at=")+4;return e.slice(s,e.indexOf(" ",s))},"atOf");function We(e,s,t,o,d="",c=[],i=S(e),u,m){const O=new Map;for(const n of u===void 0?c:[]){if(n.includes(" measure=observed "))continue;const $=`${r(n,"by").split(":")[1]??""} ${j(n)}`;(O.get($)??O.set($,[]).get($)).push(n)}const A=c.filter(n=>n.includes(" measure=observed ")&&j(n).startsWith("place:")&&(!t||r(n,"scope").startsWith(t))).map(n=>($=>`${r(n,"scope")} ${j(n)} ${u?.get($)??ae(e,O.get($)??[])}`)(`${r(n,"by").split(":")[1]??""} ${j(n)}`)),D=new Set(m?se(e):[]),W=m?re(s):void 0,k=a(n=>g(e,l(n.join(`
+`))),"digestOf"),E=m===void 0?[]:[`lock ${k([...m.owned].sort())}`,`judge ${k(h(e,"judge").filter(n=>m.scopes.has(r(n,"scope"))))}`,`take ${k(h(e,"take").filter(n=>m.scopes.has(r(n,"scope").replace(/^take\//,""))))}`,`tree ${k(h(e,W??"").filter(n=>(ie(n)??"").startsWith(m.place)))}`],J=K(e).filter(n=>n!==o&&n!=="gate"&&!n.startsWith("reader")&&!(m&&(D.has(n)||n==="judge"||n==="take"||n===W))).map(n=>`${n} ${n===ce(e,s)?fe(e,n):g(e,l(h(e,n).join(`
+`)))}`),P=[...new Set([...I(s).values()].flatMap(n=>"regions"in n&&n.shape?[n.shape]:[]))].sort().map(n=>`written ${n} ${C(e,x(i,t??"",n))??"absent"}`),T=de().filter(n=>r(n,"scope").startsWith("region/")&&r(n,"measure")==="lines"&&r(n,"value")!=="withdraw").flatMap(n=>r(n,"value").split("|").filter(Boolean)).sort().map(n=>`lines ${n} ${C(e,x(i,t??"",n))??"absent"}`);return[`place ${t??"."}`,`instrument ${d}`,`reading context ${w(e)}`,...P,...T,...[...new Set(A)].sort(),...J.sort(),...E,`lines ${g(e,l([...s].sort().join(`
+`)))}`,...M(x(e,"cas","receipts"))?q(x(e,"cas","receipts")).sort():[]]}a(We,"foldPoints");const ae=a((e,s)=>g(e,l([...new Set(s.filter(t=>!t.includes(" measure=observed ")&&!t.includes(" scope=cost/")).map(t=>`${r(t,"scope")} ${r(t,"measure")} ${r(t,"value")}`))].sort().join(`
+`))),"saidDigest");function ce(e,s){if(oe(s,"live").includes("attest"))try{return ne(e,"attest")}catch{return}}a(ce,"liveWriter");const fe=a((e,s)=>(t=>`${r(t,"at")} ${r(t,"restsOn")} ${r(t,"value")}`)(h(e,s).filter(t=>r(t,"scope")===`${s}/target`).at(-1)??""),"lastWord");function Fe(e,s,t){const o=b(y(e,v(s)))?.trim(),d=o===void 0||o===t?void 0:b(y(e,`fold/${o}`));if(d===void 0)return;const c=new Set(JSON.parse(d).points??[]),i=new Set(s);return{gone:[...c].filter(u=>!i.has(u)),came:s.filter(u=>!c.has(u))}}a(Fe,"movedPoints");const v=a(e=>`last/${H("sha256").update(e[0]??"").digest("hex")}`,"lastOf"),pe={folds:0},Me=a(()=>pe.folds,"foldsElsewhere"),p=a(e=>e.join(`
+`),"joined"),ue=a(e=>e===""?[]:e.split(`
+`),"split"),f=a(e=>e===void 0?[]:typeof e=="string"?ue(e):e,"linesOf");function w(e){const s=te(e,"read"),t=s===void 0?[]:[V(e,s),...Y(S(Q(e,s,"")),e).filter(d=>d.endsWith(ee)).map(d=>x(e,d))],o=s===void 0?[]:B(e).flatMap(d=>d.bundle.placements?.flatMap(c=>{const i=_(c.records).filter(u=>r(u,"by")===s);return i.length?[c.place+`
+`+i.join(`
+`)]:[]})??[]);return g(e,l([...t.filter(d=>M(d)).sort().map(d=>g(e,Z(d)??new Uint8Array)),...o].join(`
+`)))}a(w,"readingContext");function L(e,s){const t=new Set(s.map(o=>r(o,"scope")));return g(e,l(h(e,"judge").filter(o=>t.has(r(o,"scope"))).join(`
+`)))}a(L,"judgmentContext");function Ce(e,s,t){const o=b(y(e,v([`place ${s??"."}`])))?.trim();if(o===void 0||o==="")return;const d=b(y(e,`fold/${o}`));if(d===void 0)return;const c=JSON.parse(d);if(c.readingContext!==w(e))return;const i=c.fold;if(!(t!==void 0&&i.instrument!==t)&&c.judgmentContext===L(e,f(i.demands)))return{...i,standing:f(i.standing),observed:f(i.observed),grey:f(i.grey),refused:f(i.refused),demands:f(i.demands),paid:f(i.paid),missing:f(i.missing),history:f(i.history),orphans:f(i.orphans),signed:new Map(i.signed),kept:!0}}a(Ce,"keptPlace");const Ne=a((e,s,t)=>b(y(e,`render/${s}/${t}`)),"keptRender"),Le=a((e,s,t,o,d,c)=>{F()||N(e,`render/${t}/${o}`,l(c))},"keepRender");function Ae(e,s,t,o,d=""){if(F())return;const c={...t,standing:p(t.standing),observed:p(t.observed),grey:p(t.grey),refused:p(t.refused),demands:p(t.demands),paid:p(t.paid),missing:p(t.missing),history:p(t.history),orphans:p(t.orphans),signed:[...t.signed],kept:!1};N(e,`fold/${s}`,l(JSON.stringify({fold:c,points:o,instrument:d,readingContext:w(e),judgmentContext:L(e,t.demands)})));const i=y(e,v(o));X(S(i),{recursive:!0}),G(`${i}.${process.pid}.part`,`${s}
+`),z(`${i}.${process.pid}.part`,i)}a(Ae,"keepFold");export{We as foldPoints,Me as foldsElsewhere,Ae as keepFold,Le as keepRender,Ce as keptPlace,Ne as keptRender,Fe as movedPoints,ae as saidDigest};

package/dist/fold/keys.js

@@ -1,91 +1,3 @@
-import { dirname, existsSync, join } from "../host/io.js";
-import { ledgerLines, ledgerWriters, signedLines } from "../land/ledger.js";
-import { fieldOf, foldClaims, isWire, LOCK, selfName } from "./claims.js";
-import { observeText } from "../observe/files.js";
-import { publicLock } from '@lapxo/topos/wire';
-const held = new Map();
-const keyInputs = new Map();
-const merged = new Map();
-/**
- * Whose lines carry a class of writing, as the lock says it. Every ledger the store keeps is read, the key claims
- * folded, and the class answered with the id the lock admitted first for it: no module here holds a signer's name, so
- * the day another head runs the same work its lines come out under its own name without a letter changing.
- */
-export const keyOf = (store, kind, told = []) => keysOf(store, told).classes.get(kind)?.[0];
-export function keyFor(store, kind, told = []) {
-    const id = keyOf(store, kind, told);
-    if (id === undefined) {
-        throw new Error(`${selfName()}: REFUSE·keys the lock admits no key of class \`${kind}\`: name one as \`keys/<id> measure=class value=${kind}\``);
-    }
-    return id;
-}
-export function lockSigners(store, told = []) {
-    const keys = keysOf(store, told);
-    const attests = new Set(keys.classes.get('attest') ?? []);
-    return keys.signers.filter((id) => !attests.has(id));
-}
-export function lockLines(store) {
-    const release = releaseOf(store);
-    if (release)
-        return release;
-    const parts = lockSigners(store).map((id) => ledgerLines(store, id)).filter((part) => part.length > 0);
-    const last = merged.get(store);
-    if (last !== undefined && last.parts.length === parts.length && last.parts.every((part, i) => part === parts[i]))
-        return last.lines;
-    const lines = parts.length === 1 ? parts[0] : parts.flat();
-    merged.set(store, { parts, lines });
-    return lines;
-}
-const standings = new WeakMap();
-/** What stands of the lock, folded once per landing of any of its ledgers: lockLines is the bytes, lockSigners the ids that write them, signedLockLines the same lines still carrying their signatures. */
-export function lockStanding(store) {
-    const lines = lockLines(store);
-    return standings.get(lines) ?? standings.set(lines, foldClaims(signedLockLines(store)).standing).get(lines);
-}
-export function signedLockLines(store, told = []) {
-    const release = releaseOf(store);
-    if (release)
-        return [...release];
-    return lockSigners(store, told).flatMap((id) => signedLines(store, id));
-}
-function keysOf(store, told) {
-    const input = ledgerKeyLines(store).join('\n');
-    const mine = told.length ? read(store, told) : keyInputs.get(store) === input ? held.get(store) ?? read(store) : read(store);
-    if (!told.length)
-        keyInputs.set(store, input);
-    if (!told.length)
-        held.set(store, mine);
-    return mine;
-}
-const ledgerKeyLines = (store) => ledgerWriters(store).flatMap(writer => ledgerLines(store, writer))
-    .filter((line) => /\bsig=/.test(line) && /(?:^|\s)scope=keys\/[^/\s]+\s/.test(line));
-const releases = new Map();
-/**
- * A release's lock, where the store signs no key of its own: the lock as it was laid is the place's only lines, read
- * and never written. What it says is true where a pin names the release; no ledger is made of it.
- */
-export function releaseOf(store) {
-    if (releases.has(store))
-        return releases.get(store);
-    const at = join(dirname(store), LOCK);
-    const lines = ledgerKeyLines(store).length || !existsSync(at) ? [] : (observeText(at) ?? '').split('\n').filter(isWire);
-    const published = lines.some(line => fieldOf(line, 'scope').startsWith('keys/') && fieldOf(line, 'measure') === 'public-key' && fieldOf(line, 'sig'))
-        && publicLock(lines) !== undefined;
-    const got = published || lines.some((line) => fieldOf(line, 'scope') === 'publish/bootstrap' && fieldOf(line, 'value') !== 'withdraw') ? lines : undefined;
-    releases.set(store, got);
-    return got;
-}
-function read(store, told = []) {
-    const release = releaseOf(store) ?? [], published = publicLock(release) === undefined ? [] : release;
-    const said = [...ledgerKeyLines(store), ...release, ...told]
-        .filter((line) => (/\bsig=/.test(line) || published.includes(line)) && /(?:^|\s)scope=keys\/[^/\s]+\s/.test(line));
-    const standing = foldClaims(said).standing.filter((line) => fieldOf(line, 'value') !== 'withdraw')
-        .sort((a, b) => (Number(fieldOf(a, 'epoch')) || 0) - (Number(fieldOf(b, 'epoch')) || 0));
-    const idOf = (line) => fieldOf(line, 'scope').slice('keys/'.length);
-    const classes = new Map();
-    for (const line of standing.filter((one) => fieldOf(one, 'measure') === 'class'))
-        classes.set(fieldOf(line, 'value'), [...(classes.get(fieldOf(line, 'value')) ?? []), idOf(line)]);
-    const named = new Set(standing.filter((one) => fieldOf(one, 'measure') === 'public-key').map(idOf));
-    const signers = [...new Set(standing.filter((one) => fieldOf(one, 'measure') === 'class').map(idOf))].filter((id) => named.has(id));
-    return { classes, signers };
-}
+var E=Object.defineProperty;var c=(e,s)=>E(e,"name",{value:s,configurable:!0});import{viewInput as h}from"../host/reading-context.js";import{dirname as N,existsSync as $,join as j}from"../host/io.js";import{ledgerLines as k,ledgerWriters as C,signedLines as F}from"../land/ledger.js";import{fieldOf as a,foldClaims as y,isWire as I,LOCK as K,selfName as R}from"./claims.js";import{observeText as T}from"../observe/files.js";import{library11_publicLock as w}from"../vendor/runtime.js";const b=new Map,x=new Map,L=new Map,U=c((e,s,t=[])=>S(e,t).classes.get(s)?.[0],"keyOf");function P(e,s,t=[]){const i=U(e,s,t);if(i===void 0)throw new Error(`${R()}: REFUSE\xB7keys the lock admits no key of class \`${s}\`: name one as \`keys/<id> measure=class value=${s}\``);return i}c(P,"keyFor");function v(e,s=[]){const t=S(e,s),i=new Set(t.classes.get("attest")??[]);return t.signers.filter(o=>!i.has(o))}c(v,"lockSigners");function _(e){const s=d(e);if(s)return s;const t=v(e).map(r=>h("authority-ledger:"+e+":"+r,()=>k(e,r))).filter(r=>r.length>0),i=L.get(e);if(i!==void 0&&i.parts.length===t.length&&i.parts.every((r,l)=>r===t[l]))return i.lines;const o=t.length===1?t[0]:t.flat();return L.set(e,{parts:t,lines:o}),o}c(_,"lockLines");const M=new WeakMap;function Q(e){const s=_(e);return M.get(s)??M.set(s,y(q(e)).standing).get(s)}c(Q,"lockStanding");function q(e,s=[]){const t=d(e);return t?[...t]:v(e,s).flatMap(i=>F(e,i))}c(q,"signedLockLines");function S(e,s){const t=p(e).join(`
+`),i=s.length?m(e,s):x.get(e)===t?b.get(e)??m(e):m(e);return s.length||x.set(e,t),s.length||b.set(e,i),i}c(S,"keysOf");const p=c(e=>h("key-claims:"+e,()=>C(e).flatMap(s=>k(e,s)).filter(s=>/\bsig=/.test(s)&&/(?:^|\s)scope=keys\/[^/\s]+\s/.test(s))),"ledgerKeyLines"),g=new Map;function d(e){if(g.has(e))return g.get(e);const s=j(N(e),K),t=p(e).length||!$(s)?[]:(T(s)??"").split(`
+`).filter(I),o=t.some(r=>a(r,"scope").startsWith("keys/")&&a(r,"measure")==="public-key"&&a(r,"sig"))&&w(t)!==void 0||t.some(r=>a(r,"scope")==="publish/bootstrap"&&a(r,"value")!=="withdraw")?t:void 0;return g.set(e,o),o}c(d,"releaseOf");function m(e,s=[]){const t=d(e)??[],i=w(t)===void 0?[]:t,o=[...p(e),...t,...s].filter(n=>(/\bsig=/.test(n)||i.includes(n))&&/(?:^|\s)scope=keys\/[^/\s]+\s/.test(n)),r=y(o).standing.filter(n=>a(n,"value")!=="withdraw").sort((n,u)=>(Number(a(n,"epoch"))||0)-(Number(a(u,"epoch"))||0)),l=c(n=>a(n,"scope").slice(5),"idOf"),f=new Map;for(const n of r.filter(u=>a(u,"measure")==="class"))f.set(a(n,"value"),[...f.get(a(n,"value"))??[],l(n)]);const O=new Set(r.filter(n=>a(n,"measure")==="public-key").map(l)),W=[...new Set(r.filter(n=>a(n,"measure")==="class").map(l))].filter(n=>O.has(n));return{classes:f,signers:W}}c(m,"read");export{P as keyFor,U as keyOf,_ as lockLines,v as lockSigners,Q as lockStanding,d as releaseOf,q as signedLockLines};

package/dist/fold/laid.js

@@ -1,90 +1,3 @@
-import { createHash, gzipSync, join } from "../host/io.js";
-import { canonical, LOCK } from '@lapxo/topos/wire';
-import { fieldOf, isWire } from "./claims.js";
-import { memoized } from "./digests.js";
-import { rolesOf } from "./roles.js";
-import { said } from "./wire.js";
-import { releasesOf } from "../host/release.js";
-import { land, landBlob, ledgerLines } from "../land/ledger.js";
-import { coordinatesUnder, observeFile, observeText, stampOf } from "../observe/files.js";
-import { ownLock } from "../observe/runner.js";
-const RECEIPT = 'laid/';
-const DIGEST = '{digest}';
-/** The host's marks, named by the lock: `release/asset` on this place, else the asset and archive the tree already writes. */
-const assetsOf = (_store) => said(ownLock(), 'release/asset');
-const marked = (coordinate, tokens) => tokens.some((token) => {
-    const at = token.indexOf(DIGEST);
-    if (at < 0)
-        return !token.includes('{') && coordinate === token;
-    const head = token.slice(0, at);
-    const tail = token.slice(at + DIGEST.length);
-    return coordinate.startsWith(head) && coordinate.endsWith(tail)
-        && coordinate.length === head.length + tail.length + 64
-        && /^[0-9a-f]{64}$/.test(coordinate.slice(head.length, coordinate.length - tail.length));
-});
-const coordinatesOf = (store, place) => {
-    const roleOf = rolesOf(store);
-    const written = new Set((observeText(join(place, LOCK)) ?? '').split('\n').filter(isWire)
-        .map((line) => fieldOf(line, 'shape').split('/')[0] ?? ''));
-    const held = (coordinate) => !coordinate || (roleOf(coordinate) !== 'foreign' && (!coordinate.startsWith('.') || written.has(coordinate.split('/')[0] ?? '')));
-    const marks = assetsOf(store);
-    return coordinatesUnder(place, place, held).filter((coordinate) => held(coordinate) && !marked(coordinate, marks)).sort();
-};
-const stateOf = (place, files) => createHash('sha256').update(files.map((coordinate) => `${coordinate} ${stampOf(join(place, coordinate))?.stamp ?? ''}`).join('\n')).digest('hex');
-/**
- * A release is named by the digest of its folder, and what is laid is read again from its bytes by the same method: every
- * coordinate but those the tree's roles call foreign, a dotted one only where the folder's own lock writes into it, sorted, each a
- * ustar entry of mode 0644, owner 0 and time 0, then two empty blocks, gzipped at level nine. The mark the host writes is
- * none of those coordinates, so the digest of a place is the digest of the release laid there, or it is not that release.
- */
-export function releaseDigest(store, place) {
-    const files = coordinatesOf(store, place);
-    const state = stateOf(place, files);
-    return { state, digest: memoized(store, `laid ${state}`, () => {
-            const blocks = [];
-            for (const coordinate of files) {
-                const bytes = Buffer.from(observeFile(join(place, coordinate)) ?? new Uint8Array());
-                const header = Buffer.alloc(512);
-                const cut = coordinate.length <= 100 ? -1 : coordinate.lastIndexOf('/');
-                header.write(cut < 0 ? coordinate : coordinate.slice(cut + 1), 0, 100, 'utf8');
-                header.write('0000644\0', 100, 8, 'utf8');
-                header.write('0000000\0', 108, 8, 'utf8');
-                header.write('0000000\0', 116, 8, 'utf8');
-                header.write(`${bytes.length.toString(8).padStart(11, '0')}\0`, 124, 12, 'utf8');
-                header.write('00000000000\0', 136, 12, 'utf8');
-                header.write('        ', 148, 8, 'utf8');
-                header.write('0', 156, 1, 'utf8');
-                header.write('ustar\0', 257, 6, 'utf8');
-                header.write('00', 263, 2, 'utf8');
-                header.write(cut < 0 ? '' : coordinate.slice(0, cut), 345, 155, 'utf8');
-                header.write(`${header.reduce((sum, byte) => sum + byte, 0).toString(8).padStart(6, '0')}\0 `, 148, 8, 'utf8');
-                blocks.push(header, bytes, Buffer.alloc((512 - (bytes.length % 512)) % 512));
-            }
-            blocks.push(Buffer.alloc(1024));
-            const archive = gzipSync(Buffer.concat(blocks), { level: 9 });
-            const digest = `sha256:${createHash('sha256').update(archive).digest('hex')}`;
-            landBlob(store, digest, archive);
-            return digest;
-        }) };
-}
-/**
- * What the pass lands after it lays: for each release the own lock lays where it needs it, the digest its bytes give, by
- * the stamps of the bytes it read. What is read is the receipt of the bytes as they lie now: none is a count, and one
- * whose digest is not the one the lock names is a count.
- */
-export function landLaid(store, own, lock, folder) {
-    if (folder === undefined)
-        return;
-    land(store, folder, releasesOf(lock).filter((line) => fieldOf(line, 'needs')).map((line) => ((got) => canonical({
-        scope: `${RECEIPT}${fieldOf(line, 'scope').slice('dep/'.length)}/digest`, role: 'writes', form: 'alphabet', measure: 'digest',
-        value: got.digest, by: folder, at: `place:${got.state}`,
-    }))(releaseDigest(store, join(own, fieldOf(line, 'needs'))))));
-}
-export const laidDiffers = (store, own, lock, folder) => {
-    const said = new Map((folder === undefined ? [] : ledgerLines(store, folder)).filter((line) => fieldOf(line, 'scope').startsWith(RECEIPT))
-        .map((line) => [`${fieldOf(line, 'scope')} ${fieldOf(line, 'at')}`, fieldOf(line, 'value')]));
-    return releasesOf(lock).filter((line) => fieldOf(line, 'needs')).filter((line) => {
-        const place = join(own, fieldOf(line, 'needs'));
-        return said.get(`${RECEIPT}${fieldOf(line, 'scope').slice('dep/'.length)}/digest place:${stateOf(place, coordinatesOf(store, place))}`) !== fieldOf(line, 'value');
-    }).length;
-};
+var v=Object.defineProperty;var o=(t,s)=>v(t,"name",{value:s,configurable:!0});import{createHash as h,gzipSync as S,join as u}from"../host/io.js";import{library11_canonical as y,library11_LOCK as B}from"../vendor/runtime.js";import{fieldOf as l,isWire as L}from"./claims.js";import{memoized as W}from"./digests.js";import{rolesOf as C}from"./roles.js";import{said as D}from"./wire.js";import{releasesOf as g}from"../host/release.js";import{land as E,landBlob as I,ledgerLines as T}from"../land/ledger.js";import{coordinatesUnder as _,observeFile as j,observeText as z,stampOf as K}from"../observe/files.js";import{ownLock as U}from"../observe/runner.js";const m="laid/",w="{digest}",A=o(t=>D(U(),"release/asset"),"assetsOf"),F=o((t,s)=>s.some(r=>{const n=r.indexOf(w);if(n<0)return!r.includes("{")&&t===r;const i=r.slice(0,n),e=r.slice(n+w.length);return t.startsWith(i)&&t.endsWith(e)&&t.length===i.length+e.length+64&&/^[0-9a-f]{64}$/.test(t.slice(i.length,t.length-e.length))}),"marked"),$=o((t,s)=>{const r=C(t),n=new Set((z(u(s,B))??"").split(`
+`).filter(L).map(a=>l(a,"shape").split("/")[0]??"")),i=o(a=>!a||r(a)!=="foreign"&&(!a.startsWith(".")||n.has(a.split("/")[0]??"")),"held"),e=A(t);return _(s,s,i).filter(a=>i(a)&&!F(a,e)).sort()},"coordinatesOf"),O=o((t,s)=>h("sha256").update(s.map(r=>`${r} ${K(u(t,r))?.stamp??""}`).join(`
+`)).digest("hex"),"stateOf");function G(t,s){const r=$(t,s),n=O(s,r);return{state:n,digest:W(t,`laid ${n}`,()=>{const i=[];for(const c of r){const d=Buffer.from(j(u(s,c))??new Uint8Array),f=Buffer.alloc(512),p=c.length<=100?-1:c.lastIndexOf("/");f.write(p<0?c:c.slice(p+1),0,100,"utf8"),f.write("0000644\0",100,8,"utf8"),f.write("0000000\0",108,8,"utf8"),f.write("0000000\0",116,8,"utf8"),f.write(`${d.length.toString(8).padStart(11,"0")}\0`,124,12,"utf8"),f.write("00000000000\0",136,12,"utf8"),f.write("        ",148,8,"utf8"),f.write("0",156,1,"utf8"),f.write("ustar\0",257,6,"utf8"),f.write("00",263,2,"utf8"),f.write(p<0?"":c.slice(0,p),345,155,"utf8"),f.write(`${f.reduce((b,x)=>b+x,0).toString(8).padStart(6,"0")}\0 `,148,8,"utf8"),i.push(f,d,Buffer.alloc((512-d.length%512)%512))}i.push(Buffer.alloc(1024));const e=S(Buffer.concat(i),{level:9}),a=`sha256:${h("sha256").update(e).digest("hex")}`;return I(t,a,e),a})}}o(G,"releaseDigest");function Y(t,s,r,n){n!==void 0&&E(t,n,g(r).filter(i=>l(i,"needs")).map(i=>(e=>y({scope:`${m}${l(i,"scope").slice(4)}/digest`,role:"writes",form:"alphabet",measure:"digest",value:e.digest,by:n,at:`place:${e.state}`}))(G(t,u(s,l(i,"needs"))))))}o(Y,"landLaid");const Z=o((t,s,r,n)=>{const i=new Map((n===void 0?[]:T(t,n)).filter(e=>l(e,"scope").startsWith(m)).map(e=>[`${l(e,"scope")} ${l(e,"at")}`,l(e,"value")]));return g(r).filter(e=>l(e,"needs")).filter(e=>{const a=u(s,l(e,"needs"));return i.get(`${m}${l(e,"scope").slice(4)}/digest place:${O(a,$(t,a))}`)!==l(e,"value")}).length},"laidDiffers");export{Z as laidDiffers,Y as landLaid,G as releaseDigest};

package/dist/fold/nos.js

@@ -1,48 +1 @@
-import { existsSync, join } from "../host/io.js";
-import { fieldOf } from "./claims.js";
-import { lockLines } from "./keys.js";
-import { wordsOf } from "./wire.js";
-import { entriesIn } from "../observe/files.js";
-const sampleWord = (standing, root, place) => wordsOf(standing, 'families').find((one) => [one, `${one}s`].some((name) => existsSync(join(root, place, name))));
-const noOf = (need, word) => {
-    const steps = need.split('/');
-    const i = steps.findIndex((step) => step === word || step === `${word}s`);
-    if (i < 0 || steps[i + 2] !== 'no')
-        return undefined;
-    const file = steps[i + 3];
-    return file === undefined || file.includes('*') ? undefined : file.replace(/\.[^.]+$/, '');
-};
-/**
- * A bug found lands as a no of the law it broke. From the epoch the lock asks for it on — the next one while no line
- * asks yet, the epoch an accept would sign it at — every law of the place a witness names, a demand or a ceiling, holds
- * its bug in a no: a need under the wire's sample family /<area>/no/, or a no of the place named after the law. What this
- * counts is each law witnessed since then that holds none. When the lock lists no sample family, every such law is a
- * demand: the folder is not guessed.
- */
-export function bugsWithoutANo(root, store, standing, place, measure) {
-    const epoch = (line) => Number(fieldOf(line, 'epoch'));
-    const asking = standing.filter((line) => fieldOf(line, 'measure') === measure && fieldOf(line, 'value') !== 'withdraw').map(epoch);
-    const from = asking.length ? Math.min(...asking) : lockLines(store).reduce((most, line) => Math.max(most, epoch(line)), 0) + 1;
-    const word = sampleWord(standing, root, place);
-    const nos = new Set();
-    for (const line of standing)
-        for (const need of fieldOf(line, 'needs').split('|').filter(Boolean)) {
-            const name = word === undefined ? undefined : noOf(need, word);
-            if (name)
-                nos.add(name);
-        }
-    if (word !== undefined) {
-        const dir = [word, `${word}s`].map((name) => join(root, place, name)).find((at) => existsSync(at));
-        if (dir !== undefined)
-            for (const area of entriesIn(dir).filter((one) => one.dir)) {
-                for (const one of entriesIn(join(dir, area.name, 'no')))
-                    nos.add(one.name.replace(/\.[^.]+$/, ''));
-            }
-    }
-    const named = (scope) => scope.slice(scope.lastIndexOf('/') + 1);
-    const holds = (line) => nos.has(named(fieldOf(line, 'scope')))
-        || (word !== undefined && fieldOf(line, 'needs').split('|').some((need) => noOf(need, word) !== undefined && existsSync(join(root, need))));
-    return standing.filter((line) => fieldOf(line, 'at').startsWith('witness:') && fieldOf(line, 'value') !== 'withdraw' && epoch(line) >= from
-        && fieldOf(line, 'scope').startsWith(`${place}/`)
-        && (fieldOf(line, 'role') === 'demands' || fieldOf(line, 'form') === 'interval') && !holds(line)).length;
-}
+var v=Object.defineProperty;var c=(f,r)=>v(f,"name",{value:r,configurable:!0});import{existsSync as p,join as u}from"../host/io.js";import{fieldOf as o}from"./claims.js";import{lockLines as I}from"./keys.js";import{wordsOf as b}from"./wire.js";import{entriesIn as w}from"../observe/files.js";const k=c((f,r,t)=>b(f,"families").find(s=>[s,`${s}s`].some(i=>p(u(r,t,i)))),"sampleWord"),$=c((f,r)=>{const t=f.split("/"),s=t.findIndex(m=>m===r||m===`${r}s`);if(s<0||t[s+2]!=="no")return;const i=t[s+3];return i===void 0||i.includes("*")?void 0:i.replace(/\.[^.]+$/,"")},"noOf");function A(f,r,t,s,i){const m=c(e=>Number(o(e,"epoch")),"epoch"),h=t.filter(e=>o(e,"measure")===i&&o(e,"value")!=="withdraw").map(m),x=h.length?Math.min(...h):I(r).reduce((e,n)=>Math.max(e,m(n)),0)+1,d=k(t,f,s),l=new Set;for(const e of t)for(const n of o(e,"needs").split("|").filter(Boolean)){const a=d===void 0?void 0:$(n,d);a&&l.add(a)}if(d!==void 0){const e=[d,`${d}s`].map(n=>u(f,s,n)).find(n=>p(n));if(e!==void 0)for(const n of w(e).filter(a=>a.dir))for(const a of w(u(e,n.name,"no")))l.add(a.name.replace(/\.[^.]+$/,""))}const O=c(e=>e.slice(e.lastIndexOf("/")+1),"named"),W=c(e=>l.has(O(o(e,"scope")))||d!==void 0&&o(e,"needs").split("|").some(n=>$(n,d)!==void 0&&p(u(f,n))),"holds");return t.filter(e=>o(e,"at").startsWith("witness:")&&o(e,"value")!=="withdraw"&&m(e)>=x&&o(e,"scope").startsWith(`${s}/`)&&(o(e,"role")==="demands"||o(e,"form")==="interval")&&!W(e)).length}c(A,"bugsWithoutANo");export{A as bugsWithoutANo};

package/dist/fold/object.js

@@ -1,2 +1 @@
-/** Compatibility path; the engine owns the single object projection. */
-export { objectFold } from "../engine/index.js";
+import{objectFold as r}from"../engine/index.js";export{r as objectFold};