@lapxo/bound 0.1.4 → 0.1.6

package/dist/fold/closed.js

@@ -1,6 +1,8 @@
+import { actCosts } from "../host/act-cost.js";
+import { verifiedReadingReceipts } from "../host/reading-closures.js";
 import { dirname, existsSync, join, mkdirSync, relative, resolve, statSync, writeFileSync } from "../host/io.js";
-import { canonical, LOCK, parse, roleAt, roleClaimsOf } from '@lapxo/topos/wire';
-import { RECEIPTS, fieldOf, isWire } from "./claims.js";
+import { byBytes, canonical, LOCK, parse, publicationOf, roleAt, roleClaimsOf } from '@lapxo/topos/wire';
+import { RECEIPTS, fieldOf, foldClaims, isConfig, isWire } from "./claims.js";
 import { bytesDigest as hashBytes, fullDigest as hashFull } from "../host/digest.js";
 import { worldAt } from "./places.js";
 import { ownLockOf } from "./signed.js";
@@ -9,15 +11,14 @@ import { storeAt, storeOf } from "../land/ledger.js";
 import { coordinatesUnder, observeFile, observeText } from "../observe/files.js";
 import { carriedFrom } from "./resolved.js";
 import { takenFor } from "../fold/place-inputs.js";
-/** A region is closed when the digest of its bytes is the one its receipt names. Folding a closed region is idle: idleCount is how many were already closed, actSeconds how long this act has run, receiptsSeen how many receipts were read and how long that took. */
+/** A region is closed when the digest of its bytes is the one its receipt names. Folding a closed region is idle: idleCount is how many were already closed, actSeconds the largest measured act or unpartitioned host work, receiptsSeen how many receipts were read and how long that took. */
 let idle = 0;
-const began = Date.now();
 let seen = { count: 0, ms: 0 };
 export const idleCount = () => idle;
 export const noteIdle = () => {
     idle += 1;
 };
-export const actSeconds = () => Math.max(0, Math.round((Date.now() - began) / 1000));
+export const actSeconds = () => actCosts.seconds();
 export const receiptsSeen = () => seen;
 const algorithmIn = (text) => text.match(/(?:value=|place:)([a-z0-9]+):[0-9a-f]{64}/)?.[1] ?? '';
 const lockStamp = (root, place) => {
@@ -55,6 +56,14 @@ function filesOf(root, place, region, inputs) {
     return [...new Set([...owned, ...observed, ...own])].filter(rel => rel !== receipt && !rel.split('/').some(part => part === '.bound' || part === '.cache' || part === '.git'));
 }
 const rooted = new Map();
+function publicConfiguration(lines) {
+    if (!lines.length || !lines.every(isConfig))
+        return lines;
+    const folded = foldClaims(lines);
+    if (folded.forks.length)
+        throw Error('REFUSE·receipt disputed configuration standing');
+    return publicationOf(folded.standing.filter(line => fieldOf(line, 'value') !== 'withdraw'));
+}
 function rootLines(root, place) {
     const name = place.replace(/\/$/, '');
     if (!name)
@@ -63,7 +72,7 @@ function rootLines(root, place) {
     const held = rooted.get(key);
     if (held !== undefined)
         return held;
-    const standing = (observeText(join(root, LOCK)) ?? '').split('\n').filter(isWire);
+    const standing = publicConfiguration((observeText(join(root, LOCK)) ?? '').split('\n').filter(isWire));
     // Authority validates admission separately; it is not a rendered file input.
     const lines = standing.filter((line) => fieldOf(line, 'value') !== 'withdraw' && !fieldOf(line, 'scope').startsWith('keys/'));
     const take = takenFor(lines, `${name}/`, worldAt(root, name) ? { own: ownLockOf(root, name), tree: viewsOf(standing) } : undefined);
@@ -73,8 +82,20 @@ function rootLines(root, place) {
 }
 /** File-fold identity uses public inputs; admission history stays in its separate ledger guard. */
 export function fileRegionDigest(root, place, region, algorithm, inputs = []) {
-    const files = filesOf(root, place, region, inputs);
-    return hashFull([...files.map((rel) => `${relative(join(root, place), join(root, rel))} ${hashBytes(observeFile(join(root, rel)) ?? new Uint8Array(), algorithm)}`), ...rootLines(root, place)], algorithm);
+    const files = [...filesOf(root, place, region, inputs)].sort(byBytes);
+    const own = join(root, place, LOCK);
+    const bytesOf = (rel) => {
+        const at = join(root, rel), bytes = observeFile(at) ?? new Uint8Array();
+        if (resolve(at) !== resolve(own))
+            return bytes;
+        const lines = new TextDecoder().decode(bytes).split('\n').filter(isWire);
+        // Object history keeps its own contract. Configuration's public identity is
+        // the existing Topos publication projection, not its admission envelopes.
+        if (!lines.length || !lines.every(isConfig))
+            return bytes;
+        return new TextEncoder().encode(publicConfiguration(lines).join('\n') + '\n');
+    };
+    return hashFull([...files.map((rel) => `${relative(join(root, place), join(root, rel))} ${hashBytes(bytesOf(rel), algorithm)}`), ...rootLines(root, place)], algorithm);
 }
 function namedReceipts(root, store) {
     const text = observeText(join(root, RECEIPTS));
@@ -89,13 +110,15 @@ function namedReceipts(root, store) {
     }
     return out;
 }
+// Only the instrument's file seals describe file-region bytes. Reader receipts keep their own semantic identity.
+const fileSeal = (line) => isWire(line) && fieldOf(line, 'measure') === 'bytes' && fieldOf(line, 'by') === 'bound';
 function ownBytes(root) {
-    return (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(line => isWire(line) && fieldOf(line, 'measure') === 'bytes');
+    return (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(fileSeal);
 }
 function bytesMeet(root, place) {
     const shipped = (observeText(join(root, place, RECEIPTS)) ?? '').split('\n').filter(isWire);
     const inputs = carriedFrom(storeOf(root), shipped) ?? [];
-    const lines = shipped.filter(line => fieldOf(line, 'measure') === 'bytes');
+    const lines = shipped.filter(fileSeal);
     const algorithm = algorithmIn(lines.join('\n'));
     return lines.length > 0 && algorithm !== '' && lines.map((line) => fieldOf(line, 'value')).join('\n') === lines.map((line) => fileRegionDigest(root, place, fieldOf(line, 'scope'), algorithm, inputs)).join('\n');
 }
@@ -115,8 +138,8 @@ function rewritePlace(root, place) {
     const algorithm = algorithmIn(text);
     if (algorithm === '')
         return;
-    const kept = text.split('\n').filter((line) => line === '' || !isWire(line) || fieldOf(line, 'measure') !== 'bytes');
-    const regions = kept.filter((line) => isWire(line) && fieldOf(line, 'measure') === 'count' && fieldOf(line, 'scope').startsWith('receipts/'));
+    const kept = text.split('\n').filter((line) => line === '' || !fileSeal(line));
+    const regions = kept.filter((line) => isWire(line) && fieldOf(line, 'measure') === 'count' && fieldOf(line, 'by') === 'bound' && fieldOf(line, 'scope').startsWith('receipts/'));
     const bytes = regions.map((line) => {
         const scope = fieldOf(line, 'scope');
         const inputs = carriedFrom(storeOf(root), kept.filter(isWire)) ?? [];
@@ -146,11 +169,19 @@ export function meets(root, store, place) {
         const own = ownBytes(root);
         const carried = own.length ? carriedFrom(store, (observeText(join(root, RECEIPTS)) ?? '').split('\n').filter(isWire)) : undefined;
         const ownClosed = own.length > 0 && carried !== undefined && carried.length > 0 && bytesMeet(root, '');
-        const closed = (own.length > 0 ? ownClosed : named.size > 0) && [...named].every(([one, expected]) => {
+        let closed = (own.length > 0 ? ownClosed : named.size > 0) && [...named].every(([one, expected]) => {
             const bytes = observeFile(join(root, one, RECEIPTS));
             const algorithm = expected.split(':')[0];
             return bytes !== undefined && hashBytes(bytes, algorithm) === expected && meets(root, store, `${one}/`);
         });
+        if (closed && carried) {
+            const algorithm = algorithmIn(own.join('\n'));
+            const readings = verifiedReadingReceipts(store, carried, text => hashFull(text, algorithm));
+            if (readings === undefined)
+                closed = false;
+            else if (readings)
+                process.stderr.write(`RECEIPTS ${readings} read · 0 opened · reading closures\n`);
+        }
         seen = { count: named.size + (own.length > 0 ? 1 : 0), ms: Date.now() - at };
         return closed;
     }

package/dist/fold/digests.js

@@ -1,5 +1,6 @@
+import { ledgerLines, ledgerWriters } from "../land/ledger.js";
 import { readOnly } from "../host/read-only.js";
-import { appendFileSync, dirname, join, mkdirSync, readdirSync, relative, resolve } from "../host/io.js";
+import { appendFileSync, dirname, join, mkdirSync, readdirSync, realpathSync, relative, resolve } from "../host/io.js";
 import { bytesDigest as bytesWith, fullDigest as fullWith } from "../host/digest.js";
 import { coordinatesUnder, observeFile, observeText, stampOf } from "../observe/files.js";
 import { releaseOf, signedLockLines } from "./keys.js";
@@ -7,6 +8,7 @@ import { EXTENSION, fieldOf, foldClaims, selfName } from "./claims.js";
 import { wireLine } from "./wire.js";
 import { publicLock, LOCK } from '@lapxo/topos/wire';
 import { builtinModules, createRequire } from 'node:module';
+import { moduleImports } from "../host/adapters/modules/javascript.js";
 const held = new Map();
 let algorithmMs = 0;
 export const algorithmCost = () => algorithmMs;
@@ -31,10 +33,8 @@ function namedAlgorithm(store) {
         const contract = published === undefined ? undefined : wireLine(published, 'digest-algorithms');
         return contract === undefined ? undefined : fieldOf(contract, 'value').split('|')[0]?.split(':')[0];
     }
-    for (const entry of readdirSync(join(store, 'ledger'), { withFileTypes: true })) {
-        if (!entry.isFile() || !entry.name.endsWith(EXTENSION))
-            continue;
-        const text = observeText(join(store, 'ledger', entry.name)) ?? '';
+    for (const writer of ledgerWriters(store)) {
+        const text = ledgerLines(store, writer).join('\n');
         let from = 0;
         while (from < text.length) {
             const at = (() => {
@@ -110,6 +110,8 @@ export function coordinateDigest(store, at) {
     const stamp = stampOf(at);
     if (stamp?.kind !== 'file')
         return stamp === undefined ? undefined : bytesDigest(store, observeFile(at) ?? new Uint8Array());
+    if (readOnly())
+        return bytesDigest(store, observeFile(at) ?? new Uint8Array());
     const key = `${at} ${stamp.stamp}`;
     const memo = memoOf(store);
     const held = memo.get(key);
@@ -140,10 +142,10 @@ const imported = new Map();
 const importsOf = (store, at, digest) => {
     const key = `imports ${fullDigest(store, importsOf.toString())} ${digest}`;
     const memo = memoOf(store);
-    const held = imported.get(digest) ?? memo.get(key)?.split('|').filter(Boolean);
+    const held = imported.get(digest) ?? (readOnly() ? undefined : memo.get(key)?.split('|').filter(Boolean));
     if (held !== undefined)
         return held;
-    const found = [...new TextDecoder().decode(observeFile(at) ?? new Uint8Array()).matchAll(/(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)['"]([^'"]*)['"]/g)].map((m) => m[1] ?? '');
+    const found = moduleImports(new TextDecoder().decode(observeFile(at) ?? new Uint8Array()), at);
     imported.set(digest, found);
     memo.set(key, found.join('|'));
     if (!readOnly())
@@ -173,14 +175,19 @@ export function instrumentCoordinates(store, entry, standing = [], root = dirnam
         const digest = coordinateDigest(store, at);
         if (digest === undefined)
             return;
-        seen.set(at, digest);
-        for (const one of importsOf(store, at, digest)) {
+        // The host loader resolves links before loading a module. Count that module
+        // once, while retaining distinct modules even when their bytes are equal.
+        const module = realpathSync(at);
+        if (seen.has(module))
+            return;
+        seen.set(module, digest);
+        for (const one of importsOf(store, module, digest)) {
             if (one.startsWith('node:') || builtinModules.includes(one))
                 continue;
             if (one.startsWith('.'))
-                walk(resolve(dirname(at), one));
+                walk(resolve(dirname(module), one));
             else
-                walk(createRequire(at).resolve(one));
+                walk(createRequire(module).resolve(one));
         }
     };
     walk(resolve(entry));

package/dist/fold/kept.js

@@ -1,8 +1,9 @@
+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, memoAt, shardFile, writerFile } from "../land/ledger.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";
@@ -36,7 +37,7 @@ export function foldPoints(store, standing, under, keeper, instrument = '', obse
         `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 = (existsSync(join(store, 'ledger')) ? readdirSync(join(store, 'ledger')) : []).filter((name) => name.endsWith(EXTENSION)).map((name) => name.slice(0, -EXTENSION.length))
+    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()
@@ -100,8 +101,12 @@ 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))];
-    return bytesDigest(store, text(files.filter(file => existsSync(file)).sort()
-        .map(file => bytesDigest(store, observeFile(file) ?? new Uint8Array())).join('\n')));
+    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')));
 }
 export function keptPlace(store, under) {
     const key = observeText(memoAt(store, lastOf([`place ${under ?? '.'}`])))?.trim();

package/dist/fold/keys.js

@@ -1,8 +1,9 @@
 import { dirname, existsSync, join } from "../host/io.js";
-import { ledgerLines, signedLines } from "../land/ledger.js";
-import { EXTENSION, fieldOf, foldClaims, isWire, LOCK, selfName } from "./claims.js";
-import { entriesIn, observeText } from "../observe/files.js";
+import { ledgerLines, ledgerWriters, signedLines } from "../land/ledger.js";
+import { fieldOf, foldClaims, isWire, LOCK, selfName } from "./claims.js";
+import { observeText } from "../observe/files.js";
 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
@@ -47,13 +48,15 @@ export function signedLockLines(store, told = []) {
     return lockSigners(store, told).flatMap((id) => signedLines(store, id));
 }
 function keysOf(store, told) {
-    const mine = told.length ? read(store, told) : held.get(store) ?? read(store);
+    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) => (existsSync(join(store, 'ledger')) ? entriesIn(join(store, 'ledger')).map((entry) => entry.name) : [])
-    .filter((name) => name.endsWith(EXTENSION)).flatMap((name) => ledgerLines(store, name.slice(0, -EXTENSION.length)))
+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();
 /**