@lapxo/bound 0.1.8 → 0.1.9

package/dist/host/ports/place-act.js

@@ -0,0 +1,169 @@
+import { existsSync, readdirSync, statSync, openSync, fstatSync, readSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { readPlaceActContext, verifyPlaceActContext, placeActReceiptsOf } from '@lapxo/topos/core';
+import { underAuthorityRegions, underTheRegions, underRootProjection } from "../../land/act.js";
+import { requireEffects } from "../read-only.js";
+import { publishBundle, nativePublicationStorage } from "./publication.js";
+const fail = (why) => { throw Error('REFUSE·place act ' + why); };
+const clock = (n) => { if (!/^(0|[1-9][0-9]*)$/.test(n) || !Number.isSafeInteger(Number(n)))
+    fail('unknown receiver clock'); return Number(n); };
+const rootBytes = (r) => JSON.stringify([r.namespace, r.snapshot, r.epoch, r.prefix, r.head, r.policies]);
+const budget = (b) => { if (!b || !Number.isSafeInteger(b.acts) || b.acts < 1 || !Number.isSafeInteger(b.bytes) || b.bytes < 1)
+    fail('missing storage budget'); };
+const base = (store) => join(store, 'ledger', 'place-acts');
+const at = (store, id) => { if (!id || id.includes('\0'))
+    fail('missing identity'); return join(base(store), 'committed-' + encodeURIComponent(id)); };
+function storedInventory(store, b) {
+    budget(b);
+    if (!existsSync(base(store)))
+        return { names: [], bytes: 0 };
+    const names = readdirSync(base(store)).filter(n => n.startsWith('committed-'));
+    if (names.length > b.acts)
+        fail('stored act budget');
+    let bytes = 0;
+    for (const name of names)
+        for (const member of ['context.json', 'receipts.json', 'originals.json']) {
+            const stat = statSync(join(base(store), name, member));
+            if (!stat.isFile() || (bytes += stat.size) > b.bytes)
+                fail('stored aggregate byte budget');
+        }
+    return { names, bytes };
+}
+function readBundle(path, b) {
+    budget(b);
+    let bytes = 0;
+    const read = (name) => {
+        const fd = openSync(join(path, name), 'r');
+        try {
+            const size = fstatSync(fd);
+            if (!size.isFile() || size.size > b.bytes - bytes)
+                fail('stored byte budget');
+            const data = Buffer.alloc(size.size);
+            let read = 0;
+            while (read < data.length) {
+                const count = readSync(fd, data, read, data.length - read, null);
+                if (!count)
+                    fail('stored member changed while reading');
+                read += count;
+            }
+            if (readSync(fd, Buffer.alloc(1), 0, 1, null) !== 0)
+                fail('stored member changed while reading');
+            bytes += read;
+            return new TextDecoder('utf-8', { fatal: true }).decode(data);
+        }
+        finally {
+            closeSync(fd);
+        }
+    };
+    try {
+        const context = read('context.json'), receipts = JSON.parse(read('receipts.json')), originals = JSON.parse(read('originals.json'));
+        return { context, receipts, originals };
+    }
+    catch (e) {
+        if (e instanceof Error && e.message.startsWith('REFUSE·'))
+            throw e;
+        return fail('committed bundle unreadable');
+    }
+}
+function authenticated(bundle, id, contract) {
+    const result = placeActReceiptsOf(bundle.context, bundle.receipts, contract), decoded = readPlaceActContext(bundle.context, contract.budget);
+    if (result.identity !== id || JSON.stringify(bundle.originals) !== JSON.stringify(decoded.places.map(p => p.records)))
+        fail('stored original/context identity mismatch');
+    return decoded;
+}
+/** Historical result reads never produce a current authorization permit. */
+export function placeActResult(store, id, trust, limits) {
+    const path = at(store, id);
+    if (!existsSync(path))
+        return undefined;
+    const bundle = readBundle(path, limits);
+    authenticated(bundle, id, trust.historical(bundle.context));
+    return bundle;
+}
+/** Each receiver chain advances independently. Initial heads are explicit,
+ * authenticated host inputs, not inferred zero or legacy global epochs. */
+export function placeActHeads(store, initial, trust, limits) {
+    budget(limits);
+    if (!initial.length || new Set(initial.map(h => h.place)).size !== initial.length)
+        fail('missing/ambiguous initial heads');
+    const heads = new Map(initial.map(h => { clock(h.epoch); if (!h.identity)
+        fail('missing initial head'); return [h.place, { ...h }]; }));
+    if (!existsSync(base(store)))
+        return [...heads.values()];
+    const { names } = storedInventory(store, limits);
+    const pending = names.map(name => { const id = decodeURIComponent(name.slice(10)), bundle = readBundle(join(base(store), name), limits); const context = authenticated(bundle, id, trust.historical(bundle.context)); if (context.root.namespace !== trust.contract.root.namespace)
+        fail('stored clock namespace mismatch'); return { id, context }; });
+    while (pending.length) {
+        const next = pending.findIndex(a => a.context.places.every(p => heads.get(p.place)?.identity === p.previous));
+        if (next < 0)
+            fail('receiver chain fork or missing predecessor');
+        const act = pending.splice(next, 1)[0];
+        for (const p of act.context.places) {
+            const prior = heads.get(p.place);
+            const epoch = clock(prior.epoch) + 1;
+            if (!Number.isSafeInteger(epoch) || clock(p.epoch) !== epoch)
+                fail('receiver chain clock mismatch');
+            heads.set(p.place, { place: p.place, identity: act.id, epoch: p.epoch });
+        }
+    }
+    return [...heads.values()];
+}
+/** Context, exact original bytes and complete signed receipts have one visibility
+ * point. Real Root guard exclusion spans final authority/head comparison and
+ * publication; this does not activate a CLI profile or reinterpret local-act@1. */
+export async function commitPlaceAct(store, encoded, receipts, trust, limits, storage = nativePublicationStorage) {
+    requireEffects('place act commitment');
+    budget(limits);
+    const decoded = readPlaceActContext(encoded, trust.contract.budget), id = trust.contract.digest(encoded);
+    const regions = decoded.places.map(p => { if (p.place === '.')
+        return ''; const parts = p.place.split('/'); if (parts.length < 2 || parts.pop() !== 'TARGET.bound' || parts.some(s => s === '' || s === '.' || s === '..'))
+        fail('unknown place namespace'); return parts.join('/'); });
+    const enter = regions.includes('') ? underTheRegions : underAuthorityRegions;
+    return enter(store, regions, 'place act', () => underRootProjection(store, 'place act publication', () => {
+        const prior = placeActResult(store, id, trust, limits);
+        if (prior) {
+            if (prior.context !== encoded)
+                fail('replay bytes differ');
+            // Replay authenticates the supplied evidence too. Historical authentication
+            // grants no current authority and leaves the committed result unchanged.
+            placeActReceiptsOf(encoded, receipts, trust.historical(encoded));
+            return { ...prior, identity: id, kind: 'once' };
+        }
+        const verified = verifyPlaceActContext(encoded, trust.contract);
+        placeActReceiptsOf(encoded, receipts, trust.contract);
+        const originals = decoded.places.map(p => p.records), files = { 'context.json': encoded, 'receipts.json': JSON.stringify(receipts) + '\n', 'originals.json': JSON.stringify(originals) + '\n' };
+        const inventory = storedInventory(store, limits);
+        if (inventory.bytes + Object.values(files).reduce((n, v) => n + Buffer.byteLength(v), 0) > limits.bytes)
+            fail('publication byte budget');
+        if (inventory.names.length >= limits.acts)
+            fail('publication act budget');
+        const current = trust.current();
+        if (rootBytes(current.root) !== rootBytes(verified.dependencies))
+            fail('authority changed before publication');
+        if (new Set(current.heads.map(h => h.place)).size !== current.heads.length)
+            fail('ambiguous receiver heads');
+        const storedHeads = placeActHeads(store, trust.initialHeads, trust, limits);
+        for (const p of decoded.places) {
+            const actual = storedHeads.find(h => h.place === p.place), selected = current.heads.find(h => h.place === p.place);
+            if (!actual || !selected || actual.identity !== selected.identity || actual.epoch !== selected.epoch)
+                fail('receiver snapshot is not committed head ' + p.place);
+        }
+        for (const p of decoded.places) {
+            const head = current.heads.find(h => h.place === p.place) ?? fail('missing receiver head ' + p.place);
+            if (head.identity !== p.previous)
+                fail('receiver head moved ' + p.place);
+            const next = clock(head.epoch) + 1;
+            if (!Number.isSafeInteger(next) || clock(p.epoch) !== next)
+                fail('receiver epoch not next ' + p.place);
+        }
+        publishBundle(at(store, id), files, storage);
+        return { context: encoded, receipts, originals, identity: id, kind: 'landed' };
+    }));
+}
+/** Enumerates only committed, historically authenticated carriers. Namespace
+ * projection is a caller's separate pure operation, never current permission. */
+export function committedPlaceActResults(store, trust, limits) {
+    const { names } = storedInventory(store, limits);
+    return names.map(name => { const identity = decodeURIComponent(name.slice(10)), bundle = placeActResult(store, identity, trust, limits); if (!bundle)
+        fail('committed carrier vanished'); return { identity, bundle: bundle }; });
+}

package/dist/host/process-lifetime.js

@@ -2,11 +2,16 @@ import { spawnSync } from 'node:child_process';
 import { processOf } from "../observe/runner.js";
 /** A synchronous fold waits on a supervising host process; the supervisor owns cancellation of its child group. */
 export function boundedProcess(command, args, input, limits, cwd, env) {
-    const run = spawnSync(process.execPath, [processOf('lifetime', 'host')], { input: JSON.stringify({ command, args, input, limits, cwd, env }), encoding: 'utf8', maxBuffer: limits.responseBytes * 12 + 4096 });
+    if (!Number.isSafeInteger(limits.timeoutMs) || limits.timeoutMs <= 0 || !Number.isSafeInteger(limits.responseBytes) || limits.responseBytes <= 0)
+        throw Error('REFUSE·reader invalid process limits');
+    // The same monotonic deadline covers handoff, input and execution. Starting a
+    // fresh timer after stdin closes would leave the handoff outside the policy.
+    const deadline = process.hrtime.bigint() + BigInt(limits.timeoutMs) * 1000000n;
+    const run = spawnSync(process.execPath, [processOf('lifetime', 'host'), String(deadline), String(limits.responseBytes)], { input: JSON.stringify({ command, args, input, limits, cwd, env }), encoding: 'utf8', maxBuffer: limits.responseBytes * 12 + 4096 });
     if (run.error || run.status !== 0)
-        throw Error(`REFUSE·reader lifetime supervisor ${run.error?.message ?? run.status}`);
+        throw Error(`REFUSE·reader lifetime supervisor ${run.error?.message ?? run.signal ?? run.status}`);
     const result = JSON.parse(run.stdout);
     if (result.failure)
-        throw Error(`REFUSE·reader ${result.failure} · status ${result.status ?? result.signal ?? 'cancelled'}`);
+        throw Error(`REFUSE·reader ${result.failure} · status ${result.status ?? result.signal ?? 'cancelled'}${result.stderr ? ' · child stderr: ' + result.stderr : ''}`);
     return result;
 }

package/dist/host/provide.d.ts

@@ -19,5 +19,30 @@ export declare function resolvePinned(specifier: string, context: ResolveContext
     readonly json: string;
     readonly exports: boolean;
 }): ResolveResult;
+/** Fixed execution selects libraries by the instrument's explicit local mount,
+ * before opening any artifact. An alias or package-name guess grants nothing. */
+export declare function selectNativeDependencies(root: string, dependencies: readonly string[], manifest: string): readonly {
+    line: string;
+    library: {
+        readonly name: string;
+        readonly manifest: string;
+        readonly coordinate?: string;
+    };
+}[] | undefined;
+/** A declared artifact is not automatically an active Node library. This fixed
+ * assertion reuses only the packages selected by the actual host boundary. */
+export declare function reuseNativeResolution(pins: readonly {
+    pkg: string;
+    at: string;
+}[]): boolean;
+/** Read one resolved archive's manifest; a selected fixed library cannot vanish
+ * into the optional historical provider path when its archive is absent. */
+export declare function readProvidedPin(name: string, at: string, file: string, requiredName?: string): {
+    at: string;
+    pkg: string;
+    exports: boolean;
+    href: string;
+    json: string;
+} | undefined;
 export declare function provide(): void;
 export {};

package/dist/host/provide.js

@@ -6,7 +6,9 @@ import { fieldOf } from "../fold/claims.js";
 import { observeText } from "../observe/files.js";
 import { ownLock, ownStore, ownRoot } from "../observe/runner.js";
 import { runtimeTreeAt } from "./release.js";
+import { ContentNeeded } from "./content-needed.js";
 import { theWord } from "../fold/wire.js";
+const findPackageJSON = nodeModule.findPackageJSON;
 const registerHooks = nodeModule.registerHooks;
 const taken = (exp) => (typeof exp === 'string' ? exp : exp && typeof exp === 'object' && 'default' in exp && typeof exp.default === 'string' ? exp.default : '');
 /**
@@ -53,29 +55,129 @@ export function resolvePinned(specifier, context, nextResolve, pin) {
  * blob's folder.
  */
 let hooked = false;
+function nativeResolution() {
+    const installed = Object.getOwnPropertyDescriptor(globalThis, Symbol.for('bound.native.resolution@1'));
+    if (!installed)
+        return undefined;
+    const capability = installed.value;
+    if (installed.configurable !== false || installed.writable !== false || !capability || !Object.isFrozen(capability) || capability.profile !== 'fixed-native-resolution@1' || !Array.isArray(capability.libraryNames) || !Object.isFrozen(capability.libraryNames) || capability.libraryNames.some(name => typeof name !== 'string') || !Array.isArray(capability.libraries) || !Object.isFrozen(capability.libraries) || capability.libraries.some(lib => !lib || !Object.isFrozen(lib) || typeof lib.name !== 'string' || typeof lib.manifest !== 'string') || typeof capability.assertPins !== 'function')
+        throw Error('REFUSE·pin fixed resolution capability invalid');
+    return capability;
+}
+/** Fixed execution selects libraries by the instrument's explicit local mount,
+ * before opening any artifact. An alias or package-name guess grants nothing. */
+export function selectNativeDependencies(root, dependencies, manifest) {
+    const capability = nativeResolution();
+    if (!capability)
+        return undefined;
+    if (dependencies.length && capability.libraries.some(library => typeof library.coordinate !== 'string' || !library.coordinate))
+        throw Error('REFUSE·pin fixed resolution logical library coordinate missing');
+    const selected = new Map(capability.libraries.map(library => [library.coordinate, library]));
+    return dependencies.flatMap(line => {
+        const mount = fieldOf(line, 'needs');
+        if (!mount)
+            return [];
+        const library = selected.get(mount.replace(/\/+$/, '') + '/' + manifest);
+        if (!library)
+            return [];
+        let actual;
+        try {
+            actual = realpathSync(join(root, mount, manifest));
+        }
+        catch {
+            throw Error('REFUSE·pin selected library mount absent ' + library.name);
+        }
+        if (actual !== library.manifest)
+            throw Error('REFUSE·pin selected library mount differs ' + library.name);
+        return [{ line, library }];
+    });
+}
+/** A declared artifact is not automatically an active Node library. This fixed
+ * assertion reuses only the packages selected by the actual host boundary. */
+export function reuseNativeResolution(pins) {
+    const capability = nativeResolution();
+    if (!capability)
+        return false;
+    const selected = new Set(capability.libraryNames);
+    // The fixed preload owns this closed assertion. Package names select which
+    // declared pins participate; exact manifests and member bytes still decide.
+    capability.assertPins(pins.filter(pin => selected.has(pin.pkg)).map(pin => ({ name: pin.pkg, at: pin.at })));
+    return true;
+}
+/** Read one resolved archive's manifest; a selected fixed library cannot vanish
+ * into the optional historical provider path when its archive is absent. */
+export function readProvidedPin(name, at, file, requiredName) {
+    if (!at) {
+        if (requiredName !== undefined)
+            throw Error('REFUSE·pin fixed resolution requires declared library ' + name);
+        return undefined;
+    }
+    const manifest = JSON.parse(observeText(join(at, file)) ?? '{}'), pkg = typeof manifest.name === 'string' ? manifest.name : '';
+    if (requiredName !== undefined && pkg !== requiredName)
+        throw Error('REFUSE·pin fixed resolution library name differs ' + name);
+    return pkg ? { at, pkg, exports: Object.prototype.hasOwnProperty.call(manifest, 'exports'), href: pathToFileURL(at).href, json: pathToFileURL(join(at, file)).href } : undefined;
+}
 export function provide() {
     if (hooked)
         return;
-    hooked = true;
-    const pins = ownLock()
-        .filter((line) => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'role') === 'reads')
-        .flatMap((line) => {
-        const name = fieldOf(line, 'scope').slice('dep/'.length);
-        const at = pinPlace(name);
-        const pkg = pinName(name);
-        const file = manifestOf();
-        const manifest = JSON.parse(observeText(join(at, file)) ?? '{}');
-        return at && pkg ? [{ at, pkg, exports: Object.prototype.hasOwnProperty.call(manifest, 'exports'), href: pathToFileURL(at).href, json: pathToFileURL(join(at, file)).href }] : [];
+    const dependencies = ownLock().filter((line) => fieldOf(line, 'scope').startsWith('dep/') && fieldOf(line, 'role') === 'reads');
+    const file = manifestOf(), selected = selectNativeDependencies(ownRoot(), dependencies, file);
+    const load = (line, requiredName) => {
+        const name = fieldOf(line, 'scope').slice('dep/'.length), at = pinPlace(name);
+        if (!at)
+            throw new ContentNeeded(fieldOf(line, 'value'), 'REFUSE·pin declared library unavailable ' + name);
+        const pin = readProvidedPin(name, at, file, requiredName);
+        if (!pin)
+            throw Error('REFUSE·pin declared library unavailable ' + name);
+        return pin;
+    };
+    if (selected !== undefined) {
+        reuseNativeResolution(selected.map(({ line, library }) => load(line, library.name)));
+        hooked = true;
+        return;
+    }
+    // A mount selects a library, but its manifest is only a routing hint until
+    // an import requests it. The selected archive alone supplies executable bytes.
+    const mounts = dependencies.filter(line => fieldOf(line, 'needs') !== '').map(line => {
+        const mount = join(ownRoot(), fieldOf(line, 'needs'));
+        const manifest = JSON.parse(observeText(join(mount, file)) ?? '{}');
+        return { line, mount, pkg: typeof manifest.name === 'string' ? manifest.name : '' };
     });
+    const verified = new Map();
     registerHooks({
         resolve(specifier, context, nextResolve) {
             if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.includes(':'))
                 return nextResolve(specifier, context);
-            const parent = context.parentURL ?? '';
-            const pin = pins.find((one) => specifier === one.pkg || specifier.startsWith(`${one.pkg}/`));
-            if (pin === undefined || parent.startsWith(pin.href))
+            let selected = mounts.find(one => one.pkg && (specifier === one.pkg || specifier.startsWith(one.pkg + '/')));
+            if (!selected) {
+                // Identify the installed package before following its executable entry:
+                // a renamed manifest and an escaping entry cannot bypass the declared mount.
+                let manifest;
+                try {
+                    manifest = findPackageJSON(specifier, pathToFileURL(join(ownRoot(), file)).href);
+                }
+                catch { }
+                if (manifest)
+                    selected = mounts.find(one => {
+                        try {
+                            return realpathSync(join(one.mount, file)) === realpathSync(manifest);
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+            }
+            if (!selected)
                 return nextResolve(specifier, context);
+            let pin = verified.get(selected.line);
+            if (!pin) {
+                pin = load(selected.line);
+                verified.set(selected.line, pin);
+            }
+            if (specifier !== pin.pkg && !specifier.startsWith(pin.pkg + '/'))
+                throw Error('REFUSE·pin selected library name differs');
             return resolvePinned(specifier, context, nextResolve, pin);
         },
     });
+    hooked = true;
 }

package/dist/host/reading-closures.d.ts

@@ -1,5 +1,14 @@
 import type { ReaderLifetime, ReaderReference } from '@lapxo/topos/wire';
 import type { Capsule } from './capsule.ts';
+import { snapshotAccess } from '@lapxo/topos/contract';
+import type { ReadingIdentityContext, Snapshot, ResponseContext } from '@lapxo/topos/contract';
+import type { ReadingExecution, ReadingReference } from './reading-context.ts';
+export interface CurrentReading {
+    readonly snapshot: Snapshot;
+    readonly kept: ResponseContext;
+    readonly current: ResponseContext;
+    readonly permission: Parameters<typeof snapshotAccess>[3];
+}
 type File = {
     readonly place: string;
     readonly text: string;
@@ -18,7 +27,12 @@ export declare function readingClosures(options: {
     readerReference?: ReaderReference;
     lifetime?: ReaderLifetime;
     allowsEmpty?: boolean;
+    context?: ReadingIdentityContext;
+    execution?: ReadingExecution;
+    current?: CurrentReading;
     files: readonly File[];
+    livePlace?: () => readonly string[];
+    assertCurrent?: () => void;
     emit?: (line: string) => void;
 }): {
     lines: readonly string[];
@@ -27,5 +41,5 @@ export declare function readingClosures(options: {
     executed: number;
 };
 /** Verify the native reading carriers before a file seal may reuse them. These are semantic receipts, not file-region seals. */
-export declare function verifiedReadingReceipts(store: string, lines: readonly string[], digest: (text: string) => string): number | undefined;
+export declare function verifiedReadingReceipts(store: string, lines: readonly string[], digest: (text: string) => string, environment?: readonly ReadingReference[] | ((context: ReadingIdentityContext) => readonly ReadingReference[] | undefined), requireContext?: boolean): number | undefined;
 export {};

package/dist/host/reading-closures.js

@@ -5,12 +5,48 @@ import { canonical, parse, PROTOCOL, byBytes } from '@lapxo/topos/wire';
 import { replaceWhole, landShard, shardLines } from "../land/ledger.js";
 import { fieldOf } from "../fold/claims.js";
 import { readOnly } from "./read-only.js";
+import { readingIdentityBytes, readingReceiptIdentity, responseIdentity, snapshotAccess, placeInputs, withPlaceInputs } from '@lapxo/topos/contract';
+import { withReadingBoundary } from "./reading-context.js";
+const receiptScope = (scope) => [scope, 'identity'].join('/');
 const fields = (line) => { const got = parse(line); if (got.kind !== 'fact')
     throw Error('REFUSE·input projection contains a non-wire line'); return got.value.fields; };
 export const inputLines = (files) => files.map(file => canonical({ scope: file.place, form: 'alphabet', measure: 'text', role: 'writes', value: 'lock', shape: file.place, about: file.text, by: 'host', at: 'policy:handed-input' }));
 /** The selected world owns input projection and reading. The host only verifies closures and keeps native count/bytes receipts. */
 export function readingClosures(options) {
     const { root, store, reader, speaker, digest: hash, capsule, region, projection, files } = options, emit = options.emit ?? (() => { });
+    options.assertCurrent?.();
+    if (options.context)
+        readingIdentityBytes(options.context);
+    let access = [];
+    if (options.current) {
+        if (!options.context)
+            throw Error('REFUSE·current reading requires a declared identity');
+        const { snapshot, kept, current, permission } = options.current;
+        if (current.implementation !== options.context.implementation)
+            throw Error('REFUSE·current reading implementation differs from its verified context');
+        const response = responseIdentity(snapshot, current, hash), allowed = snapshotAccess(snapshot, kept, current, permission, hash);
+        if (!allowed.inspect || !allowed.reuse)
+            throw Error('REFUSE·current reading is not admitted for reuse');
+        access = [['response', response], ['permission', hash(JSON.stringify([permission.inspect, permission.reuse, permission.freshness]))]];
+    }
+    if (options.execution && (!options.context || JSON.stringify(readingIdentityBytes(options.execution.context)) !== JSON.stringify(readingIdentityBytes(options.context))))
+        throw Error('REFUSE·reading execution differs from declared context');
+    const projectionFor = (name) => {
+        if (!capsule.selectedWorld)
+            return undefined;
+        const { standing, offer } = capsule.selectedWorld;
+        const selectors = standing.parts.some(part => part.scope === `${offer}/place-inputs/${name}` && part.measure === 'reads');
+        if (!selectors)
+            return undefined;
+        if (!options.context || !options.execution || !options.livePlace)
+            throw Error('REFUSE·place inputs require authenticated shadow and reading context ' + name);
+        return placeInputs(standing, offer, name, options.livePlace(), bytes => hash(new TextDecoder().decode(bytes)));
+    };
+    const projectedPlace = projectionFor(projection), readingPlace = projectionFor(region);
+    const commit = (context, name, place) => place && context ? withPlaceInputs(context, JSON.stringify(['place-inputs', capsule.selectedWorld.offer, name]), place) : context;
+    const ask = (identity, requests, context = options.context) => withReadingBoundary(identity, options.execution && context ? { ...options.execution, context } : options.execution, () => capsule.ask(requests, options.readerReference));
+    const projectionContext = commit(options.context, projection, projectedPlace);
+    const base = projectionContext ? hash(new TextDecoder().decode(readingIdentityBytes(projectionContext))) : '';
     const algorithm = hash('').split(':')[0], handed = new Map(files.map(file => [file.place, file.text]));
     if (handed.size !== files.length)
         throw Error('REFUSE·input projection has duplicate handed coordinates');
@@ -18,7 +54,7 @@ export function readingClosures(options) {
         if (!readFileSync(join(root, file.place)).equals(Buffer.from(file.text)))
             throw Error('REFUSE·input changed ' + file.place); };
     verify();
-    const projected = capsule.ask([{ protocol: PROTOCOL, verb: 'render', rootScope: '', region: projection, at: 1, reads: ['**'], lines: inputLines(files), files: [] }], options.readerReference)[0];
+    const projected = ask(base, [{ ...(projectedPlace ? { place: projectedPlace } : {}), protocol: PROTOCOL, verb: 'render', rootScope: '', region: projection, at: 1, reads: ['**'], lines: inputLines(files), files: [] }], projectionContext)[0];
     if (projected?.kind !== 'fact' || !Array.isArray(projected.lines))
         throw Error('REFUSE·input projection ' + (projected?.why ?? 'no lines'));
     const plans = new Map();
@@ -56,7 +92,12 @@ export function readingClosures(options) {
     let read = 0, opened = 0, executed = 0;
     for (const plan of ordered) {
         actCosts.measure(() => {
-            const closure = [plan.line, canonical({ scope: 'implementation', role: 'writes', form: 'alphabet', measure: 'digest', value: identity, by: 'host', at: 'policy:input-identity' }), ...plan.inputs.map(input => canonical({ scope: input, role: 'writes', form: 'alphabet', measure: 'digest', value: hash(handed.get(input)), by: 'host', at: 'policy:input-identity' })), ...plan.needs.map(need => canonical({ scope: need, role: 'writes', form: 'alphabet', measure: 'digest', value: results.get(need).digest, by: 'host', at: 'policy:input-identity' }))].sort(byBytes).join('\n') + '\n';
+            // Retained evidence does not authorize a current answer.
+            options.assertCurrent?.();
+            const legacyClosure = [plan.line, canonical({ scope: 'implementation', role: 'writes', form: 'alphabet', measure: 'digest', value: identity, by: 'host', at: 'policy:input-identity' }), ...plan.inputs.map(input => canonical({ scope: input, role: 'writes', form: 'alphabet', measure: 'digest', value: hash(handed.get(input)), by: 'host', at: 'policy:input-identity' })), ...plan.needs.map(need => canonical({ scope: need, role: 'writes', form: 'alphabet', measure: 'digest', value: results.get(need).digest, by: 'host', at: 'policy:input-identity' }))].sort(byBytes).join('\n') + '\n';
+            const leafContext = commit(options.context, region, readingPlace);
+            const context = leafContext && { ...leafContext, policy: hash(JSON.stringify([leafContext.policy, options.allowsEmpty === true, options.lifetime ?? null, options.readerReference ?? null, capsule.selection ?? null, capsule.lines])), inputs: [...[...leafContext.inputs, ...access].map(([name, digest]) => [JSON.stringify(['context', name]), digest]), [JSON.stringify(['plan']), hash(plan.line)], ...plan.inputs.map(input => [JSON.stringify(['file', input]), hash(handed.get(input))]), ...plan.needs.map(need => [JSON.stringify(['receipt', need]), results.get(need).digest])] };
+            const closure = context ? new TextDecoder().decode(readingIdentityBytes(context)) : legacyClosure;
             const input = hash(closure), scope = 'receipts/readings/' + hash(plan.scope).split(':')[1] + '/' + input.split(':')[1], matching = prior.filter(line => fieldOf(line, 'scope') === scope && fieldOf(line, 'measure') === 'bytes' && fieldOf(line, 'value') === input).at(-1);
             const count = matching && prior.filter(line => fieldOf(line, 'scope') === scope && fieldOf(line, 'measure') === 'count' && fieldOf(line, 'by') === by).at(-1);
             const heldOutput = count && load(fieldOf(count, 'at').replace(/^place:/, ''));
@@ -75,7 +116,7 @@ export function readingClosures(options) {
                 if (readOnly())
                     throw Error('REFUSE·preview reading closure is unpaid ' + plan.scope);
                 const started = process.hrtime.bigint();
-                const dependencies = plan.needs.flatMap(need => results.get(need).lines), answer = capsule.ask([{ protocol: PROTOCOL, verb: 'read', rootScope: plan.scope, name: plan.scope, region, at: plan.resolution, reads: ['**'], lines: [...inputLines(plan.inputs.map(place => ({ place, text: handed.get(place) }))), ...dependencies], files: [] }], options.readerReference)[0];
+                const dependencies = plan.needs.flatMap(need => results.get(need).lines), answer = ask(input, [{ ...(readingPlace ? { place: readingPlace } : {}), protocol: PROTOCOL, verb: 'read', rootScope: plan.scope, name: plan.scope, region, at: plan.resolution, reads: ['**'], lines: [...inputLines(plan.inputs.map(place => ({ place, text: handed.get(place) }))), ...dependencies], files: [] }], context)[0];
                 if (answer?.kind !== 'fact' || !Array.isArray(answer.claims))
                     throw Error('REFUSE·reading ' + plan.scope + ' · ' + (answer?.why ?? 'no claims'));
                 lines = answer.claims.map((unknown) => { if (typeof unknown?.scope !== 'string' || typeof unknown?.measure !== 'string' || typeof unknown?.role !== 'string' || !unknown.bound || !['interval', 'enumerated'].includes(unknown.bound.kind))
@@ -84,6 +125,7 @@ export function readingClosures(options) {
                     throw Error('REFUSE·reading empty response is not admitted ' + plan.scope);
                 executed++;
                 verify();
+                options.assertCurrent?.();
                 payload = saved(lines.length ? [...lines].sort(byBytes).join('\n') + '\n' : '');
                 if (saved(closure) !== input)
                     throw Error('REFUSE·receipt input closure mismatch');
@@ -92,8 +134,17 @@ export function readingClosures(options) {
                 if (plan.resolution === 1)
                     opened++;
             }
-            results.set(plan.scope, { digest: payload, lines });
-            out.push(canonical({ scope: plan.scope, role: 'writes', form: 'alphabet', measure: 'observed', value: input, by, at: 'place:' + input }), ...lines);
+            const receipt = context ? readingReceiptIdentity(input, payload, bytes => hash(new TextDecoder().decode(bytes))) : payload;
+            if (context)
+                out.push(canonical({ scope: receiptScope(scope), role: 'writes', form: 'alphabet', measure: 'digest', value: receipt, by, at: 'place:' + input }));
+            results.set(plan.scope, { digest: receipt, lines });
+            out.push(canonical({ scope: plan.scope, role: 'writes', form: 'alphabet', measure: 'observed', value: input, by, at: 'place:' + input }), 
+            // A logical reading name is not a physical input coordinate. Preserve the
+            // host-verified handoff beside the result so portable file seals retain
+            // every input, including explicitly read foreign files.
+            // Input witnesses do not locate the result at each input. Result attribution
+            // remains the logical reading's place; two inputs are not two new origins.
+            ...plan.inputs.map(coordinate => canonical({ scope: coordinate, role: 'writes', form: 'alphabet', measure: 'observed', value: hash(handed.get(coordinate)), by, at: 'witness:' + input })), ...lines);
             if (plan.resolution === 1) {
                 read++;
                 const native = shardLines(store, speaker, journal).filter(line => fieldOf(line, 'scope') === scope && ((fieldOf(line, 'measure') === 'bytes' && fieldOf(line, 'value') === input) || (fieldOf(line, 'measure') === 'count') || (fieldOf(line, 'measure') === 's' && fieldOf(line, 'at') === 'place:' + input))).map(line => {
@@ -116,7 +167,7 @@ export function readingClosures(options) {
     return { lines: out, read, opened, executed };
 }
 /** Verify the native reading carriers before a file seal may reuse them. These are semantic receipts, not file-region seals. */
-export function verifiedReadingReceipts(store, lines, digest) {
+export function verifiedReadingReceipts(store, lines, digest, environment, requireContext = false) {
     const units = lines.filter(line => fieldOf(line, 'scope').startsWith('receipts/readings/') && fieldOf(line, 'measure') === 'bytes' && fieldOf(line, 'role') === 'writes');
     const load = (id, row) => {
         const hex = id.split(':')[1];
@@ -139,6 +190,37 @@ export function verifiedReadingReceipts(store, lines, digest) {
         const count = counts[0], output = load(fieldOf(count, 'at').replace(/^place:/, ''), count);
         if (output === undefined)
             return;
+        const inputBytes = load(input, unit);
+        if (inputBytes.trimStart().startsWith('[')) {
+            let context;
+            try {
+                context = JSON.parse(inputBytes);
+            }
+            catch {
+                return;
+            }
+            if (!Array.isArray(context) || context.length !== 6 || context[0] !== 'reading-context@1')
+                return;
+            const canonicalContext = { instrument: context[1], implementation: context[2], policy: context[3], inputs: context[4], environment: context[5] };
+            try {
+                if (new TextDecoder().decode(readingIdentityBytes(canonicalContext)) !== inputBytes)
+                    return;
+            }
+            catch {
+                return;
+            }
+            if (environment) {
+                const expected = typeof environment === 'function' ? environment(canonicalContext) : environment;
+                if (expected === undefined || JSON.stringify([...expected].sort((a, b) => byBytes(a[0], b[0]))) !== JSON.stringify(context[5]))
+                    return;
+            }
+            const identity = lines.filter(line => fieldOf(line, 'scope') === receiptScope(scope) && fieldOf(line, 'measure') === 'digest' && fieldOf(line, 'by') === by && fieldOf(line, 'role') === 'writes' && fieldOf(line, 'at') === 'place:' + input);
+            const expected = readingReceiptIdentity(input, fieldOf(count, 'at').replace(/^place:/, ''), bytes => digest(new TextDecoder().decode(bytes)));
+            if (identity.length !== 1 || fieldOf(identity[0], 'value') !== expected)
+                return;
+        }
+        else if (requireContext || !inputBytes.endsWith('\n') || inputBytes.split('\n').filter(Boolean).some(line => parse(line).kind !== 'fact'))
+            return;
         const rows = output.split('\n').filter(Boolean);
         if (fieldOf(count, 'value') !== `${rows.length}..${rows.length}` || rows.some(line => fieldOf(line, 'by') !== by || fieldOf(line, 'at') !== 'place:' + input))
             return;

package/dist/host/reading-context.d.ts

@@ -0,0 +1,29 @@
+import type { ReadingIdentityContext } from '@lapxo/topos/contract';
+export type ReadingReference = readonly [string, string];
+export interface ReadingExecution {
+    readonly context: ReadingIdentityContext;
+    readonly env: Readonly<Record<string, string>>;
+    readonly cwd: string;
+    readonly flags: readonly string[];
+}
+interface Boundary {
+    readonly identity: string;
+    readonly execution?: ReadingExecution;
+}
+export declare const readingBoundary: () => Boundary | undefined;
+export declare function withReadingBoundary<T>(identity: string, execution: ReadingExecution | undefined, run: () => T): T;
+export declare function readingEnvironment(hash: (text: string) => string, env?: Readonly<Record<string, string | undefined>>, cwd?: string, flags?: readonly string[]): readonly ReadingReference[];
+export declare function readingProfile(lines: readonly string[], field: (line: string, name: string) => string): boolean;
+/** The caller supplies verified implementation and transitive references. This
+ * constructor adds the process boundary that the host will actually hand over. */
+export declare function readingExecution(input: {
+    instrument: string;
+    implementation: string;
+    policy: string;
+    inputs: readonly ReadingReference[];
+}, hash: (text: string) => string, boundary?: {
+    env: Readonly<Record<string, string | undefined>>;
+    cwd: string;
+    flags: readonly string[];
+}): ReadingExecution;
+export {};