@lapxo/bound 0.1.8 → 0.2.0

package/dist/host/reading-closures.js

@@ -5,12 +5,53 @@ 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' }));
+/** One portable native receipt carrier shared by file plans and native capsule batches. */
+export function portableReadingReceipt(scope, by, closure, output, hash, modern = true, costs = []) {
+    const input = hash(closure), payload = hash(output), rows = output.split('\n').filter(Boolean);
+    return [...(modern ? [canonical({ scope: receiptScope(scope), role: 'writes', form: 'alphabet', measure: 'digest', value: readingReceiptIdentity(input, payload, bytes => hash(new TextDecoder().decode(bytes))), by, at: 'place:' + input })] : []), canonical({ scope, role: 'writes', form: 'alphabet', measure: 'observed', value: payload, by, at: 'place:' + payload }), canonical({ scope, role: 'writes', form: 'alphabet', measure: 'bytes', value: input, by, at: 'place:' + input, about: closure }), canonical({ scope, role: 'writes', form: 'interval', measure: 'count', value: `${rows.length}..${rows.length}`, by, at: 'place:' + payload, about: output }), ...costs];
+}
 /** 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 +59,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 +97,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 +121,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 +130,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,22 +139,24 @@ 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 && plan.resolution !== 1)
+                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 => {
-                    const f = fields(line), id = f.measure === 'bytes' ? f.value : f.measure === 'count' ? (f.at ?? '').replace(/^place:/, '') : undefined;
-                    if (id === undefined)
-                        return line;
-                    const bytes = load(id);
-                    if (bytes === undefined)
-                        throw Error('REFUSE·receipt missing verified carrier ' + id);
-                    // The full-resolution native row carries the actual verified UTF-8 bytes.
-                    // Its semantic count/digest is unchanged; a public copy needs no private CAS.
-                    return canonical({ ...f, about: bytes });
-                });
-                out.push(canonical({ scope, role: 'writes', form: 'alphabet', measure: 'observed', value: payload, by, at: 'place:' + payload }), ...native);
+                const output = load(payload);
+                if (output === undefined)
+                    throw Error('REFUSE·receipt missing verified carrier ' + payload);
+                const costs = shardLines(store, speaker, journal).filter(line => fieldOf(line, 'scope') === scope && fieldOf(line, 'measure') === 's' && fieldOf(line, 'at') === 'place:' + input);
+                out.push(...portableReadingReceipt(scope, by, closure, output, hash, !!context, costs));
             }
         });
     }
@@ -116,7 +165,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 +188,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 {};

package/dist/host/reading-context.js

@@ -0,0 +1,53 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createHash } from 'node:crypto';
+import { readFileSync, realpathSync } from 'node:fs';
+import { release } from 'node:os';
+import { readingIdentityBytes } from '@lapxo/topos/contract';
+const active = new AsyncLocalStorage();
+export const readingBoundary = active.getStore.bind(active);
+export function withReadingBoundary(identity, execution, run) {
+    if (execution) {
+        const algorithm = identity.split(':')[0];
+        const hash = (text) => algorithm + ':' + createHash(algorithm).update(text).digest('hex');
+        const expected = readingEnvironment(hash, execution.env, execution.cwd, execution.flags);
+        const named = [...execution.context.environment].sort(([a], [b]) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+        if (JSON.stringify([...expected].sort(([a], [b]) => Buffer.compare(Buffer.from(a), Buffer.from(b)))) !== JSON.stringify(named))
+            throw Error('REFUSE·reading execution environment differs from its identity');
+    }
+    return active.run({ identity, execution }, run);
+}
+/** References commit the actual inherited boundary. Values are hashed, never
+ * carried as environment secrets. No empty map is substituted for unknown input. */
+// The running runtime is resolved once for this act; mutable input bytes are not
+// stored in this slot. Later processes establish their own runtime reference.
+const runtimes = new Map();
+const runtimeOf = (algorithm) => { const held = runtimes.get(algorithm); if (held)
+    return held; const digest = algorithm + ':' + createHash(algorithm).update(readFileSync(process.execPath)).digest('hex'); runtimes.set(algorithm, digest); return digest; };
+export function readingEnvironment(hash, env = process.env, cwd = process.cwd(), flags = process.execArgv) {
+    const inherited = Object.entries(env).filter((entry) => entry[1] !== undefined);
+    return [
+        ['variables', hash(JSON.stringify(inherited.sort(([a], [b]) => Buffer.compare(Buffer.from(a), Buffer.from(b)))))],
+        ['cwd', hash(realpathSync(cwd))], ['flags', hash(JSON.stringify(flags))],
+        ['runtime', runtimeOf(hash('').split(':')[0])],
+        ['platform', hash(JSON.stringify([process.platform, process.arch, process.versions, release()]))],
+    ];
+}
+export function readingProfile(lines, field) {
+    const values = (scope) => lines.filter(line => field(line, 'scope') === scope && field(line, 'role') === 'writes' && field(line, 'value') !== 'withdraw');
+    const contexts = values('wire/reading-context'), receipts = values('wire/reading-receipt');
+    if (!contexts.length && !receipts.length)
+        return false;
+    if (contexts.length !== 1 || receipts.length !== 1 || field(contexts[0], 'value') !== 'reading-context@1' || field(receipts[0], 'value') !== 'reading-receipt@1')
+        throw Error('REFUSE·reading identity ambiguous or incomplete profiles');
+    return true;
+}
+/** The caller supplies verified implementation and transitive references. This
+ * constructor adds the process boundary that the host will actually hand over. */
+export function readingExecution(input, hash, boundary = { env: process.env, cwd: process.cwd(), flags: process.execArgv }) {
+    const env = Object.fromEntries(Object.entries(boundary.env).filter((entry) => entry[1] !== undefined));
+    const cwd = boundary.cwd, flags = Object.freeze([...boundary.flags]);
+    Object.freeze(env);
+    const context = { ...input, environment: readingEnvironment(hash, env, cwd, flags) };
+    readingIdentityBytes(context);
+    return { context, env, cwd, flags };
+}

package/dist/host/reference-authenticated.d.ts

@@ -0,0 +1,28 @@
+import { authorityOf, validateObjectContext } from '@lapxo/topos/wire';
+type ObjectContext = Parameters<typeof validateObjectContext>[1];
+type Signer = Parameters<typeof authorityOf>[1][number];
+export interface ReferenceTrust {
+    readonly snapshot: string;
+    readonly epoch: number;
+    readonly proofScope: string;
+    readonly policy: string;
+    readonly formImplementation: string;
+    readonly signers: readonly Signer[];
+    readonly algorithms: readonly string[];
+    readonly objects: ObjectContext;
+    readonly maxBytes: number;
+    readonly maxRecords: number;
+    readonly digestBytes: (bytes: Uint8Array) => string | Promise<string>;
+    readonly verifyBytes: (bytes: string, key: string, signature: string, algorithms: readonly string[]) => boolean | Promise<boolean>;
+    readonly fetchBytes: (source: string, blob: string) => Promise<Uint8Array>;
+}
+/** Prospective authenticated-standing@1 host composition; no effects and no authority from transport. */
+export declare function inspectAuthenticatedReference(fragment: string, trust: ReferenceTrust): Promise<{
+    reference: import("./reference-profile.ts").StandingReference;
+    records: readonly import("@lapxo/topos/wire").ObjectRecord[];
+    semanticIdentity: string;
+    authorityContextIdentity: string;
+    semanticStanding: string;
+    originalRecords: readonly string[];
+}>;
+export { encodeReference, decodeReference } from './reference-profile.ts';

package/dist/host/reference-authenticated.js

@@ -0,0 +1,84 @@
+import { parse, canonical, authorityOf, authorityAtEpoch, signedBytes, objectHistory, validateObjectContext } from '@lapxo/topos/wire';
+import { cellInputs } from '@lapxo/topos/cell-inputs';
+import { semanticStandingBytes } from '@lapxo/topos/standing';
+import { decodeReference } from "./reference-profile.js";
+function fail(why) { throw Error('REFUSE·authenticated-reference ' + why); }
+const utf8 = (s) => new TextEncoder().encode(s);
+/** Prospective authenticated-standing@1 host composition; no effects and no authority from transport. */
+export async function inspectAuthenticatedReference(fragment, trust) {
+    if (new Set(trust.signers.map(s => s.id)).size !== trust.signers.length)
+        fail('duplicate host signer');
+    const reference = decodeReference(fragment);
+    if (!Number.isSafeInteger(trust.maxBytes) || trust.maxBytes < 1 || !Number.isSafeInteger(trust.maxRecords) || trust.maxRecords < 1)
+        fail('resource budget');
+    const received = await trust.fetchBytes(reference.source, reference.blob);
+    if (received.byteLength > trust.maxBytes)
+        fail('bytes budget');
+    if (typeof SharedArrayBuffer !== 'undefined' && received.buffer instanceof SharedArrayBuffer)
+        fail('shared transport bytes');
+    const bytes = new Uint8Array(received);
+    if (await trust.digestBytes(bytes) !== reference.blob)
+        fail('blob integrity');
+    const text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    let packet;
+    try {
+        packet = JSON.parse(text);
+    }
+    catch {
+        fail('carrier framing');
+    }
+    if (!Array.isArray(packet) || packet.length !== 3 || packet[0] !== 'authenticated-standing@1' || !Array.isArray(packet[1]) || packet[1].length < 1 || packet[1].length > trust.maxRecords || packet[1].some((x) => typeof x !== 'string') || typeof packet[2] !== 'string' || JSON.stringify(packet) + '\n' !== text)
+        fail('carrier framing');
+    const originals = packet[1], proofLine = packet[2];
+    const parsed = [...originals, proofLine].map(line => { const p = parse(line); if (p.kind !== 'fact' || canonical(p.value.fields) !== line)
+        fail('original canonical'); return p.value.fields; });
+    const proof = parsed[parsed.length - 1];
+    if (proof.scope !== trust.proofScope || proof.at !== 'witness:' + trust.snapshot || proof.role !== 'writes' || proof.form !== 'alphabet' || proof.measure !== 'digest' || proof.epoch !== String(trust.epoch))
+        fail('untrusted snapshot binding');
+    if (proof.value !== await trust.digestBytes(utf8(JSON.stringify(['authenticated-standing@1', originals]) + '\n')))
+        fail('snapshot commitment');
+    // Async crypto port is called on exact native signed bytes; authorityOf consumes only those results.
+    const verifiedCrypto = new Set();
+    const key = (f, pub) => JSON.stringify([signedBytes(f), pub, f.sig, trust.algorithms]);
+    for (const f of parsed)
+        for (const s of trust.signers)
+            if (s.id === f.by && await trust.verifyBytes(signedBytes(f), s.publicKey, f.sig, trust.algorithms))
+                verifiedCrypto.add(key(f, s.publicKey));
+    const verifies = (f, pub) => verifiedCrypto.has(key(f, pub));
+    const authentic = authorityOf(proof, trust.signers, verifies);
+    if (authentic.kind !== 'admitted')
+        fail('proof ' + authentic.kind + ' ' + authentic.why);
+    const signer = trust.signers.find(s => s.id === proof.by);
+    if (!signer)
+        fail('proof signer');
+    const current = authorityAtEpoch(proof, signer, trust.epoch, trust.proofScope, 'authority');
+    if (current.kind !== 'admitted')
+        fail('current proof ' + current.kind + ' ' + current.why);
+    const verified = new Set();
+    for (let i = 0; i < originals.length; i++) {
+        const admitted = authorityOf(parsed[i], trust.signers, verifies);
+        if (admitted.kind !== 'admitted')
+            fail('original ' + admitted.kind + ' ' + admitted.why);
+        verified.add(originals[i]);
+    }
+    const history = objectHistory(originals);
+    if (history.kind !== 'fact')
+        fail('wire ' + history.why);
+    if (history.value.configuration.some(f => f.value === 'withdraw'))
+        fail('configuration history requires admitted standing fold');
+    const context = { ...trust.objects, admit: (r) => verified.has(canonical(r.fields)) && trust.objects.admit(r) };
+    const checked = validateObjectContext(history.value.objects, context);
+    if (checked.kind !== 'fact')
+        throw Error('REFUSE·' + checked.why);
+    const membership = new Set([...cellInputs(checked.value, 'semantic-live@2').values()].flat().map(l => semanticStandingBytes([l])));
+    const fields = (line) => { const p = parse(line); if (p.kind !== 'fact')
+        fail('original parse'); return p.value.fields; };
+    const effective = [...originals].sort((a, b) => Number(fields(a).epoch) - Number(fields(b).epoch));
+    const live = effective.filter(line => { const f = fields(line); return f.type === undefined || membership.has(semanticStandingBytes([line])); });
+    const semantic = semanticStandingBytes(live), semanticIdentity = await trust.digestBytes(utf8(semantic));
+    if (semanticIdentity !== 'sha256:' + reference.digest)
+        fail('standing identity');
+    const authorityContextIdentity = await trust.digestBytes(utf8(JSON.stringify(['reference-inspection-trust@1', trust.snapshot, trust.epoch, trust.proofScope, trust.policy, trust.formImplementation, trust.signers, trust.algorithms])));
+    return { reference, records: checked.value, semanticIdentity, authorityContextIdentity, semanticStanding: semantic, originalRecords: originals };
+}
+export { encodeReference, decodeReference } from "./reference-profile.js";

package/dist/host/reference-native.d.ts

@@ -0,0 +1,10 @@
+export declare function authenticatedReferenceSelected(standing: readonly string[]): boolean;
+export declare function openAuthenticatedReference(root: string, fragment: string): Promise<{
+    readings: readonly import("../engine/object.ts").ObjectReading[];
+    reference: import("./reference-profile.ts").StandingReference;
+    records: readonly import("@lapxo/topos/wire").ObjectRecord[];
+    semanticIdentity: string;
+    authorityContextIdentity: string;
+    semanticStanding: string;
+    originalRecords: readonly string[];
+}>;

package/dist/host/reference-native.js

@@ -0,0 +1,50 @@
+/** Native ports for authenticated #bound opening; trusted policy belongs to the selected local place. */
+import { sha256 as hash, isSha256 } from "./hash.js";
+import { canonical, parse, transportSelection } from '@lapxo/topos/wire';
+import { semanticStandingBytes } from '@lapxo/topos/standing';
+import { authorityFor, rootSigner } from "../fold/signers.js";
+import { eraOf } from "../fold/digests.js";
+import { lockStanding, lockLines } from "../fold/keys.js";
+import { signedOwnerLines } from "../cli/owner.js";
+import { admittedObjects } from "./objects.js";
+import { storeOf } from "../land/ledger.js";
+import { objectFold } from "../engine/index.js";
+import { toposAt, contentAt } from "./selected-topos.js";
+import { transportBytes } from "./ports/transport.js";
+import { decodeReference } from "./reference-profile.js";
+import { inspectAuthenticatedReference } from "./reference-authenticated.js";
+import { verifyBytes } from "./adapters/keys/ed25519.js";
+export function authenticatedReferenceSelected(standing) {
+    const selected = standing.flatMap(line => { const p = parse(line); return p.kind === 'fact' && p.value.fields.scope === 'reference/authentication' ? [p.value.fields] : []; });
+    if (!selected.length)
+        return false;
+    if (selected.length !== 1 || selected[0].value !== 'authenticated-standing@1')
+        throw Error('REFUSE·reference conflicting or unknown authentication profile');
+    return true;
+}
+export async function openAuthenticatedReference(root, fragment) {
+    const store = storeOf(root), standing = lockStanding(store), era = eraOf(standing), authority = authorityFor(lockLines(store), rootSigner(root), era.admitted);
+    if (!authenticatedReferenceSelected(standing))
+        throw Error('REFUSE·reference no admitted authenticated-standing@1 profile');
+    const one = (scope) => { const found = standing.flatMap(line => { const p = parse(line); return p.kind === 'fact' && p.value.fields.scope === scope ? [{ line, fields: p.value.fields }] : []; }); if (found.length !== 1 || found[0].fields.role !== 'writes' || found[0].fields.measure !== 'id' || authority.of(found[0].line).kind !== 'admitted')
+        throw Error('REFUSE·reference missing, conflicting or unauthenticated ' + scope); return found[0].fields.value; };
+    if (one('reference/authentication') !== 'authenticated-standing@1')
+        throw Error('REFUSE·reference authentication profile');
+    const snapshot = one('reference/snapshot'), epochText = one('reference/epoch'), proofScope = one('reference/proof-scope'), recordsText = one('reference/records');
+    if (!isSha256(snapshot) || !/^\d+$/.test(epochText) || !Number.isSafeInteger(Number(epochText)) || !/^\d+$/.test(recordsText) || !Number.isSafeInteger(Number(recordsText)) || Number(recordsText) < 1 || !proofScope)
+        throw Error('REFUSE·reference authority snapshot or resource contract');
+    const reference = decodeReference(fragment);
+    // Provider selection is made from HOST-declared cells/configuration, never carrier-picked code.
+    const held = await admittedObjects(root, signedOwnerLines(store), () => { }, true);
+    if (!held.records.some(r => r.record === 'cell'))
+        throw Error('REFUSE·reference host has no declared object interpretation');
+    const context = held.context, policy = held.configuration.map(fields => canonical(fields)), selection = transportSelection(held.configuration, new URL(reference.source).protocol.slice(0, -1));
+    if (!selection)
+        throw Error('REFUSE·reference no admitted transport policy');
+    const implementations = [...new Set(held.records.filter(r => r.record === 'cell').map(r => r.fields.topos))].sort().map(pin => { const selected = toposAt(pin, store), selectors = selected.parts.filter(f => f.scope === 'wire/topos/context-view'); if (selectors.length !== 1)
+        throw Error('REFUSE·reference host context selector'); const offers = selected.parts.filter(f => f.kind === 'check' && f.view === selectors[0].value); if (offers.length !== 1)
+        throw Error('REFUSE·reference host context offer'); const offer = offers[0], closure = [...new Set((offer.restsOn ?? '').split('|').filter(Boolean))].sort(); for (const digest of closure)
+        contentAt(digest, store); return [pin, offer.value, closure]; });
+    const result = await inspectAuthenticatedReference(fragment, { snapshot, epoch: Number(epochText), proofScope, policy: hash(semanticStandingBytes(policy)), formImplementation: hash(JSON.stringify(implementations)), signers: authority.admitted, algorithms: era.admitted, objects: context, maxBytes: selection.responseBytes, maxRecords: Number(recordsText), digestBytes: hash, verifyBytes, fetchBytes: (source, blob) => transportBytes(source, blob, policy) });
+    return { ...result, readings: objectFold(result.records, context) };
+}

package/dist/host/reference-profile.d.ts

@@ -0,0 +1,23 @@
+/** reference-profile@1: platform URL parsing, no authority or transport effects. */
+export interface StandingReference {
+    readonly class: 'standing';
+    readonly algorithm: 'sha256';
+    readonly digest: string;
+    readonly blob: string;
+    readonly source: string;
+}
+interface InspectionPort {
+    readonly maxBytes: number;
+    readonly readSemanticStanding: (bytes: string) => readonly string[];
+    readonly semanticStandingBytes: (lines: readonly string[]) => string;
+    readonly digestBytes: (bytes: Uint8Array) => string;
+}
+export declare function encodeReference(reference: StandingReference): string;
+export declare function decodeReference(fragment: string): StandingReference;
+export declare function inspectReferenceBytes(reference: StandingReference, bytes: Uint8Array, { maxBytes, readSemanticStanding, semanticStandingBytes, digestBytes }: InspectionPort): {
+    reference: StandingReference;
+    lines: readonly string[];
+    standing: string;
+    authentication: string;
+};
+export {};

package/dist/host/reference-profile.js

@@ -0,0 +1,62 @@
+const hex = /^[0-9a-f]{64}$/;
+const refuse = (cause) => { throw Error(`REFUSE·reference ${cause}`); };
+const keys = ['class', 'algorithm', 'digest', 'blob', 'source'];
+function check(reference) {
+    if (Object.keys(reference).length !== keys.length || keys.some(key => !Object.prototype.hasOwnProperty.call(reference, key)))
+        refuse('fields');
+    if (reference.class !== 'standing')
+        refuse('unknown class');
+    if (reference.algorithm !== 'sha256')
+        refuse('unknown algorithm');
+    if (!hex.test(reference.digest) || !/^sha256:[0-9a-f]{64}$/.test(reference.blob))
+        refuse('digest');
+    let source;
+    try {
+        source = new URL(reference.source);
+    }
+    catch {
+        return refuse('source URL');
+    }
+    if (source.username || source.password || source.hash)
+        refuse('source credentials or fragment');
+    if (source.href !== reference.source)
+        refuse('noncanonical source URL');
+    return reference;
+}
+export function encodeReference(reference) {
+    check(reference);
+    return '#bound:1?' + keys.map(key => key + '=' + encodeURIComponent(reference[key])).join('&');
+}
+export function decodeReference(fragment) {
+    if (!fragment.startsWith('#bound:1?'))
+        refuse('profile');
+    const parameters = new URLSearchParams(fragment.slice('#bound:1?'.length));
+    if ([...parameters].length !== keys.length || new Set(parameters.keys()).size !== keys.length)
+        refuse('duplicate or missing field');
+    const reference = check(Object.fromEntries(parameters));
+    if (encodeReference(reference) !== fragment)
+        refuse('noncanonical encoding');
+    return Object.freeze(reference);
+}
+export function inspectReferenceBytes(reference, bytes, { maxBytes, readSemanticStanding, semanticStandingBytes, digestBytes }) {
+    if (bytes.byteLength > maxBytes)
+        refuse('bytes budget');
+    if (digestBytes(bytes) !== reference.blob.slice(7))
+        refuse('blob integrity');
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
+    catch {
+        refuse('document');
+    }
+    if (document === null || typeof document !== 'object' || document.profile !== 'semantic-standing@1' || typeof document.standing !== 'string' || Object.keys(document).length !== 2)
+        refuse('document profile');
+    if (new TextDecoder('utf-8', { fatal: true }).decode(bytes) !== JSON.stringify({ profile: document.profile, standing: document.standing }))
+        refuse('noncanonical document wrapper');
+    const lines = readSemanticStanding(document.standing);
+    const semantic = semanticStandingBytes(lines);
+    if (digestBytes(new TextEncoder().encode(semantic)) !== reference.digest)
+        refuse('standing identity');
+    return { reference, lines, standing: semantic, authentication: 'not demonstrated; inspect only' };
+}

package/dist/host/reference.d.ts

@@ -0,0 +1,6 @@
+export declare function inspectReference(fragment: string, policy: readonly string[]): Promise<{
+    reference: import("./reference-profile.ts").StandingReference;
+    lines: readonly string[];
+    standing: string;
+    authentication: string;
+}>;

package/dist/host/reference.js

@@ -0,0 +1,24 @@
+/** Host composition. Location supplies bytes, never identity or authority. No store writes. */
+import { createHash } from 'node:crypto';
+import { readSemanticStanding, semanticStandingBytes } from '@lapxo/topos/core';
+import { parse, transportSelection } from '@lapxo/topos/wire';
+import { transportBytes } from "./ports/transport.js";
+import { decodeReference, inspectReferenceBytes } from "./reference-profile.js";
+export async function inspectReference(fragment, policy) {
+    const reference = decodeReference(fragment), scheme = new URL(reference.source).protocol.slice(0, -1);
+    const fields = policy.flatMap(line => { const got = parse(line); return got.kind === 'fact' ? [got.value.fields] : []; });
+    const selected = transportSelection(fields, scheme);
+    if (selected === undefined)
+        throw Error(`REFUSE·transport ${scheme} no admitted content-request/1 policy`);
+    let bytes;
+    try {
+        bytes = await transportBytes(reference.source, reference.blob, policy);
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error.message : 'transport failed';
+        if (cause.startsWith('REFUSE·'))
+            throw error;
+        throw Error(`REFUSE·transport ${scheme} ${cause}`);
+    }
+    return inspectReferenceBytes(reference, bytes, { maxBytes: selected.responseBytes, readSemanticStanding, semanticStandingBytes, digestBytes: value => createHash('sha256').update(value).digest('hex') });
+}