@lapxo/bound 0.1.7 → 0.1.9

package/dist/host/native/generated-custodian.js

@@ -0,0 +1,267 @@
+import { sha256 as sha } from "../hash.js";
+/** One asynchronous Root custodian owns aggregate counters for one actual job.
+ * Endpoint is injected by instrument code, never selected by a world payload. */
+import { createServer, createConnection } from 'node:net';
+import { chmodSync, rmSync, realpathSync, writeFileSync, renameSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { canonicalJson } from "./reading.js";
+import { verifyNativeBinary, nativeBinaryProjection } from "./native-binary.js";
+import { commandRequest, commandResponse } from '@lapxo/topos/contract';
+import { assertProducerInterpretation, chargeProducerRequest, createGeneratedProducer, readBounded, validateDescendantInvocation, sealGeneratedFile, sealNativeEval, sealInterpretation, recordProducerEmission, recordProducerEmissions, registerProducerCandidates, gateDerived, producerTransport, producerUsage } from "./generated.js";
+import { retainedNativeEvalMatches } from "./node-launch.js";
+import { verifyNativeProgram, nativeProgramProjection } from "./native-program.js";
+/** Refusal transport is bounded too; an undersized channel closes without a
+ * frame while the parent retains the named refusal. No truncation is success. */
+export function boundedRefusalFrame(endpoint, why) { if (why.length > endpoint.responseBytes || Buffer.byteLength(why) > endpoint.responseBytes)
+    return; const frame = JSON.stringify({ protocol: 'command-lot/1', coordinate: endpoint.coordinate, implementation: endpoint.implementation, identity: endpoint.identity, responses: [{ kind: 'refuse', why }] }) + '\n'; return Buffer.byteLength(frame) <= endpoint.responseBytes ? frame : undefined; }
+export async function startProducerCustodian(handle, snapshot, nativeImplementations, directory, inputNativePrograms = []) {
+    const nativePrograms = inputNativePrograms.map(grant => ({ identity: grant.identity, program: { ...grant.program } }));
+    if (nativePrograms.some(g => !/^sha256:[0-9a-f]{64}$/.test(g.identity) || g.program.kind !== 'native-binary' || typeof g.program.alias !== 'string' || !g.program.alias.length || !g.program.entry.startsWith('/') || !/^sha256:[0-9a-f]{64}$/.test(g.program.entryDigest) || !Number.isSafeInteger(g.program.entryBytes) || g.program.entryBytes < 1 || g.program.entryBytes > snapshot.budget.bytes || !g.program.condition) || new Set(nativePrograms.map(g => g.program.alias)).size !== nativePrograms.length)
+        throw Error('REFUSE·producer native program selection ambiguous/over budget');
+    const selected = producerTransport(handle), endpoint = { ...selected, deadlineMs: Date.now() + selected.timeoutMs, socket: join(directory, 'p-' + randomBytes(6).toString('hex')), token: randomBytes(32).toString('hex') }, connections = new Set(), unfinishedRequests = new Set(), refusals = [], knownDigests = new Set(snapshot.members.map(m => m.digest));
+    const retainedContexts = new Map(), retainedValues = new Map();
+    let contextBytes = 0;
+    const reconstruct = (compact) => { const full = { ...compact }; for (const key of ['invocation', 'edges'])
+        if (full[key]?.retainedValue) {
+            const value = retainedValues.get(full[key].retainedValue);
+            if (value === undefined)
+                throw Error('REFUSE·producer retained value absent');
+            full[key] = value;
+        } return full; };
+    const retainContext = (context) => { const held = retainedContexts.get(context.identity); if (held) {
+        if (canonicalJson(reconstruct(held)) !== canonicalJson(context))
+            throw Error('REFUSE·producer context identity collision');
+        return;
+    } const compact = { ...context }, fresh = new Map(); for (const key of ['invocation', 'edges']) {
+        const value = context[key];
+        if (value && typeof value === 'object') {
+            const encoded = canonicalJson(value), id = sha(encoded), prior = retainedValues.get(id);
+            if (prior !== undefined && canonicalJson(prior) !== encoded)
+                throw Error('REFUSE·producer retained value collision');
+            if (prior === undefined && !fresh.has(id))
+                fresh.set(id, JSON.parse(encoded));
+            compact[key] = { retainedValue: id };
+        }
+    } let bytes = Buffer.byteLength(canonicalJson(compact)); for (const [id, value] of fresh)
+        bytes += Buffer.byteLength(canonicalJson([id, value])); if (bytes > selected.responseBytes - contextBytes)
+        throw Error('REFUSE·producer retained contexts bytes'); for (const [id, value] of fresh)
+        retainedValues.set(id, value); retainedContexts.set(context.identity, compact); contextBytes += bytes; };
+    const server = createServer(socket => {
+        try {
+            chargeProducerRequest(handle);
+            if (Date.now() >= endpoint.deadlineMs)
+                throw Error('REFUSE·producer parent deadline');
+        }
+        catch (error) {
+            refusals.push(error instanceof Error ? error.message : String(error));
+            socket.destroy();
+            return;
+        }
+        connections.add(socket);
+        unfinishedRequests.add(socket);
+        const finishReply = (reply) => { const done = () => unfinishedRequests.delete(socket); if (reply === undefined)
+            socket.end(done);
+        else
+            socket.end(reply, done); };
+        socket.once('error', () => { if (!refusals.length)
+            refusals.push('REFUSE·producer IPC response interrupted'); });
+        socket.setTimeout(Math.max(1, endpoint.deadlineMs - Date.now()), () => { refusals.push('REFUSE·producer IPC timeout'); socket.destroy(); });
+        const chunks = [];
+        let bytes = 0, handled = false;
+        socket.on('data', chunk => {
+            bytes += chunk.length;
+            if (bytes > endpoint.responseBytes) {
+                refusals.push('REFUSE·producer IPC request bytes');
+                socket.destroy();
+                return;
+            }
+            chunks.push(chunk);
+            if (!chunk.includes(10))
+                return;
+            if (handled)
+                return;
+            handled = true;
+            socket.pause();
+            try {
+                const raw = Buffer.concat(chunks).toString('utf8');
+                if (refusals.length)
+                    throw Error(refusals[0]);
+                const frame = JSON.parse(raw.trim());
+                if (frame.protocol !== 'command-lot/1' || frame.coordinate !== endpoint.coordinate || frame.implementation !== endpoint.implementation || frame.identity !== endpoint.identity || !Array.isArray(frame.requests) || frame.requests.length !== 1)
+                    throw Error('REFUSE·producer IPC frame');
+                const body = JSON.parse(frame.requests[0]);
+                if (body.token !== endpoint.token || !['entry', 'emission', 'emission-batch', 'native-program', 'interpretation', 'eval-context', 'violation'].includes(body.operation))
+                    throw Error('REFUSE·producer IPC capability');
+                if (body.operation === 'violation') {
+                    if (typeof body.why !== 'string' || body.why.length > endpoint.responseBytes || Buffer.byteLength(body.why) > endpoint.responseBytes)
+                        throw Error('REFUSE·producer violation bytes');
+                    throw Error('REFUSE·producer pre-entry ' + body.why);
+                }
+                let context;
+                if (body.operation === 'eval-context') {
+                    const actual = body.request;
+                    const matches = [...retainedContexts.values()].map(reconstruct).filter(record => retainedNativeEvalMatches(record, actual));
+                    if (matches.length !== 1)
+                        throw Error('REFUSE·producer retained eval context ' + (matches.length ? 'ambiguous' : 'absent'));
+                    context = matches[0];
+                }
+                else if (body.operation === 'emission-batch') {
+                    const request = body.request;
+                    if (!request || !Array.isArray(request.outputs) || request.outputs.length > selected.limits.work)
+                        throw Error('REFUSE·producer emission batch context/count absent');
+                    context = recordProducerEmissions(handle, request.outputs, request.invocation);
+                }
+                else if (body.operation === 'emission') {
+                    const request = body.request;
+                    if (!request || typeof request.path !== 'string')
+                        throw Error('REFUSE·producer emission context absent');
+                    context = recordProducerEmission(handle, request.path, request.invocation);
+                }
+                else if (body.operation === 'native-program') {
+                    const request = body.request;
+                    if (!request || typeof request.alias !== 'string' || typeof request.path !== 'string')
+                        throw Error('REFUSE·producer native invocation absent');
+                    const grant = nativePrograms.find(g => g.program.alias === request.alias);
+                    if (!grant)
+                        throw Error('REFUSE·producer native program alias undeclared ' + request.alias);
+                    const invocation = validateDescendantInvocation(handle, request.invocation);
+                    let actual;
+                    try {
+                        actual = realpathSync(request.path);
+                    }
+                    catch {
+                        throw Error('REFUSE·producer native program target absent');
+                    }
+                    if (actual !== grant.program.entry)
+                        throw Error('REFUSE·producer native program route differs');
+                    const bytes = readBounded(actual, grant.program.entryBytes), digest = sha(bytes);
+                    if (bytes.length !== grant.program.entryBytes || digest !== grant.program.entryDigest)
+                        throw Error('REFUSE·producer native program bytes differ');
+                    const transaction = { kind: 'native-program-transaction/1', parent: selected.parent, producer: selected.identity, program: grant.identity, alias: grant.program.alias, target: actual, digest, byteLength: bytes.length, invocation, condition: grant.program.condition };
+                    context = { ...transaction, identity: sha(JSON.stringify(transaction)) };
+                }
+                else if (body.operation === 'interpretation') {
+                    const request = body.request;
+                    if (!request || typeof request.path !== 'string' || typeof request.interpretation !== 'string')
+                        throw Error('REFUSE·producer interpretation context absent');
+                    context = sealInterpretation(handle, request.path, request.interpretation, request.invocation);
+                }
+                else {
+                    const request = body.request;
+                    if (!request || !['module', 'commonjs'].includes(request.mode))
+                        throw Error('REFUSE·producer unknown entry mode');
+                    if (request.candidates !== undefined)
+                        registerProducerCandidates(handle, request.candidates);
+                    if (request.kind === 'file') {
+                        if (request.interpretation !== undefined) {
+                            assertProducerInterpretation(handle, request.interpretation);
+                            if (request.interpretation !== 'node-ambiguous-javascript@1')
+                                throw Error('REFUSE·producer entry interpretation unsupported');
+                        }
+                        if (!request.path)
+                            throw Error('REFUSE·producer missing path');
+                        const path = realpathSync(request.path), actual = readBounded(path, snapshot.budget.bytes);
+                        if (actual.length > snapshot.budget.bytes)
+                            throw Error('REFUSE·producer static input bytes');
+                        const digest = sha(actual);
+                        if (knownDigests.has(digest)) {
+                            context = { kind: 'mounted-executable/1', parent: selected.parent, producer: selected.identity, path, digest, mode: request.mode, ...(request.interpretation === undefined ? {} : { interpretation: request.interpretation }), invocation: validateDescendantInvocation(handle, request.invocation), identity: sha(JSON.stringify([selected.parent, selected.identity, path, digest, request.mode, request.invocation, ...(request.interpretation === undefined ? [] : [request.interpretation])])), qualification: nativeImplementations.has(digest) ? 'separately selected privileged native implementation' : 'same sealed content mounted at actual path' };
+                        }
+                        else {
+                            const record = sealGeneratedFile(handle, path, request.mode, request.invocation, request.interpretation), edges = gateDerived(handle, record, { path }, snapshot, nativeImplementations);
+                            context = { ...record, edges };
+                        }
+                    }
+                    else if (request.kind === 'eval') {
+                        if (!request.argv || !request.rootPrefix)
+                            throw Error('REFUSE·producer missing eval binding');
+                        const record = sealNativeEval(handle, request.argv, request.rootPrefix, request.invocation);
+                        if (record.mode !== request.mode)
+                            throw Error('REFUSE·producer eval mode differs from argv');
+                        const edges = gateDerived(handle, record, { argv: request.argv }, snapshot, nativeImplementations);
+                        context = { ...record, edges };
+                    }
+                    else
+                        throw Error('REFUSE·producer unknown entry kind');
+                }
+                retainContext(context);
+                const reply = JSON.stringify({ protocol: 'command-lot/1', coordinate: endpoint.coordinate, implementation: endpoint.implementation, identity: endpoint.identity, responses: [{ kind: 'entry-context', context, usage: producerUsage(handle) }] }) + '\n';
+                if (Buffer.byteLength(reply) > endpoint.responseBytes)
+                    throw Error('REFUSE·producer IPC response bytes');
+                finishReply(reply);
+            }
+            catch (error) {
+                const why = error instanceof Error ? error.message : String(error);
+                if (!refusals.length)
+                    refusals.push(why);
+                const refusal = boundedRefusalFrame(endpoint, why);
+                if (refusal === undefined) {
+                    finishReply();
+                    return;
+                }
+                finishReply(refusal);
+            }
+        });
+        socket.once('close', () => { if (unfinishedRequests.delete(socket) && !refusals.length)
+            refusals.push('REFUSE·producer IPC interrupted before bounded reply'); connections.delete(socket); });
+    });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(endpoint.socket, () => { chmodSync(endpoint.socket, 0o600); resolve(); }); });
+    const deadline = setTimeout(() => { refusals.push('REFUSE·producer parent deadline'); for (const socket of connections)
+        socket.destroy(); }, endpoint.timeoutMs);
+    return { endpoint, get contexts() { return [...retainedContexts.values()].map(reconstruct); }, retention: () => ({ bytes: contextBytes, contexts: [...retainedContexts.values()].map(value => JSON.parse(canonicalJson(value))), values: [...retainedValues].map(([id, value]) => [id, JSON.parse(canonicalJson(value))]) }), assertClosed: () => { if (Date.now() >= endpoint.deadlineMs)
+            throw Error('REFUSE·producer parent deadline'); if (refusals.length)
+            throw Error(refusals[0]); if (unfinishedRequests.size)
+            throw Error('REFUSE·producer IPC unfinished'); }, refusals, usage: () => producerUsage(handle), close: async () => { clearTimeout(deadline); for (const socket of connections)
+            socket.destroy(); await new Promise(resolve => server.close(() => resolve())); rmSync(endpoint.socket, { force: true }); } };
+}
+/** Asynchronous client for original async native APIs. Original sync APIs use
+ * the fixed client executable; both address this SAME custodian/counters. */
+export async function requestRetainedEvalContext(endpoint, actual) { return requestProducerOperation(endpoint, 'eval-context', actual); }
+export async function requestProducerEntry(endpoint, request) { return requestProducerOperation(endpoint, 'entry', request); }
+export async function requestProducerInterpretation(endpoint, request) { return requestProducerOperation(endpoint, 'interpretation', request); }
+export async function requestNativeProgram(endpoint, request) { return requestProducerOperation(endpoint, 'native-program', request); }
+export async function requestProducerEmission(endpoint, request) { return requestProducerOperation(endpoint, 'emission', request); }
+export async function requestProducerEmissionBatch(endpoint, request) { return requestProducerOperation(endpoint, 'emission-batch', request); }
+async function requestProducerOperation(endpoint, operation, request) { const port = { coordinate: endpoint.coordinate, implementation: endpoint.implementation, closure: [endpoint.implementation], timeoutMs: endpoint.timeoutMs, responseBytes: endpoint.responseBytes, environment: [], stderr: 'reject' }, lot = { identity: endpoint.identity, requests: [JSON.stringify({ operation, token: endpoint.token, request })] }, frame = commandRequest(port, lot); if (Buffer.byteLength(frame) > endpoint.responseBytes)
+    throw Error('REFUSE·producer IPC request bytes'); const raw = await new Promise((resolve, reject) => { const socket = createConnection(endpoint.socket), chunks = [], timer = setTimeout(() => socket.destroy(Error('REFUSE·producer IPC timeout')), Math.max(1, Math.min(endpoint.timeoutMs, endpoint.deadlineMs - Date.now()))); let bytes = 0; socket.on('connect', () => socket.write(frame + '\n')); socket.on('data', c => { bytes += c.length; if (bytes > endpoint.responseBytes)
+    socket.destroy(Error('REFUSE·producer IPC response bytes'));
+else
+    chunks.push(c); }); socket.once('error', reject); socket.once('close', () => { clearTimeout(timer); resolve(Buffer.concat(chunks).toString('utf8')); }); }); const values = commandResponse(port, lot, { status: 0, interrupted: false, stdout: raw, stderr: '' }, value => !!value && typeof value === 'object' && ['entry-context', 'refuse'].includes(value.kind)); const one = values[0]; if (one.kind === 'refuse')
+    throw Error(one.why); return one.context; }
+/** Bound's guarded host constructs this factory, not a world. The transport path
+ * is selected by the sealed native preload configuration, not a grant in data.
+ * A shared context file cannot be multiplexed across simultaneous bindings. */
+export function createProducerJobCustody(input) { let active = false; return { async open(parent) { if (active || existsSync(input.contextFile))
+        throw Error('REFUSE·producer execution context occupied'); active = true; let service; const temporary = input.contextFile + '.' + randomBytes(6).toString('hex'); try {
+        const programs = (input.programSelections ?? []).map(selected => nativeProgramProjection(verifyNativeProgram(input.root, selected.coordinate, parent, selected.runtimeBinding)));
+        const handle = createGeneratedProducer(input.root, input.coordinate, parent, input.implementationBytes);
+        const nativePrograms = (input.nativeBinaries ?? []).map(binding => { const verified = verifyNativeBinary(input.root, binding.coordinate, parent, binding.privateBinding); return { identity: verified.identity, program: nativeBinaryProjection(verified) }; });
+        service = await startProducerCustodian(handle, input.snapshot, input.nativeImplementations, input.directory, nativePrograms);
+        const declaredPrograms = [...programs, ...nativePrograms.map(g => g.program)];
+        if (new Set(declaredPrograms.map(p => p.alias)).size !== declaredPrograms.length)
+            throw Error('REFUSE·producer native alias ambiguous');
+        const text = JSON.stringify({ endpoint: service.endpoint, parentExecution: parent, programs: declaredPrograms });
+        if (Buffer.byteLength(text) > parent.responseBytes)
+            throw Error('REFUSE·producer execution context bytes');
+        writeFileSync(temporary, text, { flag: 'wx', mode: 0o600 });
+        renameSync(temporary, input.contextFile);
+        const held = service;
+        return { assertClosed: () => held.assertClosed(), async close() { try {
+                await held.close();
+            }
+            finally {
+                rmSync(input.contextFile, { force: true });
+                active = false;
+            } } };
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        await service?.close();
+        active = false;
+        throw error;
+    } } }; }
+/** Fixed Root preload reports a local before-entry refusal to the SAME parent
+ * custodian. A caught child error therefore cannot become a success receipt. */
+export async function reportProducerViolation(endpoint, why) { if (typeof why !== 'string' || why.length > endpoint.responseBytes || Buffer.byteLength(why) > endpoint.responseBytes)
+    throw Error('REFUSE·producer violation bytes'); const frame = JSON.stringify({ protocol: 'command-lot/1', coordinate: endpoint.coordinate, implementation: endpoint.implementation, identity: endpoint.identity, requests: [JSON.stringify({ operation: 'violation', token: endpoint.token, why })] }); await new Promise((resolve, reject) => { const socket = createConnection(endpoint.socket), timer = setTimeout(() => socket.destroy(Error('REFUSE·producer IPC timeout')), Math.max(1, endpoint.deadlineMs - Date.now())); socket.once('connect', () => socket.write(frame + '\n')); socket.on('data', () => { }); socket.once('error', reject); socket.once('close', () => { clearTimeout(timer); resolve(); }); }); throw Error('REFUSE·producer pre-entry ' + why); }

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

@@ -0,0 +1,217 @@
+import { type RootStanding } from './reading.ts';
+export interface ProducerLimits {
+    members: number;
+    bytes: number;
+    work: number;
+    argvBytes: number;
+    argvItems: number;
+}
+export interface ProducerProfile {
+    profile: 'host-generated-executable@3';
+    coordinate: string;
+    implementation: string;
+    interpretations: readonly string[];
+    environmentNames: readonly string[];
+    selector: {
+        port: string;
+        binding: string;
+        implementation: string;
+    };
+    limits: ProducerLimits;
+}
+export interface ParentExecution {
+    identity: string;
+    port: string;
+    binding: string;
+    implementation: string;
+    instrument: string;
+    policy: string;
+    authority: string;
+    inputs: readonly (readonly [string, string])[];
+    environment: readonly (readonly [string, string])[];
+    argv: readonly string[];
+    cwd: string;
+    runtime: string;
+    timeoutMs: number;
+    responseBytes: number;
+}
+export interface DescendantInvocation {
+    cwd: string;
+    argv: readonly string[];
+    environment: readonly (readonly [string, string])[];
+    runtime: string;
+    timeoutMs: number;
+    responseBytes: number;
+}
+export interface GeneratedProducer {
+    readonly identity: string;
+}
+export interface DerivedExecutable {
+    kind: 'derived-executable/1';
+    parent: string;
+    producer: string;
+    identity: string;
+    digest: string;
+    mode: 'module' | 'commonjs';
+    interpretation?: string;
+    invocation: DescendantInvocation;
+    target: {
+        kind: 'file';
+        path: string;
+    } | {
+        kind: 'eval';
+        cwd: string;
+        argv: readonly string[];
+        text: string;
+    };
+    byteLength: number;
+}
+export interface DerivedInterpretation {
+    kind: 'derived-interpretation/1';
+    parent: string;
+    producer: string;
+    identity: string;
+    path: string;
+    digest: string;
+    interpretation: string;
+    invocation: DescendantInvocation;
+    byteLength: number;
+}
+export interface ProducerEmission {
+    kind: 'producer-emission/1';
+    parent: string;
+    producer: string;
+    identity: string;
+    path: string;
+    digest: string;
+    invocation: DescendantInvocation;
+    invocationIdentity: string;
+    byteLength: number;
+}
+export interface RootMember {
+    path: string;
+    digest: string;
+}
+export interface LiteralSnapshot {
+    budget: {
+        members: number;
+        bytes: number;
+    };
+    members: readonly RootMember[];
+    libraries: readonly {
+        name: string;
+        manifest: string;
+    }[];
+    builtins: readonly string[];
+    platform: string;
+}
+export interface ProducerCandidates {
+    readonly invocation: DescendantInvocation;
+    readonly outputs: readonly {
+        path: string;
+        digest?: string;
+        reason?: string;
+    }[];
+}
+/** Call inside the parent's real authority guard BEFORE emission/work. Signature
+ * and current eligibility are shared with the Root port constructor, unchanged. */
+export declare function createGeneratedProducer(root: RootStanding, coordinate: string, parent: ParentExecution, implementationBytes: Uint8Array): GeneratedProducer;
+export declare function validateDescendantInvocation(handle: GeneratedProducer, input: DescendantInvocation): DescendantInvocation;
+export declare function producerTransport(handle: GeneratedProducer): Readonly<{
+    coordinate: string;
+    implementation: string;
+    identity: string;
+    parent: string;
+    timeoutMs: number;
+    responseBytes: number;
+    limits: {
+        members: number;
+        bytes: number;
+        work: number;
+        argvBytes: number;
+        argvItems: number;
+    };
+    interpretations: string[];
+}>;
+export declare function readBounded(path: string, limit: number): Uint8Array;
+export declare function assertProducerInterpretation(handle: GeneratedProducer, name: string): void;
+export declare function sealGeneratedFile(handle: GeneratedProducer, path: string, mode: 'module' | 'commonjs', invocation: DescendantInvocation, interpretation?: string): DerivedExecutable;
+/** Preserve the four consumed native eval forms exactly; no rewriting/default
+ * flags/option blacklist. Prefix is the exact Root-selected inherited preload. */
+export declare function sealNativeEval(handle: GeneratedProducer, actualArgv: readonly string[], rootPrefix: readonly string[], invocation: DescendantInvocation): DerivedExecutable;
+/** Interpretive data is provenance, never an executable or an authority grant.
+ * The finite interpretation is Root-signed before bounded IO/JSON work. */
+export declare function sealInterpretation(handle: GeneratedProducer, path: string, interpretation: string, invocation: DescendantInvocation): DerivedInterpretation;
+/** Metadata from the fixed observer is only a candidate. No file is opened,
+ * no emission accepted, and no execution permission follows from registration. */
+export declare function registerProducerCandidates(handle: GeneratedProducer, groups: readonly ProducerCandidates[]): void;
+export declare function recordProducerEmission(handle: GeneratedProducer, path: string, invocation: DescendantInvocation): ProducerEmission;
+/** All observed outputs must match before any provenance is accepted. One
+ * invocation context is committed once, with no code grant or quota widening. */
+export declare function recordProducerEmissions(handle: GeneratedProducer, outputs: readonly {
+    path: string;
+    digest: string;
+}[], invocation: DescendantInvocation): {
+    identity: string;
+    kind: string;
+    parent: string;
+    producer: string;
+    invocation: DescendantInvocation;
+    invocationIdentity: string;
+    outputs: {
+        path: string;
+        digest: string;
+        identity: string;
+        byteLength: number;
+    }[];
+};
+/** Verify the ACTUAL body/argv again before execution. A record's existence
+ * alone authorizes nothing and cannot be moved to another parent context. */
+export declare function verifyDerived(handle: GeneratedProducer, record: DerivedExecutable, actual: {
+    path?: string;
+    argv?: readonly string[];
+}): Uint8Array;
+export declare function gateDerived(handle: GeneratedProducer, record: DerivedExecutable, actual: {
+    path?: string;
+    argv?: readonly string[];
+}, snapshot: LiteralSnapshot, nativeImplementations?: ReadonlySet<string>): readonly {
+    target: string;
+    digest?: string;
+    platform?: string;
+}[];
+export declare function chargeProducerRequest(handle: GeneratedProducer): void;
+export declare function producerUsage(handle: GeneratedProducer): Readonly<{
+    members: number;
+    bytes: number;
+    work: number;
+    retainedContents: number;
+    codeBytes: number;
+    limits: {
+        members: number;
+        bytes: number;
+        work: number;
+        argvBytes: number;
+        argvItems: number;
+    };
+}>;
+/** Shared host traversal. The reader callback supplies verification; traversal
+ * itself introduces no provenance or execution authority. */
+export declare function traverseGeneratedClosure(input: {
+    source: Uint8Array;
+    path: string;
+    mode: 'module' | 'commonjs';
+    libs: ReadonlyMap<string, string>;
+    native: ReadonlySet<string>;
+    platform: string;
+    nativeImplementations: ReadonlySet<string>;
+    verify: (path: string) => {
+        real: string;
+        bytes: Uint8Array;
+        digest: string;
+    };
+    step: () => void;
+}): readonly {
+    target: string;
+    digest?: string;
+    platform?: string;
+}[];