@lapxo/bound 0.1.3 → 0.1.5

package/dist/fold/observed.js

@@ -1,3 +1,6 @@
+import { actCosts } from "../host/act-cost.js";
+import { readingClosures } from "../host/reading-closures.js";
+import { readerLifetime, readerAllowsEmpty, assertReaderInputs, parse as parseLifetime } from '@lapxo/topos/wire';
 import { readOnly } from "../host/read-only.js";
 import { basename, dirname, existsSync, mkdirSync, resolve, rmSync, spawn, statSync, writeFileSync } from "../host/io.js";
 import { bundleOf, processOf } from "../observe/runner.js";
@@ -264,202 +267,222 @@ export function observedClaims(root, store, options = {}) {
     }
     function observeOne(reader, started) {
         const module = resolve(root, reader.module);
-        const asked = reader.capsule === undefined ? undefined : capsuleAt(reader.capsule.digest, reader.capsule.entry);
-        const source = reader.capsule === undefined ? observeFile(module) : asked === undefined ? undefined : new Uint8Array();
-        const bundle = source && reader.capsule === undefined ? bundleOf(module) ?? bytesDigest(store, source) : 'none';
-        const offered = offersOf(root, store, reader, roleOf, look, (where) => reached(trimmed(where)));
-        const vectors = reader.capsule === undefined ? observeText(resolve(root, vectorsOf(reader.module, standing))) : undefined;
-        const kept = whole && legacy === undefined && answered === undefined && source ? sha([
-            speaker, reader.module, reader.kind, reader.shape.join('|'), reader.where.join('|'), bundle, vectors === undefined ? 'no vectors' : sha(vectors),
-            reader.capsule === undefined ? '' : `${reader.capsule.digest} ${reader.capsule.region} ${reader.capsule.reads.join('|')} ${[...reader.capsule.globs].map(([place, globs]) => `${place}${globs.join('|')}`).join(' ')}`,
-            ...offered.map((offer) => `${offer.place} ${offer.digest?.() ?? bytesDigest(store, offer.bytes())}`),
-        ].join('\n')) : undefined;
-        const stored = kept === undefined ? undefined : observeText(memoAt(store, `observed/${kept}`));
-        if (stored !== undefined) {
-            out.push(...stored.split('\n').filter(isWire));
-            read += offered.length;
-            whole_ += 1;
+        const asked = reader.capsule === undefined ? undefined : reader.capsule.selected ?? capsuleAt(reader.capsule.digest, reader.capsule.entry);
+        const projection = reader.capsule === undefined ? [] : (asked?.lines ?? []).filter(line => fieldOf(line, 'scope') === `region/${reader.capsule.region}` && fieldOf(line, 'measure') === 'input-projection' && fieldOf(line, 'value') !== 'withdraw');
+        if (projection.length) {
+            if (projection.length !== 1 || !asked)
+                throw Error('REFUSE·input projection is ambiguous ' + reader.module);
+            const files = [...new Set(reader.where.flatMap(where => handedAt(root, reader, roleOf, look, where)))].sort().map(place => ({ place, text: observeText(resolve(root, place)) ?? '' }));
+            const result = readingClosures({ root, store, reader: reader.module, speaker, digest: text => bytesDigest(store, Buffer.from(text)), capsule: asked, region: reader.capsule.region, projection: fieldOf(projection[0], 'value'), allowsEmpty: readerAllowsEmpty(standing.flatMap(line => { const p = parseLifetime(line); return p.kind === 'fact' ? [p.value.fields] : []; }), reader.module), files, emit: line => process.stderr.write(line + '\n') });
+            out.push(...result.lines);
+            ran += result.executed;
+            read += result.read - result.opened;
             return false;
         }
-        const mark = out.length;
-        const home = regionIn(regions, reader.module);
-        const own = shardLines(store, speaker, home).filter((line) => fieldOf(line, 'scope') === `reader/${reader.module}`);
-        const lineage = own.filter((line) => fieldOf(line, 'measure') === 'identity').map((line) => fieldOf(line, 'value'));
-        const sum = source && reader.capsule === undefined ? bytesDigest(store, new TextEncoder().encode(`${reader.module} ${bundle}`)).replace(/^sha256:/, '').slice(0, 12) : 'none';
-        const measured = reader.capsule !== undefined ? { by: source ? sha(`${reader.capsule.digest}\n${reader.capsule.region}`).slice(0, 12) : 'none', lines: [] }
-            : source ? identityOf({ store, root, speaker, module: reader.module, kind: reader.kind, code: sum, lineage, kept: own.filter((line) => /(?:^|\s)measure=(?:extension|emits)\s/.test(line)) })
-                : { by: 'none', lines: [] };
-        const by = measured.by;
-        const level = [...measured.lines];
-        const identified = Date.now();
-        const lines = [...lineage, by];
-        const before = [...lineage].reverse().find((one) => one !== by);
-        const regionsOf = new Map();
-        for (const offer of offered) {
-            const region = regionIn(regions, offer.place);
-            if (reached(region))
-                regionsOf.set(region, [...(regionsOf.get(region) ?? []), offer]);
-        }
-        const planned = [...regionsOf].map(([region, offers]) => {
-            const shard = open(region);
-            const places = offers.map((offer) => offer.place);
-            const pairs = [];
-            const kept = [];
-            const moved = [];
-            const all = [];
-            for (const offer of offers) {
-                const known = shard.places.get(`${by} ${offer.place}`);
-                if (known && fieldOf(known.line, 'value') === offer.seen) {
-                    pairs.push(`${offer.place} ${known.at}`);
-                    kept.push(known.line);
-                    all.push({ ...offer, digest: known.at.slice('place:'.length) });
-                    read += 1;
-                    continue;
+        const endAct = actCosts.begin();
+        try {
+            const source = reader.capsule === undefined ? observeFile(module) : asked === undefined ? undefined : new Uint8Array();
+            const bundle = source && reader.capsule === undefined ? bundleOf(module) ?? bytesDigest(store, source) : 'none';
+            const offered = offersOf(root, store, reader, roleOf, look, (where) => reached(trimmed(where)));
+            assertReaderInputs(standing.flatMap(line => { const p = parseLifetime(line); return p.kind === 'fact' ? [p.value.fields] : []; }), reader.module, offered.length);
+            const vectors = reader.capsule === undefined ? observeText(resolve(root, vectorsOf(reader.module, standing))) : undefined;
+            const kept = whole && legacy === undefined && answered === undefined && source ? sha([
+                speaker, reader.module, reader.kind, reader.shape.join('|'), reader.where.join('|'), bundle, vectors === undefined ? 'no vectors' : sha(vectors),
+                reader.capsule === undefined ? '' : `${reader.capsule.selected?.selection ?? reader.capsule.digest} ${reader.capsule.region} ${reader.capsule.reads.join('|')} ${[...reader.capsule.globs].map(([place, globs]) => `${place}${globs.join('|')}`).join(' ')}`,
+                ...offered.map((offer) => `${offer.place} ${offer.digest?.() ?? bytesDigest(store, offer.bytes())}`),
+            ].join('\n')) : undefined;
+            const stored = kept === undefined ? undefined : observeText(memoAt(store, `observed/${kept}`));
+            if (stored !== undefined) {
+                out.push(...stored.split('\n').filter(isWire));
+                read += offered.length;
+                whole_ += 1;
+                return false;
+            }
+            const mark = out.length;
+            const home = regionIn(regions, reader.module);
+            const own = shardLines(store, speaker, home).filter((line) => fieldOf(line, 'scope') === `reader/${reader.module}`);
+            const lineage = own.filter((line) => fieldOf(line, 'measure') === 'identity').map((line) => fieldOf(line, 'value'));
+            const sum = source && reader.capsule === undefined ? bytesDigest(store, new TextEncoder().encode(`${reader.module} ${bundle}`)).replace(/^sha256:/, '').slice(0, 12) : 'none';
+            const measured = reader.capsule !== undefined ? { by: source ? sha(`${reader.capsule.selected?.selection ?? reader.capsule.digest}\n${reader.capsule.region}`).slice(0, 12) : 'none', lines: [] }
+                : source ? identityOf({ store, root, speaker, module: reader.module, kind: reader.kind, code: sum, lineage, lifetime: readerLifetime(standing.flatMap(line => { const p = parseLifetime(line); return p.kind === 'fact' ? [p.value.fields] : []; }), reader.module), kept: own.filter((line) => /(?:^|\s)measure=(?:extension|emits)\s/.test(line)) })
+                    : { by: 'none', lines: [] };
+            const by = measured.by;
+            const level = [...measured.lines];
+            const identified = Date.now();
+            const lines = [...lineage, by];
+            const before = [...lineage].reverse().find((one) => one !== by);
+            const regionsOf = new Map();
+            for (const offer of offered) {
+                const region = regionIn(regions, offer.place);
+                if (reached(region))
+                    regionsOf.set(region, [...(regionsOf.get(region) ?? []), offer]);
+            }
+            const planned = [...regionsOf].map(([region, offers]) => {
+                const shard = open(region);
+                const places = offers.map((offer) => offer.place);
+                const pairs = [];
+                const kept = [];
+                const moved = [];
+                const all = [];
+                for (const offer of offers) {
+                    const known = shard.places.get(`${by} ${offer.place}`);
+                    if (known && fieldOf(known.line, 'value') === offer.seen) {
+                        pairs.push(`${offer.place} ${known.at}`);
+                        kept.push(known.line);
+                        all.push({ ...offer, digest: known.at.slice('place:'.length) });
+                        read += 1;
+                        continue;
+                    }
+                    const bytes = offer.digest ? undefined : offer.bytes();
+                    const digest = offer.digest?.() ?? bytesDigest(store, bytes);
+                    pairs.push(`${offer.place} place:${digest}`);
+                    kept.push(canonical({ scope: offer.place, role: 'writes', form: 'alphabet', measure: 'observed', value: offer.seen, by: `${speaker}:${by}`, at: `place:${digest}` }));
+                    all.push({ ...offer, digest, bytes: () => bytes ?? offer.bytes() });
+                    if (known?.at === `place:${digest}`)
+                        read += 1;
+                    else
+                        moved.push({ place: offer.place, seen: offer.seen, digest, bytes: bytes ?? offer.bytes() });
+                }
+                return { region, shard, places, pairs, kept, moved, all, key: keyOf(by, region, pairs) };
+            });
+            if (answered !== undefined && planned.every((plan) => !plan.moved.length && observedAt(store, plan.key))) {
+                for (const plan of planned) {
+                    for (const [at, digest] of digestsAt(plan.key))
+                        answered.set(`${by} ${at}`, digest);
+                    if (plan.shard.keys.get(by) !== plan.key || plan.kept.some((line) => plan.shard.places.get(`${by} ${fieldOf(line, 'scope')}`)?.line !== line)) {
+                        landShard(store, speaker, plan.region, [...plan.kept, pointer(speaker, by, plan.region, plan.key, plan.pairs)]);
+                    }
+                    out.push(...plan.kept);
                 }
-                const bytes = offer.digest ? undefined : offer.bytes();
-                const digest = offer.digest?.() ?? bytesDigest(store, bytes);
-                pairs.push(`${offer.place} place:${digest}`);
-                kept.push(canonical({ scope: offer.place, role: 'writes', form: 'alphabet', measure: 'observed', value: offer.seen, by: `${speaker}:${by}`, at: `place:${digest}` }));
-                all.push({ ...offer, digest, bytes: () => bytes ?? offer.bytes() });
-                if (known?.at === `place:${digest}`)
-                    read += 1;
-                else
-                    moved.push({ place: offer.place, seen: offer.seen, digest, bytes: bytes ?? offer.bytes() });
+                if (level.length)
+                    landShard(store, speaker, home, level);
+                return true;
             }
-            return { region, shard, places, pairs, kept, moved, all, key: keyOf(by, region, pairs) };
-        });
-        if (answered !== undefined && planned.every((plan) => !plan.moved.length && observedAt(store, plan.key))) {
-            for (const plan of planned) {
-                for (const [at, digest] of digestsAt(plan.key))
-                    answered.set(`${by} ${at}`, digest);
-                if (plan.shard.keys.get(by) !== plan.key || plan.kept.some((line) => plan.shard.places.get(`${by} ${fieldOf(line, 'scope')}`)?.line !== line)) {
-                    landShard(store, speaker, plan.region, [...plan.kept, pointer(speaker, by, plan.region, plan.key, plan.pairs)]);
+            const plans = planned.map(({ region, shard, places, pairs, kept, moved, all, key }) => {
+                const prior = lastOf(shard, by, places);
+                if (before !== undefined)
+                    lastOf(shard, before, places);
+                const ats = [...new Set(pairs.map((pair) => pair.slice(pair.indexOf(' ') + 1)))];
+                const found = byAt(key);
+                const said = found !== undefined ? ats.flatMap((at) => found.get(at) ?? [])
+                    : moved.length || prior === undefined ? undefined : ats.flatMap((at) => prior.get(at) ?? []);
+                const due = said === undefined && !moved.length ? all.map((one) => ({ place: one.place, seen: one.seen, digest: one.digest, bytes: one.bytes() })) : moved;
+                return { region, shard, places, pairs, kept, due, key, said, prior, found: found !== undefined };
+            });
+            const due = plans.flatMap((plan) => (plan.said === undefined ? plan.due.map((one) => ({ ...one, region: plan.region })) : []));
+            const heldOf = (place, region) => {
+                for (const one of [...lines].reverse()) {
+                    const shard = open(region);
+                    const mine = servedAt(shard, one, place, lastOf(shard, one, [place])).slice(1);
+                    if (mine.length)
+                        return mine.map((line) => [fieldOf(line, 'scope'), fieldOf(line, 'value')]);
                 }
-                out.push(...plan.kept);
+                return [];
+            };
+            if (due.length && !source) {
+                refused.push(`REFUSE·reader ${reader.module} unavailable · ${due.length} readings remain due`);
+                return false;
             }
-            if (level.length)
-                landShard(store, speaker, home, level);
-            return true;
-        }
-        const plans = planned.map(({ region, shard, places, pairs, kept, moved, all, key }) => {
-            const prior = lastOf(shard, by, places);
-            if (before !== undefined)
-                lastOf(shard, before, places);
-            const ats = [...new Set(pairs.map((pair) => pair.slice(pair.indexOf(' ') + 1)))];
-            const found = byAt(key);
-            const said = found !== undefined ? ats.flatMap((at) => found.get(at) ?? [])
-                : moved.length || prior === undefined ? undefined : ats.flatMap((at) => prior.get(at) ?? []);
-            const due = said === undefined && !moved.length ? all.map((one) => ({ place: one.place, seen: one.seen, digest: one.digest, bytes: one.bytes() })) : moved;
-            return { region, shard, places, pairs, kept, due, key, said, prior, found: found !== undefined };
-        });
-        const due = plans.flatMap((plan) => (plan.said === undefined ? plan.due.map((one) => ({ ...one, region: plan.region })) : []));
-        const heldOf = (place, region) => {
-            for (const one of [...lines].reverse()) {
-                const shard = open(region);
-                const mine = servedAt(shard, one, place, lastOf(shard, one, [place])).slice(1);
-                if (mine.length)
-                    return mine.map((line) => [fieldOf(line, 'scope'), fieldOf(line, 'value')]);
+            if (due.length && !wait) {
+                for (const plan of plans) {
+                    if (plan.said !== undefined) {
+                        out.push(...plan.kept, ...plan.said);
+                        continue;
+                    }
+                    for (const place of plan.places) {
+                        const mine = servedAt(plan.shard, by, place, plan.prior);
+                        out.push(...(mine.length || before === undefined ? mine : servedAt(plan.shard, before, place, lastOf(plan.shard, before, plan.places))));
+                    }
+                }
+                const marker = storeAt(store, 'pending', by);
+                const pid = Number((observeText(marker) ?? '').split('\n')[1]);
+                const running = existsSync(marker) && Date.now() - statSync(marker).mtimeMs < 30 * 60 * 1000 && Number.isInteger(pid) && pid > 0 && alive(pid);
+                if (!running) {
+                    mkdirSync(dirname(marker), { recursive: true });
+                    const child = spawn(process.execPath, [...childFlags(), processOf('observe'), root, reader.module], { cwd: root, detached: true, stdio: 'ignore' });
+                    child.unref();
+                    writeFileSync(marker, `${reader.module}\n${child.pid ?? ''}\n`);
+                }
+                behind.push({ module: reader.module, places: due.length });
+                process.stderr.write(`GREY     reading: ${reader.module} · ${due.length} places · runs behind${running ? ', already running' : ''}\n`);
+                if (level.length)
+                    landShard(store, speaker, home, level);
+                if (Date.now() - started > 250)
+                    spent.push(`${reader.module.split('/').pop()} behind ${Date.now() - started}`);
+                return false;
             }
-            return [];
-        };
-        if (due.length && !source) {
-            refused.push(`REFUSE·reader ${reader.module} unavailable · ${due.length} readings remain due`);
-            return false;
-        }
-        if (due.length && !wait) {
-            for (const plan of plans) {
-                if (plan.said !== undefined) {
-                    out.push(...plan.kept, ...plan.said);
-                    continue;
+            if (due.length) {
+                const at = Date.now();
+                let rows;
+                try {
+                    rows = reader.capsule !== undefined && asked !== undefined
+                        ? asked.ask(due.map((d) => ({
+                            protocol: PROTOCOL, verb: 'read', rootScope: d.place, region: reader.capsule.region, held: heldOf(d.place, d.region),
+                            files: (reader.capsule.reads.some((read) => read.includes('@')) ? handedAt(root, reader, roleOf, look, d.place) : [d.place]).map((coordinate) => ({ place: coordinate, text: observeText(resolve(root, coordinate)) ?? '' })),
+                        }))).map((answer) => {
+                            if (answer?.kind !== 'fact')
+                                throw new Error(`REFUSE·reader ${reader.module} · ${answer?.why ?? 'no capsule answer'}`);
+                            return (answer.claims ?? []);
+                        })
+                        : runReader(module, root, due.map((d) => ({ place: d.place, ...(reader.kind === 'js' ? { text: new TextDecoder().decode(d.bytes) } : {}), held: heldOf(d.place, d.region) })), readerLifetime(standing.flatMap(line => { const p = parseLifetime(line); return p.kind === 'fact' ? [p.value.fields] : []; }), reader.module));
                 }
-                for (const place of plan.places) {
-                    const mine = servedAt(plan.shard, by, place, plan.prior);
-                    out.push(...(mine.length || before === undefined ? mine : servedAt(plan.shard, before, place, lastOf(plan.shard, before, plan.places))));
+                catch (error) {
+                    const why = `REFUSE·reader ${reader.module} · ${error instanceof Error ? error.message : String(error)}`;
+                    refused.push(why);
+                    process.stderr.write(`${why}\n`);
+                    return false;
                 }
+                if (rows.every((mine) => !mine.length) && !readerAllowsEmpty(standing.flatMap(line => { const p = parseLifetime(line); return p.kind === 'fact' ? [p.value.fields] : []; }), reader.module)) {
+                    const why = `REFUSE·reader ${reader.module} · answered none of ${due.length} places · nothing landed, they stay due`;
+                    refused.push(why);
+                    process.stderr.write(`${why}\n`);
+                    return false;
+                }
+                ran += due.length;
+                process.stderr.write(`READER   ${reader.module} · ${due.length} run · ${Date.now() - at} ms\n`);
+                const fresh = new Map();
+                due.forEach((d, i) => fresh.set(d.place, (rows[i] ?? []).map((row) => lineOf(row, d.digest, by, speaker))));
+                for (const plan of plans.filter((one) => one.said === undefined)) {
+                    const mine = new Set(plan.due.map((d) => d.place));
+                    const stay = [...new Set(plan.pairs.filter((pair) => !mine.has(pair.slice(0, pair.indexOf(' ')))).map((pair) => pair.slice(pair.indexOf(' ') + 1)))];
+                    const said = [...stay.flatMap((one) => plan.prior?.get(one) ?? []), ...[...mine].flatMap((place) => fresh.get(place) ?? [])];
+                    keepObservation(store, plan.key, said);
+                    landShard(store, speaker, plan.region, [...plan.kept, pointer(speaker, by, plan.region, plan.key, plan.pairs)]);
+                    out.push(...plan.kept, ...said);
+                }
+                const spent = Date.now() - at;
+                const over = bytesDigest(store, new TextEncoder().encode(due.map((d) => d.digest).sort().join('\n'))).replace(/^sha256:/, '');
+                level.push(canonical({ scope: `cost/reader/${reader.module}`, role: 'writes', form: 'interval', measure: 'ms', value: `${spent}..${spent}`, by: `${speaker}:${by}`, at: `place:${over}` }));
+                if (lineage.at(-1) !== by)
+                    level.push(canonical({ scope: `reader/${reader.module}`, role: 'writes', form: 'alphabet', measure: 'identity', value: by, by: `${speaker}:${by}`, at: `place:${by}` }));
+                rmSync(storeAt(store, 'pending', by), { force: true });
             }
-            const marker = storeAt(store, 'pending', by);
-            const pid = Number((observeText(marker) ?? '').split('\n')[1]);
-            const running = existsSync(marker) && Date.now() - statSync(marker).mtimeMs < 30 * 60 * 1000 && Number.isInteger(pid) && pid > 0 && alive(pid);
-            if (!running) {
-                mkdirSync(dirname(marker), { recursive: true });
-                const child = spawn(process.execPath, [...childFlags(), processOf('observe'), root, reader.module], { cwd: root, detached: true, stdio: 'ignore' });
-                child.unref();
-                writeFileSync(marker, `${reader.module}\n${child.pid ?? ''}\n`);
+            for (const plan of plans.filter((one) => one.said !== undefined)) {
+                if (!plan.found)
+                    keepObservation(store, plan.key, plan.said);
+                if (plan.shard.keys.get(by) !== plan.key || plan.kept.some((line) => plan.shard.places.get(`${by} ${fieldOf(line, 'scope')}`)?.line !== line)) {
+                    landShard(store, speaker, plan.region, [...plan.kept, pointer(speaker, by, plan.region, plan.key, plan.pairs)]);
+                }
+                out.push(...plan.kept, ...plan.said);
             }
-            behind.push({ module: reader.module, places: due.length });
-            process.stderr.write(`GREY     reading: ${reader.module} · ${due.length} places · runs behind${running ? ', already running' : ''}\n`);
             if (level.length)
                 landShard(store, speaker, home, level);
             if (Date.now() - started > 250)
-                spent.push(`${reader.module.split('/').pop()} behind ${Date.now() - started}`);
+                spent.push(`${reader.module.split('/').pop()} ${identified - started}+${Date.now() - identified}`);
+            if (kept !== undefined)
+                landMemo(store, `observed/${kept}`, new TextEncoder().encode(out.slice(mark).join('\n')));
             return false;
         }
-        if (due.length) {
-            const at = Date.now();
-            let rows;
-            try {
-                rows = reader.capsule !== undefined && asked !== undefined
-                    ? asked.ask(due.map((d) => ({
-                        protocol: PROTOCOL, verb: 'read', rootScope: d.place, region: reader.capsule.region, held: heldOf(d.place, d.region),
-                        files: (reader.capsule.reads.some((read) => read.includes('@')) ? handedAt(root, reader, roleOf, look, d.place) : [d.place]).map((coordinate) => ({ place: coordinate, text: observeText(resolve(root, coordinate)) ?? '' })),
-                    }))).map((answer) => {
-                        if (answer?.kind !== 'fact')
-                            throw new Error(`REFUSE·reader ${reader.module} · ${answer?.why ?? 'no capsule answer'}`);
-                        return (answer.claims ?? []);
-                    })
-                    : runReader(module, root, due.map((d) => ({ place: d.place, ...(reader.kind === 'js' ? { text: new TextDecoder().decode(d.bytes) } : {}), held: heldOf(d.place, d.region) })));
-            }
-            catch (error) {
-                const why = `REFUSE·reader ${reader.module} · ${error instanceof Error ? error.message : String(error)}`;
-                refused.push(why);
-                process.stderr.write(`${why}\n`);
-                return false;
-            }
-            if (rows.every((mine) => !mine.length)) {
-                const why = `REFUSE·reader ${reader.module} · answered none of ${due.length} places · nothing landed, they stay due`;
-                refused.push(why);
-                process.stderr.write(`${why}\n`);
-                return false;
-            }
-            ran += due.length;
-            process.stderr.write(`READER   ${reader.module} · ${due.length} run · ${Date.now() - at} ms\n`);
-            const fresh = new Map();
-            due.forEach((d, i) => fresh.set(d.place, (rows[i] ?? []).map((row) => lineOf(row, d.digest, by, speaker))));
-            for (const plan of plans.filter((one) => one.said === undefined)) {
-                const mine = new Set(plan.due.map((d) => d.place));
-                const stay = [...new Set(plan.pairs.filter((pair) => !mine.has(pair.slice(0, pair.indexOf(' ')))).map((pair) => pair.slice(pair.indexOf(' ') + 1)))];
-                const said = [...stay.flatMap((one) => plan.prior?.get(one) ?? []), ...[...mine].flatMap((place) => fresh.get(place) ?? [])];
-                keepObservation(store, plan.key, said);
-                landShard(store, speaker, plan.region, [...plan.kept, pointer(speaker, by, plan.region, plan.key, plan.pairs)]);
-                out.push(...plan.kept, ...said);
-            }
-            const spent = Date.now() - at;
-            const over = bytesDigest(store, new TextEncoder().encode(due.map((d) => d.digest).sort().join('\n'))).replace(/^sha256:/, '');
-            level.push(canonical({ scope: `cost/reader/${reader.module}`, role: 'writes', form: 'interval', measure: 'ms', value: `${spent}..${spent}`, by: `${speaker}:${by}`, at: `place:${over}` }));
-            if (lineage.at(-1) !== by)
-                level.push(canonical({ scope: `reader/${reader.module}`, role: 'writes', form: 'alphabet', measure: 'identity', value: by, by: `${speaker}:${by}`, at: `place:${by}` }));
-            rmSync(storeAt(store, 'pending', by), { force: true });
-        }
-        for (const plan of plans.filter((one) => one.said !== undefined)) {
-            if (!plan.found)
-                keepObservation(store, plan.key, plan.said);
-            if (plan.shard.keys.get(by) !== plan.key || plan.kept.some((line) => plan.shard.places.get(`${by} ${fieldOf(line, 'scope')}`)?.line !== line)) {
-                landShard(store, speaker, plan.region, [...plan.kept, pointer(speaker, by, plan.region, plan.key, plan.pairs)]);
-            }
-            out.push(...plan.kept, ...plan.said);
+        finally {
+            endAct();
         }
-        if (level.length)
-            landShard(store, speaker, home, level);
-        if (Date.now() - started > 250)
-            spent.push(`${reader.module.split('/').pop()} ${identified - started}+${Date.now() - identified}`);
-        if (kept !== undefined)
-            landMemo(store, `observed/${kept}`, new TextEncoder().encode(out.slice(mark).join('\n')));
-        return false;
     }
     if (spent.length)
         process.stderr.write(`SPENT    observe ${spent.join(' · ')} ms\n`);
     if (legacy)
         setAside(store, speaker);
     process.stderr.write(`OBSERVE  ${ran} run · ${read} read by key${whole_ ? ` · ${whole_} readers kept whole` : ''} · ${Date.now() - began} ms\n`);
+    if (wait && refused.length)
+        throw new Error(refused.join('\n'));
     return [...new Set(out)].sort();
 }

package/dist/fold/readers.d.ts

@@ -1,3 +1,4 @@
+import type { Capsule } from '../host/capsule.ts';
 import type { CoordinateRole } from './wire.ts';
 import { capsulesFor } from './reach.ts';
 import type { Kind } from '../observe/run.ts';
@@ -8,6 +9,7 @@ export interface ReaderClaim {
     readonly module: string;
     readonly kind: Kind;
     readonly capsule?: {
+        readonly selected?: Capsule;
         readonly digest: string;
         readonly entry: string;
         readonly region: string;

package/dist/fold/readers.js

@@ -62,13 +62,13 @@ export function capsuleReadersOf(root, store, standing, lines, resolve = capsule
             const pkg = fieldOf(by?.offer ?? '', 'scope').split('/')[1] ?? '';
             if (by === undefined || reaching.has(`${pkg} ${region} ${where || '/'}`))
                 continue;
-            const key = `${by.capsule.digest} ${region}`;
-            const group = groups.get(key) ?? groups.set(key, { module: `${pkg}/${region}`, digest: by.capsule.digest, entry: fieldOf(by.offer, 'shape'), region, reads: by.capsule.declaration.regions[region] ?? [], globs: new Map() }).get(key);
+            const key = `${by.capsule.selection ?? by.capsule.digest} ${region}`;
+            const group = groups.get(key) ?? groups.set(key, { module: `${pkg}/${region}`, digest: by.capsule.digest, entry: fieldOf(by.offer, 'shape'), selected: by.capsule, region, reads: by.capsule.declaration.regions[region] ?? [], globs: new Map() }).get(key);
             group.globs.set(where, fieldOf(line, 'value').split('|').filter(Boolean));
         }
     }
     return [...groups.values()].map((group) => ({ id: group.module, shape: ['run'], where: [...group.globs.keys()], module: group.module, kind: 'process',
-        capsule: { digest: group.digest, entry: group.entry, region: group.region, reads: group.reads, globs: group.globs } }));
+        capsule: { selected: group.selected, digest: group.digest, entry: group.entry, region: group.region, reads: group.reads, globs: group.globs } }));
 }
 export function handedAt(root, reader, roleOf, look, place) {
     const { reads, globs } = reader.capsule;

package/dist/fold/resolved.js

@@ -95,20 +95,24 @@ export function keepCarried(store, lines, from) {
  * the caller refuses rather than read the lines that only name it.
  */
 export function carriedFrom(store, shipped) {
-    const named = shipped.find((line) => fieldOf(line, 'scope') === 'receipts' && fieldOf(line, 'measure') === 'digest');
+    // Signed receipts inside the observed set are evidence, not its framing.
+    const headerOf = (line) => fieldOf(line, 'scope') === 'receipts' && fieldOf(line, 'measure') === 'digest' && fieldOf(line, 'by') === 'bound' && !fieldOf(line, 'sig');
+    const named = shipped.find(headerOf);
     if (named === undefined)
         return shipped;
     // Resolution 8 may precede its authenticated summary in the same public file.
     // It is evidence only if its exact bytes meet the summary's carrier digest.
     for (let i = 1; i < shipped.length; i += 1) {
         const header = shipped[i];
-        if (fieldOf(header, 'scope') !== 'receipts' || fieldOf(header, 'measure') !== 'digest')
+        if (!headerOf(header))
             continue;
         const digest = fieldOf(header, 'at').replace(/^place:sha256:/, '');
         const body = shipped.slice(0, i);
         if (/^[0-9a-f]{64}$/.test(digest) && createHash('sha256').update(body.map(line => `${line}\n`).join('')).digest('hex') === digest)
             return body;
     }
+    if (shipped.indexOf(named) > 0)
+        throw Error('REFUSE·receipt public carrier bytes mismatch; a cached carrier cannot replace supplied evidence');
     const hex = fieldOf(named, 'at').replace(/^place:(?:sha256:)?/, '');
     const text = /^[0-9a-f]{64}$/.test(hex) ? verifiedCarried(storeAt(store, 'cas', 'carried', hex), hex) : undefined;
     return text === undefined ? undefined : text.split('\n').filter(isWire);

package/dist/host/act-cost.d.ts

@@ -0,0 +1,13 @@
+/** A sequence of declared acts is not one act. Unpartitioned host work still has a cost. */
+export declare class ActCosts {
+    private readonly began;
+    private occupied;
+    private largest;
+    private depth;
+    private readonly clock;
+    constructor(clock?: () => number);
+    begin(): () => void;
+    measure<T>(work: () => T): T;
+    seconds(): number;
+}
+export declare const actCosts: ActCosts;

package/dist/host/act-cost.js

@@ -0,0 +1,25 @@
+/** A sequence of declared acts is not one act. Unpartitioned host work still has a cost. */
+export class ActCosts {
+    constructor(clock = () => performance.now()) {
+        this.occupied = 0;
+        this.largest = 0;
+        this.depth = 0;
+        this.clock = clock;
+        this.began = clock();
+    }
+    begin() {
+        const started = this.clock(), outer = this.depth++ === 0;
+        let closed = false;
+        return () => { if (closed)
+            throw Error('Act measurement closed twice'); closed = true; const elapsed = Math.max(0, this.clock() - started); this.depth--; this.largest = Math.max(this.largest, elapsed); if (outer)
+            this.occupied += elapsed; };
+    }
+    measure(work) { const end = this.begin(); try {
+        return work();
+    }
+    finally {
+        end();
+    } }
+    seconds() { return Math.max(0, Math.round(Math.max(this.largest, this.clock() - this.began - this.occupied) / 1000)); }
+}
+export const actCosts = new ActCosts();

package/dist/host/adapters/modules/javascript.d.ts

@@ -0,0 +1 @@
+export declare function moduleImports(source: string, coordinate: string): readonly string[];

package/dist/host/adapters/modules/javascript.js

@@ -0,0 +1,48 @@
+import * as nodeModule from 'node:module';
+import { extname } from 'node:path';
+/** Host module syntax, never wire or domain interpretation. Reading imports executes no module. */
+// The package's minimum Node runtime provides this API; older build-only Node types do not.
+const require = nodeModule.createRequire(import.meta.url);
+const { parse } = require('acorn');
+const stripTypeScriptTypes = nodeModule.stripTypeScriptTypes;
+export function moduleImports(source, coordinate) {
+    const code = extname(coordinate) === '.ts' ? stripTypeScriptTypes(source, { mode: 'transform' }) : source;
+    let tree;
+    try {
+        tree = parse(code, { ecmaVersion: 'latest', sourceType: 'module', allowReturnOutsideFunction: true, allowHashBang: true });
+    }
+    catch {
+        throw Error('REFUSE·source module syntax cannot be read: ' + coordinate);
+    }
+    const found = new Set();
+    const literal = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        const n = node;
+        return n['type'] === 'Literal' && typeof n['value'] === 'string' ? n['value'] : undefined;
+    };
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        if (Array.isArray(node)) {
+            for (const child of node)
+                visit(child);
+            return;
+        }
+        const n = node;
+        let specifier;
+        if (n['type'] === 'ImportDeclaration' || n['type'] === 'ExportNamedDeclaration' || n['type'] === 'ExportAllDeclaration' || n['type'] === 'ImportExpression')
+            specifier = literal(n['source']);
+        if (n['type'] === 'CallExpression') {
+            const callee = n['callee'];
+            if (callee?.['type'] === 'Identifier' && callee['name'] === 'require')
+                specifier = literal(n['arguments'][0]);
+        }
+        if (specifier !== undefined)
+            found.add(specifier);
+        for (const child of Object.values(n))
+            visit(child);
+    };
+    visit(tree);
+    return [...found];
+}

package/dist/host/adapters/transport/http.d.ts

@@ -0,0 +1,5 @@
+/** Reference HTTP adapter. Location and budgets are already selected by admitted host policy. */
+export declare function fetchBytes(location: string, limits: {
+    readonly timeoutMs: number;
+    readonly responseBytes: number;
+}): Promise<Uint8Array>;

package/dist/host/adapters/transport/http.js

@@ -0,0 +1,28 @@
+/** Reference HTTP adapter. Location and budgets are already selected by admitted host policy. */
+export async function fetchBytes(location, limits) {
+    const signal = AbortSignal.timeout(limits.timeoutMs), response = await fetch(location, { signal });
+    if (!response.ok)
+        throw Error(`HTTP ${response.status}`);
+    const reader = response.body?.getReader();
+    if (!reader)
+        return new Uint8Array();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            size += part.value.length;
+            if (size > limits.responseBytes) {
+                await reader.cancel();
+                throw Error('response exceeds declared byte bound');
+            }
+            chunks.push(part.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks);
+}