@lapxo/bound 0.1.8 → 0.2.0

package/dist/host/native/reading.d.ts

@@ -0,0 +1,91 @@
+import type { Signer } from '@lapxo/topos/wire';
+import type { Request, Response } from '@lapxo/topos/contract';
+import type { Asked } from '@lapxo/topos/capsule';
+import type { CommandPort } from '@lapxo/topos/contract';
+import { type NodeImage, type RootJobCustody } from './node-jobs.ts';
+import type { Handoff, Proposal } from './jobs.ts';
+export declare const canonicalJson: (value: unknown) => string;
+export interface RootStanding {
+    readonly history: readonly string[];
+    readonly live: readonly string[];
+    readonly signer: Signer;
+    readonly eras: readonly string[];
+    readonly epoch: number;
+    readonly budget: {
+        readonly lines: number;
+        readonly bytes: number;
+    };
+}
+export interface PortProfile {
+    readonly profile: 'host-native-reading@1';
+    readonly port: CommandPort;
+    readonly selection: {
+        readonly archive: string;
+        readonly entry: string;
+        readonly reader: string;
+        readonly loaderConfig: string;
+        readonly runtime: string;
+        readonly preload: string | null;
+        readonly nativePreloadMembers: readonly string[];
+        readonly condition: string;
+        readonly budget: Handoff['budget'];
+        readonly members: readonly {
+            coordinate: string;
+            digest: string;
+        }[];
+        readonly bindings: Handoff['bindings'];
+        readonly loads: Handoff['loads'];
+    };
+}
+export interface NativeReadingModule {
+    readonly commands?: (asked: Asked) => readonly Proposal[];
+    readonly receipt?: (asked: Asked) => readonly unknown[];
+    readonly render?: (asked: Asked) => readonly string[];
+}
+export interface NativeReadingHandle {
+    readonly identity: string;
+}
+export declare function authenticateSignedPort(root: RootStanding, coordinate: string): {
+    line: string;
+    profile: unknown;
+};
+export interface AuthenticatedNativeSelection {
+    readonly identity: string;
+}
+/** One synchronous authentication supplies both the opaque boundary and its
+ * immutable signed profile. Fresh Root checks still run at load and answer. */
+export declare function authenticateNativeProfile(root: RootStanding, coordinate: string): {
+    readonly selection: AuthenticatedNativeSelection;
+    readonly line: string;
+    readonly profile: PortProfile;
+};
+export declare function validateSignedNativeProfile(root: RootStanding, coordinate: string, expected: PortProfile): AuthenticatedNativeSelection;
+/** Root must hold its real authority protection across the callback. A guard
+ * method is instrument code, never supplied by a command or its JSON profile. */
+export interface RootAuthorityGuard {
+    withCurrent<T>(body: (root: RootStanding) => Promise<T>): Promise<T>;
+}
+/** Fixed instrument loader, never a callback supplied by module/request/profile.
+ * Root's REAL await-safe lease must cover verification, load and completion.
+ * The handoff image is verified before the fixed loader receives an entry. */
+export declare function loadSignedNativeReading(selection: AuthenticatedNativeSelection, resolved: {
+    profile: PortProfile;
+    handoff: Handoff;
+    image: NodeImage;
+    archive: Uint8Array;
+    custody?: RootJobCustody;
+}, guard: RootAuthorityGuard): Promise<NativeReadingHandle>;
+export declare function answerNativeReading(handle: NativeReadingHandle, requests: readonly Request[], self: string, options: {
+    phase: 'act' | 'selection' | 'help' | 'check' | 'preview' | 'sign';
+    signal?: AbortSignal;
+    guard: RootAuthorityGuard;
+}): Promise<readonly Response[]>;
+/** Executable resources belong to the currently authenticated parent command
+ * declaration, not to the separate authority-history/clock parsing budget. */
+export declare function nativeParentInputBytes(root: RootStanding, parent: {
+    port: string;
+}): number;
+/** Exact schema field names, shared by the host's selected native formats. */
+export declare function fieldNames(value: object): string;
+/** Retain each verifier's private map and return a fresh canonical projection. */
+export declare function retainedProjection<H extends object, T>(verified: WeakMap<H, T>, fail: (why: string) => never): (handle: H) => T;

package/dist/host/native/reading.js

@@ -0,0 +1,249 @@
+import { sha256 as hash } from "../hash.js";
+/** Host profile authentication and bounded executable input handoff. */
+import { extname } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { readBoundedFile } from "./bounded-file.js";
+import { members as archiveMembers } from "../archive.js";
+import { installBoundary } from "./loader.js";
+import { nativeRootJobCustody } from "./custody.js";
+import { mountNativeImage } from "./image.js";
+import { createHash } from 'node:crypto';
+import { canonical } from '@lapxo/topos/wire';
+import { parsedLine as parse } from "../../fold/claims.js";
+import { answer } from '@lapxo/topos/contract';
+import { authorityFor } from "../../fold/signers.js";
+// Public SDK eligibility implementation; no private SDK module import.
+import { authorityAtEpoch } from '@lapxo/topos/wire';
+import { scheduleDeadline } from "./deadline.js";
+import { prepareNodeImage, plannedJobs, executeJobs } from "./node-jobs.js";
+const fail = (why) => { throw Error('REFUSE·native reading ' + why); };
+export const canonicalJson = (value) => JSON.stringify(order(value));
+const order = (value) => Array.isArray(value) ? value.map(order) : value !== null && typeof value === 'object' ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => [k, order(v)])) : value;
+const prepared = new WeakMap();
+export function authenticateSignedPort(root, coordinate) {
+    if (!root || !Number.isSafeInteger(root.epoch) || root.epoch < 0 || !Number.isSafeInteger(root.budget?.lines) || root.budget.lines < 1 || !Number.isSafeInteger(root.budget.bytes) || root.budget.bytes < 1)
+        fail('missing authority/budget');
+    const retained = [...new Set([...root.history, ...root.live])];
+    if (retained.length > root.budget.lines)
+        fail('authority line budget');
+    let bytes = 0;
+    for (const line of retained) {
+        if (typeof line !== 'string' || (bytes += Buffer.byteLength(line)) > root.budget.bytes)
+            fail('authority byte budget');
+    }
+    if (!/^port\/[^\s]+$/.test(coordinate))
+        fail('selection is not a command port');
+    const rows = root.live.filter(line => { const got = parse(line); return got.kind === 'fact' && got.value.fields.scope === coordinate; });
+    if (rows.length !== 1)
+        fail('missing/ambiguous signed declaration ' + coordinate);
+    const line = rows[0];
+    if (!root.history.includes(line))
+        fail('port absent from authenticated admission history');
+    const got = parse(line);
+    if (got.kind !== 'fact')
+        return fail('port not a wire record');
+    const f = got.value.fields;
+    if (f.role !== 'writes' || f.form !== 'alphabet' || f.measure !== 'text' || f.value !== 'lock' || typeof f.about !== 'string')
+        fail('unknown port projection ' + coordinate);
+    const auth = authorityFor(root.history, root.signer, root.eras), verdict = auth.of(line);
+    if (verdict.kind !== 'admitted')
+        fail('port signature/coverage ' + verdict.why);
+    const signerId = verdict.kind === 'admitted' ? verdict.signer : fail('signature not admitted');
+    const signers = auth.admitted.filter(s => s.id === signerId);
+    if (signers.length !== 1)
+        fail('ambiguous port signer');
+    if (root.history.some(line => { const p = parse(line); return p.kind === 'fact' && p.value.fields.epoch !== undefined && (!Number.isSafeInteger(Number(p.value.fields.epoch)) || Number(p.value.fields.epoch) > root.epoch); }))
+        fail('authority prefix exceeds current epoch');
+    const current = authorityAtEpoch(f, signers[0], root.epoch, coordinate, 'authority');
+    if (current.kind !== 'admitted')
+        fail('current port authority ' + current.why);
+    let value;
+    try {
+        value = JSON.parse(f.about);
+    }
+    catch {
+        return fail('port JSON invalid');
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value) || canonicalJson(value) !== f.about)
+        fail('port profile invalid/noncanonical');
+    return { line, profile: value };
+}
+function selected(root, coordinate) {
+    const got = authenticateSignedPort(root, coordinate), profile = got.profile;
+    const line = got.line;
+    if (!profile.port || !profile.selection || typeof profile.selection !== 'object' || Array.isArray(profile.selection))
+        fail('missing native selection');
+    if (Object.keys(profile.selection).sort().join(',') !== 'archive,bindings,budget,condition,entry,loaderConfig,loads,members,nativePreloadMembers,preload,reader,runtime')
+        fail('unknown native selection field');
+    if (Object.keys(profile).sort().join(',') !== 'port,profile,selection' || profile.profile !== 'host-native-reading@1' || profile.port?.coordinate !== coordinate)
+        fail('unknown/noncanonical native profile');
+    return { line, profile };
+}
+const selections = new WeakMap();
+/** This is the BEFORE-LOAD boundary. It authenticates the actual signed profile
+ * and checks current authority; a packet cannot mint the opaque result. */
+function freezeProfile(value) { if (value !== null && typeof value === 'object') {
+    for (const child of Object.values(value))
+        freezeProfile(child);
+    Object.freeze(value);
+} return value; }
+function holdSelection(root, coordinate, selection) { const handle = Object.freeze({ identity: hash(canonicalJson([selection.line, root.epoch])) }); selections.set(handle, { root: { ...root, history: [...root.history], live: [...root.live], eras: [...root.eras], budget: { ...root.budget } }, coordinate, profile: freezeProfile(selection.profile) }); return handle; }
+/** One synchronous authentication supplies both the opaque boundary and its
+ * immutable signed profile. Fresh Root checks still run at load and answer. */
+export function authenticateNativeProfile(root, coordinate) { const got = selected(root, coordinate), selection = holdSelection(root, coordinate, got); return Object.freeze({ selection, line: got.line, profile: got.profile }); }
+export function validateSignedNativeProfile(root, coordinate, expected) { const got = selected(root, coordinate); if (canonicalJson(got.profile) !== canonicalJson(expected))
+    fail('expected profile differs from signature'); return holdSelection(root, coordinate, got); }
+/** Root supplies an authenticated current standing and its selected exact image.
+ * The signature authenticates the ENTIRE profile JSON including its selection;
+ * matching resolved selection is checked byte-for-byte, never from world data.
+ * The real Root guard constructor remains a host-integration prerequisite. */
+function prepareSignedNativeReading(root, coordinate, resolved) {
+    const selection = selected(root, coordinate);
+    if (canonicalJson(selection.profile) !== canonicalJson(resolved.profile))
+        fail('resolved image/profile differs from signed selection');
+    if (!(resolved.archive instanceof Uint8Array) || resolved.archive.byteLength > resolved.handoff.budget.bytes)
+        fail('archive exceeds declared input budget');
+    let entries;
+    try {
+        gunzipSync(resolved.archive, { maxOutputLength: resolved.handoff.budget.bytes });
+        entries = archiveMembers(resolved.archive);
+    }
+    catch {
+        return fail('native implementation archive invalid');
+    }
+    const entriesAt = entries.filter(e => e.name === resolved.profile.selection.entry);
+    if (entriesAt.length !== 1 || 'sha256:' + createHash('sha256').update(entriesAt[0].bytes).digest('hex') !== resolved.profile.port.implementation)
+        fail('archive native entry differs from implementation');
+    const computedSelection = { archive: 'sha256:' + createHash('sha256').update(resolved.archive).digest('hex'), entry: resolved.profile.selection.entry, reader: resolved.profile.selection.reader, loaderConfig: resolved.profile.selection.loaderConfig, runtime: resolved.image.runtime, preload: resolved.image.preload ?? null, nativePreloadMembers: resolved.image.nativePreloadMembers, condition: resolved.image.condition, budget: resolved.handoff.budget, members: resolved.handoff.members.map(({ coordinate, digest }) => ({ coordinate, digest })), bindings: resolved.handoff.bindings, loads: resolved.handoff.loads };
+    if (canonicalJson(computedSelection) !== canonicalJson(resolved.profile.selection))
+        fail('resolved host bindings differ from signed selection');
+    if (resolved.profile.port.implementation !== resolved.handoff.members.find(m => m.coordinate === resolved.profile.selection.entry)?.digest)
+        fail('native implementation differs from handed member');
+    if (resolved.handoff.bindings.some(b => b.limits.slots !== resolved.handoff.bindings[0].limits.slots))
+        fail('native bindings need one declared parent slots resource');
+    if (!Number.isSafeInteger(resolved.profile.port.timeoutMs) || resolved.profile.port.timeoutMs < 1 || !Number.isSafeInteger(resolved.profile.port.responseBytes) || resolved.profile.port.responseBytes < 1)
+        fail('missing parent time/bytes');
+    const declared = resolved.profile.port;
+    if (Object.keys(declared).sort().join(',') !== 'closure,coordinate,environment,implementation,responseBytes,stderr,timeoutMs' || declared.stderr !== 'reject' || new Set(declared.closure).size !== declared.closure.length || canonicalJson([...declared.closure].sort()) !== canonicalJson([...new Set(resolved.handoff.members.map(m => m.digest))].sort()) || resolved.handoff.bindings.some(b => canonicalJson(b.environment.map(([name]) => name).sort()) !== canonicalJson([...declared.environment].sort())))
+        fail('command resource/environment/closure projection differs');
+    const authorityIdentity = hash(canonicalJson([root.signer.id, root.signer.publicKey, root.eras, root.epoch, root.history, root.live]));
+    const contextualHandoff = { ...resolved.handoff, authoritySnapshot: authorityIdentity, policy: hash(canonicalJson([resolved.handoff.policy, selection.line, authorityIdentity])) };
+    const image = prepareNodeImage(contextualHandoff, { ...resolved.image, commandPort: declared }), handle = Object.freeze({ identity: hash(canonicalJson([selection.line, root.epoch, image.identity])) });
+    prepared.set(handle, { root: { ...root, history: [...root.history], live: [...root.live], eras: [...root.eras], budget: { ...root.budget } }, coordinate, profile: selection.profile, image, module: Object.freeze({ ...resolved.module }) });
+    return handle;
+}
+/** Fixed instrument loader, never a callback supplied by module/request/profile.
+ * Root's REAL await-safe lease must cover verification, load and completion.
+ * The handoff image is verified before the fixed loader receives an entry. */
+export async function loadSignedNativeReading(selection, resolved, guard) {
+    const held = selections.get(selection);
+    if (!held)
+        return fail('unknown pre-load selection');
+    return guard.withCurrent(async (current) => {
+        const fresh = selected(current, held.coordinate);
+        if (current.epoch !== held.root.epoch || canonicalJson(fresh.profile) !== canonicalJson(held.profile) || canonicalJson(current.history) !== canonicalJson(held.root.history))
+            fail('authority changed before load');
+        // Validate the exact entire image/profile FIRST, without importing reader code.
+        prepareSignedNativeReading(current, held.coordinate, { ...resolved, module: {} });
+        const reader = resolved.image.locations.find(l => l.member === held.profile.selection.reader), config = resolved.handoff.members.find(m => m.coordinate === held.profile.selection.loaderConfig), location = resolved.image.locations.find(l => l.member === held.profile.selection.loaderConfig);
+        if (!reader || reader.kind !== 'module' || !config || !location || !held.profile.selection.nativePreloadMembers.includes(config.coordinate))
+            return fail('reader/config not selected');
+        const raw = readBoundedFile(location.path, resolved.handoff.budget.bytes, held.profile.selection.loaderConfig);
+        if (hash(raw.toString('utf8')) !== config.digest)
+            fail('loader configuration changed');
+        let declared;
+        try {
+            declared = JSON.parse(raw.toString('utf8'));
+        }
+        catch {
+            return fail('loader configuration invalid');
+        }
+        const logical = declared;
+        if (logical.platform !== resolved.image.condition)
+            fail('selected runtime condition differs from logical platform');
+        if (!Array.isArray(logical.members) || logical.members.some(m => resolved.handoff.members.find(member => member.coordinate === m.coordinate)?.digest !== m.digest))
+            fail('loader target not covered by exact signed image');
+        const mounted = mountNativeImage(logical, resolved.image.locations.filter(location => logical.members.some(member => member.coordinate === location.member)).map(location => ({ coordinate: location.member, path: location.path })), held.profile.selection.reader, resolved.handoff.budget);
+        const boundary = installBoundary(mounted.declaration);
+        try {
+            const module = await boundary.loadEntry();
+            boundary.assertClosed();
+            const ready = prepareSignedNativeReading(current, held.coordinate, { ...resolved, image: { ...resolved.image, hostLoader: { ...mounted, preload: new URL('./preload' + extname(new URL(import.meta.url).pathname), import.meta.url).href } }, module });
+            prepared.get(ready).loader = mounted.declaration;
+            prepared.get(ready).custody = resolved.custody ?? nativeRootJobCustody(current, resolved.profile, resolved.handoff, resolved.image, logical);
+            return ready;
+        }
+        finally {
+            boundary.close();
+        }
+    });
+}
+export async function answerNativeReading(handle, requests, self, options) {
+    const held = prepared.get(handle);
+    if (!held)
+        return fail('unknown instrument selection');
+    if (options.phase !== 'act')
+        fail('effects forbidden during ' + options.phase);
+    if (options.signal?.aborted)
+        fail('interrupted before wrapper');
+    const deadline = process.hrtime.bigint() + BigInt(held.profile.port.timeoutMs) * 1000000n, controller = new AbortController(), abort = controller.abort.bind(controller, undefined), cancel = scheduleDeadline(deadline, abort);
+    options.signal?.addEventListener('abort', abort, { once: true });
+    try {
+        return await options.guard.withCurrent(async (current) => {
+            const fresh = selected(current, held.coordinate);
+            if (canonicalJson(fresh.profile) !== canonicalJson(held.profile) || current.epoch !== held.root.epoch || hash(canonicalJson(current.history)) !== hash(canonicalJson(held.root.history)))
+                fail('authority changed since preparation');
+            if (!held.loader)
+                return fail('reader not loaded by fixed host boundary');
+            const boundary = installBoundary(held.loader);
+            try {
+                const frames = requests.map(request => { let asked; if (request.verb === 'read' && held.module.commands) {
+                    const extraction = answer({ receipt: a => { asked = a; return []; } }, request, self);
+                    if (extraction.kind !== 'fact' || !asked)
+                        fail('Asked extraction refused');
+                } const jobs = asked ? held.module.commands(asked) : []; return { request, asked, jobs }; });
+                const jobs = frames.flatMap(f => f.jobs), frame = new TextEncoder().encode(JSON.stringify(jobs)), wanted = plannedJobs(held.image, frame), observations = jobs.length ? await executeJobs(held.image, frame, { phase: 'act', signal: controller.signal, custody: held.custody }) : [];
+                if (observations.length !== wanted.length || observations.some((got, i) => got.id !== wanted[i].id || got.identity !== wanted[i].identity || got.responses.length !== 1))
+                    fail('capture identity/count differs');
+                const rows = new Map(observations.map(got => [got.id, got]));
+                if (rows.size !== observations.length)
+                    fail('duplicate capture');
+                // Capture text is witness provenance, not a new conceptual origin. Actual
+                // Topos answer performs its normal handed(reads,lines) projection both times.
+                const results = frames.map(({ request, jobs }) => { const captures = jobs.map(job => { const got = rows.get(job.id); if (!got)
+                    return fail('missing capture ' + job.id); return canonical({ scope: 'command/capture/' + job.id, shape: 'same', role: 'reads', form: 'alphabet', measure: 'text', value: 'lock', by: 'host', at: 'witness:' + got.identity, about: JSON.stringify({ identity: got.identity, responses: got.responses }) }); }); return answer(held.module, { ...request, lines: [...(request.lines ?? []), ...captures] }, self); });
+                if (results.length !== requests.length)
+                    return fail('incomplete pure response');
+                if (controller.signal.aborted || process.hrtime.bigint() >= deadline)
+                    fail('interrupted/timeout wrapper');
+                if (Buffer.byteLength(JSON.stringify(results)) > held.profile.port.responseBytes)
+                    fail('parent response bytes exceeded');
+                boundary.assertClosed();
+                return results;
+            }
+            finally {
+                boundary.close();
+            }
+        });
+    }
+    finally {
+        cancel();
+        options.signal?.removeEventListener('abort', abort);
+    }
+}
+/** Executable resources belong to the currently authenticated parent command
+ * declaration, not to the separate authority-history/clock parsing budget. */
+export function nativeParentInputBytes(root, parent) {
+    const selected = authenticateSignedPort(root, parent.port).profile;
+    const bytes = selected?.selection?.budget?.bytes;
+    if (selected?.profile !== 'host-native-reading@1' || !Number.isSafeInteger(bytes) || bytes < 1)
+        fail('parent executable input resource absent');
+    return bytes;
+}
+/** Exact schema field names, shared by the host's selected native formats. */
+export function fieldNames(value) { return Object.keys(value).sort().join(','); }
+/** Retain each verifier's private map and return a fresh canonical projection. */
+export function retainedProjection(verified, fail) {
+    return handle => { const p = verified.get(handle); if (!p)
+        return fail('unknown verified selection'); return JSON.parse(canonicalJson(p)); };
+}

package/dist/host/native/receipt-environment.d.ts

@@ -0,0 +1,3 @@
+import type { ReadingIdentityContext } from '@lapxo/topos/contract';
+import { type ReadingReference } from '../reading-context.ts';
+export declare function currentReadingEnvironment(store: string, root: string, hash: (text: string) => string, flags: readonly string[]): (context: ReadingIdentityContext) => readonly ReadingReference[] | undefined;

package/dist/host/native/receipt-environment.js

@@ -0,0 +1,41 @@
+/** Reconstruct the current execution boundary from authenticated selections.
+ * A retained receipt never selects its own cwd or execution flags. Historical
+ * inspection does not call this resolver and does not authorize a current act.
+ */
+import { join } from 'node:path';
+import { readingEnvironment } from "../reading-context.js";
+import { currentNativeReaderSelections, nativeMountIdentity } from "./route.js";
+export function currentReadingEnvironment(store, root, hash, flags) {
+    const selections = currentNativeReaderSelections(store);
+    const ordinary = readingEnvironment(hash, process.env, root, flags);
+    return context => {
+        const mounts = [];
+        for (const [encoded, digest] of context.inputs) {
+            let name = encoded;
+            for (;;) {
+                let value;
+                try {
+                    value = JSON.parse(name);
+                }
+                catch {
+                    break;
+                }
+                if (!Array.isArray(value) || value.length !== 2 || value[0] !== 'context' || typeof value[1] !== 'string')
+                    break;
+                name = value[1];
+            }
+            if (name === 'native/mount')
+                mounts.push(digest);
+        }
+        if (!mounts.length)
+            return selections.some(one => one.profile.selection.archive === context.implementation) ? undefined : ordinary;
+        if (mounts.length !== 1)
+            return undefined;
+        const selected = selections.filter(one => one.profile.selection.archive === context.implementation && nativeMountIdentity(one.profile, one.binaries, one.control) === mounts[0]);
+        if (!selected.length)
+            return undefined;
+        // Several readers may share this exact image. They have the same execution
+        // boundary; their policy and transitive inputs remain separate in the receipt.
+        return readingEnvironment(hash, process.env, join(store, 'cas', 'laid', mounts[0].slice(7)), []);
+    };
+}

package/dist/host/native/references.d.ts

@@ -0,0 +1,5 @@
+import type { ReadingReference } from '../reading-context.ts';
+/** Existing leaf folds wrap parent names in the context namespace. Resolve that
+ * namespace without dropping any inherited identity, and never pick a duplicate.
+ */
+export declare function nativeReferenceInputs(inputs: readonly ReadingReference[], required: readonly ReadingReference[]): void;

package/dist/host/native/references.js

@@ -0,0 +1,30 @@
+/** Existing leaf folds wrap parent names in the context namespace. Resolve that
+ * namespace without dropping any inherited identity, and never pick a duplicate.
+ */
+export function nativeReferenceInputs(inputs, required) {
+    const names = new Map(required);
+    const found = new Map();
+    for (const [encoded, digest] of inputs) {
+        let name = encoded;
+        for (;;) {
+            let value;
+            try {
+                value = JSON.parse(name);
+            }
+            catch {
+                break;
+            }
+            if (!Array.isArray(value) || value.length !== 2 || value[0] !== 'context' || typeof value[1] !== 'string')
+                break;
+            name = value[1];
+        }
+        if (!names.has(name))
+            continue;
+        if (found.has(name))
+            throw Error('REFUSE·native reading duplicate context input ' + name);
+        found.set(name, digest);
+    }
+    for (const [name, digest] of required)
+        if (found.get(name) !== digest)
+            throw Error('REFUSE·native reading context omits or changes ' + name);
+}

package/dist/host/native/root.d.ts

@@ -0,0 +1,17 @@
+import { type RootAuthorityProtection } from '../../land/act.ts';
+import type { RootStanding, RootAuthorityGuard } from './reading.ts';
+import type { RootContext } from '@lapxo/topos/core';
+/** Values come from the fixed parent argv chain while it retains actual Root
+ * protection. No world packet supplies the store, parent, cursor or verifier.
+ */
+export interface NativeRootInheritance {
+    readonly store: string;
+    readonly parent: number;
+    readonly expected: RootContext;
+}
+export declare function currentNativeRoot(store: string, parent: number, proof: RootAuthorityProtection): {
+    readonly context: RootContext;
+    readonly root: RootStanding;
+};
+export declare function inheritedNativeRoot(inherited: NativeRootInheritance, proof: RootAuthorityProtection): RootStanding;
+export declare function inheritedNativeGuard(inherited: NativeRootInheritance, proof: RootAuthorityProtection): RootAuthorityGuard;

package/dist/host/native/root.js

@@ -0,0 +1,37 @@
+import { dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { declaredRootClockSource } from "../root-clock-source.js";
+import { foldClaims, fieldOf } from "../../fold/claims.js";
+import { assertRootAuthorityProtection } from "../../land/act.js";
+import { withCommittedLocalActObservation } from "../ports/local-act.js";
+const fail = (why) => { throw Error('REFUSE·native Root ' + why); };
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export function currentNativeRoot(store, parent, proof) {
+    assertRootAuthorityProtection(proof, store, parent);
+    return withCommittedLocalActObservation(store, () => {
+        // The constructor has just authenticated this cursor and its receiver heads.
+        // Reuse that result only within this protected synchronous invocation. Calling
+        // trust.current() here would repeat the same full construction immediately;
+        // subsequent gates still construct their own fresh source under the lease.
+        const root = dirname(store), source = declaredRootClockSource(root), current = source.trust.contract.root;
+        const { history, anchor: signer, algorithms: eras } = source.observation;
+        const live = foldClaims(history).standing.filter(line => fieldOf(line, 'value') !== 'withdraw');
+        // The source constructor authenticates the complete history at each original
+        // admission snapshot. Current port eligibility stays a separate SDK check.
+        const limits = source.resources;
+        if (history.length > limits.lines || history.reduce((bytes, line) => bytes + Buffer.byteLength(line), 0) > limits.bytes)
+            fail('Root declared history resources exceeded');
+        assertRootAuthorityProtection(proof, store, parent);
+        return { context: current, root: { history, live, signer, eras, epoch: Number(current.epoch), budget: { lines: limits.lines, bytes: limits.bytes } } };
+    });
+}
+export function inheritedNativeRoot(inherited, proof) {
+    const current = currentNativeRoot(inherited.store, inherited.parent, proof);
+    if (!same(current.context, inherited.expected))
+        fail('actual authority cursor or dependencies changed');
+    return current.root;
+}
+export function inheritedNativeGuard(inherited, proof) {
+    return { async withCurrent(body) { const before = inheritedNativeRoot(inherited, proof), result = await body(before), after = inheritedNativeRoot(inherited, proof); if (createHash('sha256').update(JSON.stringify(before)).digest('hex') !== createHash('sha256').update(JSON.stringify(after)).digest('hex'))
+            fail('Root changed during native execution'); return result; } };
+}

package/dist/host/native/route.d.ts

@@ -0,0 +1,66 @@
+import { type NativeBinaryOrigin } from './native-binary.ts';
+import { type HostControlSelection } from './control-selection.ts';
+export { materializeNativeRoute } from './materialize.ts';
+import { type PortProfile, type RootStanding } from './reading.ts';
+import type { ReadingExecution, ReadingReference } from '../reading-context.ts';
+import type { Request, Response } from '@lapxo/topos/contract';
+import type { ReaderLifetime } from '@lapxo/topos/wire';
+export interface NativeBinaryBinding {
+    readonly line: string;
+    readonly coordinate: string;
+    readonly profile: import('./native-binary.ts').NativeBinaryProfile;
+    readonly origin?: NativeBinaryOrigin;
+}
+export interface NativeRoute {
+    readonly identity: string;
+    readonly profile: PortProfile;
+    readonly binaries: readonly NativeBinaryBinding[];
+    readonly control?: HostControlSelection;
+    readonly inputs: readonly ReadingReference[];
+}
+/** Shared origins are one exact input; individual signed selectors remain separate. */
+export declare function nativeBinaryOriginInputs(binaries: readonly NativeBinaryBinding[]): readonly ReadingReference[];
+/** Inputs are semantic logical references. Fixed instrument/host graph and
+ * runtime-supervisor chain must also be supplied by the calling identity builder.
+ * Locations and lock-token/PID are operational custody, never these inputs.
+ */
+export declare function prepareNativeRoute(store: string, coordinate: string, readerMapping?: string): NativeRoute;
+/** Recheck authority before both a current retained answer and fresh execution.
+ * Historical public --check uses the existing receipt-inspection path, not this
+ * command authorization route.
+ */
+export declare function assertNativeRouteCurrent(route: NativeRoute): void;
+export declare function invokeNativeRoute(route: NativeRoute, input: {
+    archive: string;
+    locations: readonly {
+        member: string;
+        path: string;
+        kind: 'module' | 'data' | 'binary';
+    }[];
+    requests: readonly Request[];
+    execution: ReadingExecution;
+    limits: ReaderLifetime;
+}): readonly Response[];
+/** This predicate only schedules an outer lease. It grants no command. */
+export declare function declaredNativeReaderPorts(lines: readonly string[]): boolean;
+export declare function prepareNativeReaderRoute(store: string, reader: {
+    id: string;
+    module: string;
+}): NativeRoute | undefined;
+export declare function nativeRouteStore(route: NativeRoute): string;
+/** Quiet-pass gate: authenticate grants/cursor only, no image/materialization or
+ * program execution. Historical --check remains its separate receipt path. */
+export declare function assertNativeReaderGrantsCurrent(store: string): void;
+/** Executable kinds come only from current authenticated Root declarations. A
+ * matching JSON hint identifies a candidate, but is never permission to execute. */
+export declare function authenticatedNativeBinaries(root: RootStanding, profile: PortProfile): readonly NativeBinaryBinding[];
+/** Same semantic image identity for preparation, retained mount and quiet checks. */
+export declare function nativeMountIdentity(profile: PortProfile, binaries: readonly NativeBinaryBinding[], control?: HostControlSelection): string;
+export interface CurrentNativeReaderSelection {
+    readonly profile: PortProfile;
+    readonly binaries: readonly NativeBinaryBinding[];
+    readonly control?: HostControlSelection;
+}
+/** Current eligibility only: no executor graph, image load or materialization. */
+export declare function currentNativeReaderSelections(store: string): readonly CurrentNativeReaderSelection[];
+export declare function currentNativeReaderProfiles(store: string): readonly PortProfile[];