@lapxo/bound 0.1.8 → 0.1.9

package/dist/host/capsule-process.js

@@ -1,4 +1,5 @@
 import { actCosts } from "./act-cost.js";
+import { fileURLToPath } from 'node:url';
 import { boundedProcess } from "./process-lifetime.js";
 import { spawnSync } from 'node:child_process';
 import { PROTOCOL } from '@lapxo/topos/wire';
@@ -35,7 +36,9 @@ export function validResponse(value, request) {
 /** Last-line JSON is the wire framing. No partial batch, failed exit or synthetic missing response is accepted. */
 export function executeCapsule(command, args, requests, limits = {}, lifetime) {
     return actCosts.measure(() => {
-        const run = lifetime === undefined ? spawnSync(command, args, { input: JSON.stringify(requests), encoding: 'utf8', maxBuffer: 1 << 26, ...limits }) : boundedProcess(command, args, JSON.stringify(requests), lifetime);
+        const cwd = limits.cwd;
+        const directory = cwd === undefined ? undefined : typeof cwd === 'string' ? cwd : fileURLToPath(cwd);
+        const run = lifetime === undefined ? spawnSync(command, args, { input: JSON.stringify(requests), encoding: 'utf8', maxBuffer: 1 << 26, ...limits }) : boundedProcess(command, args, JSON.stringify(requests), lifetime, directory, limits.env);
         if ('error' in run && run.error)
             throw new CapsuleProcessError(`failed: ${run.error.message}`, run);
         if (run.signal !== null || run.status !== 0)

package/dist/host/capsule.d.ts

@@ -2,6 +2,10 @@ import type { ReaderReference } from '@lapxo/topos/wire';
 import type { Declaration } from '@lapxo/topos/capsule';
 import type { Request, Response } from '@lapxo/topos/contract';
 export interface Capsule {
+    readonly selectedWorld?: {
+        readonly standing: import("@lapxo/topos/standing").StandingTopos;
+        readonly offer: string;
+    };
     readonly selection?: string;
     readonly digest: string;
     readonly declaration: Declaration;

package/dist/host/capsule.js

@@ -1,6 +1,9 @@
 import { readerLifetime, parse } from '@lapxo/topos/wire';
 import { contentStore, verifiedContent, contentPolicy } from "./content-store.js";
 import { readOnly } from "./read-only.js";
+import { readingBoundary } from "./reading-context.js";
+import { nativeReaderRoute } from "./native-reader-context.js";
+import { assertNativeRouteCurrent, invokeNativeRoute, materializeNativeRoute } from "./native/route.js";
 import { sha } from "./hash.js";
 import { wireLinesOf as linesOf } from "../fold/claims.js";
 import { createHash } from 'node:crypto';
@@ -87,6 +90,13 @@ const spawnOf = (at, names) => {
 };
 export const childFlags = (argv = process.execArgv) => argv.filter((flag, i) => !/^(-e|-p|--eval|--print)$/.test(argv[i - 1] ?? '') && !/^(-e|-p|--eval|--print|--input-type)(=|$)/.test(flag));
 function answered(digest, bytes, requests, names, tree, cacheStore = ownStore(), entry, reader) {
+    const boundary = readingBoundary();
+    const native = nativeReaderRoute();
+    if (native) {
+        if (!boundary?.execution || digest !== native.profile.selection.archive)
+            throw Error('REFUSE·native reader lacks its complete implementation identity');
+        assertNativeRouteCurrent(native);
+    }
     const child = entry === undefined ? spawnOf(tree ?? unpacked(digest, bytes), names) : [entry];
     if (!child.length) {
         process.stderr.write(`LOAD     regions · none of ${names.length} under the directories release/layout names\n`);
@@ -95,7 +105,7 @@ function answered(digest, bytes, requests, names, tree, cacheStore = ownStore(),
     const loader = entry !== undefined ? `${createHash('sha256').update(`${relative(tree, entry)}\n`).digest('hex')}\n` : child.length > 1 ? `${createHash('sha256').update(observeFile(child[0]) ?? new Uint8Array()).digest('hex')}\n` : '';
     const lifetime = readerLifetime(contentPolicy().flatMap(line => { const p = parse(line); return p.kind === 'fact' ? [p.value.fields] : []; }), reader ?? digest);
     const policy = lifetime === undefined ? '' : JSON.stringify(lifetime) + '\n';
-    const hitOf = (request) => sha(`${digest}\n${loader}${policy}${JSON.stringify(request)}`);
+    const hitOf = (request) => sha(`${digest}\n${loader}${policy}${boundary === undefined ? '' : boundary.identity + '\n'}${JSON.stringify(request)}`);
     const hits = requests.map(hitOf);
     const kept = hits.map(hit => storeAt(cacheStore, 'cas', 'answers', hit));
     const held = kept.map((at, i) => {
@@ -116,7 +126,11 @@ function answered(digest, bytes, requests, names, tree, cacheStore = ownStore(),
     if (missing.length)
         process.stderr.write(`CAPSULE  ${digest.slice(7, 19)} · ${requests.length} asked · ${missing.length} run · ${missing.map((one) => `${one.rootScope}${one.region}`).join(' ')}\n`);
     // Execute and validate the entire batch before committing any answer to the cache.
-    const ran = !missing.length ? [] : executeCapsule(process.execPath, [...childFlags(), hostOf(), ...child], missing, {}, lifetime);
+    if (native && !lifetime)
+        throw Error('REFUSE·native reader missing declared lifetime');
+    const ran = !missing.length ? [] : native
+        ? invokeNativeRoute(native, { ...materializeNativeRoute(native), requests: missing, execution: boundary.execution, limits: lifetime })
+        : executeCapsule(process.execPath, [...childFlags(boundary?.execution?.flags), hostOf(), ...child], missing, boundary?.execution ? { env: boundary.execution.env, cwd: boundary.execution.cwd } : {}, lifetime);
     return requests.map((request, i) => {
         if (held[i] !== undefined)
             return held[i];

package/dist/host/contextual-place.d.ts

@@ -0,0 +1,59 @@
+import { type PlaceReceipt } from '@lapxo/topos/core';
+export declare function hasContextualPlace(root: string): boolean;
+/** Exact selected SDK frame plus complete pre-signed receiver statements. No
+ * executable/verifier/epoch selection can be supplied by this envelope. */
+export declare function landContextualPlace(root: string, file: string): Promise<import("./ports/place-act.ts").PlaceActBundle & {
+    readonly kind: "landed" | "once";
+    readonly identity: string;
+}>;
+export declare function contextualAct(root: string, identity: string): {
+    profile: string;
+    identity: string;
+    context: string;
+    receipts: readonly PlaceReceipt[];
+    contexts: {
+        identity: string;
+        context: string;
+        receipts: readonly PlaceReceipt[];
+        authority: ReturnType<(encoded: string) => {
+            anchor: import("@lapxo/topos/wire").Signer;
+            history: readonly string[];
+            checkpoint: string;
+        }>;
+    }[];
+} | undefined;
+/** Carriers retain exact originals and authenticated context/receipts. Each
+ * namespace folds independently; labels assert no statistical independence. */
+export declare function contextualStanding(root: string): {
+    profile: string;
+    root: readonly string[];
+    legacyPlaces: {
+        namespace: string;
+        place: string;
+        standing: string[];
+        history: readonly string[];
+    }[];
+    contexts: {
+        identity: string;
+        context: string;
+        receipts: readonly PlaceReceipt[];
+        authority: {
+            anchor: import("@lapxo/topos/wire").Signer;
+            history: readonly string[];
+            checkpoint: string;
+        };
+    }[];
+    places: {
+        namespace: string;
+        place: string;
+        standing: string[];
+        retracted: readonly string[];
+        superseded: readonly string[];
+        forks: readonly import("../fold/claims.ts").Fork[];
+        contexts: {
+            identity: string;
+            context: string;
+            receipts: readonly PlaceReceipt[];
+        }[];
+    }[];
+};

package/dist/host/contextual-place.js

@@ -0,0 +1,77 @@
+import { openSync, fstatSync, readSync, closeSync } from 'node:fs';
+import { readPlaceActContext, PLACE_ACT_CONTEXT } from '@lapxo/topos/core';
+import { declaredRootClockSource, hasRootClockSource } from "./root-clock-source.js";
+import { commitPlaceAct, placeActResult, committedPlaceActResults } from "./ports/place-act.js";
+import { placesIn } from "../fold/places.js";
+import { appliedHistoryIn } from "../fold/signed.js";
+import { storeOf } from "../land/ledger.js";
+import { authenticatedRootStanding } from "./admitted-place.js";
+import { foldClaims, fieldOf } from "../fold/claims.js";
+const fail = (s) => { throw Error('REFUSE·contextual place ' + s); };
+function read(path, limit) {
+    const fd = openSync(path, 'r');
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > limit)
+            fail('batch byte budget');
+        const data = Buffer.alloc(stat.size);
+        let n = 0;
+        while (n < data.length) {
+            const got = readSync(fd, data, n, data.length - n, null);
+            if (!got)
+                fail('batch changed during read');
+            n += got;
+        }
+        if (readSync(fd, Buffer.alloc(1), 0, 1, null))
+            fail('batch changed during read');
+        return new TextDecoder('utf8', { fatal: true }).decode(data);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function hasContextualPlace(root) { return hasRootClockSource(root); }
+/** Exact selected SDK frame plus complete pre-signed receiver statements. No
+ * executable/verifier/epoch selection can be supplied by this envelope. */
+export async function landContextualPlace(root, file) {
+    const selected = declaredRootClockSource(root), raw = read(file, selected.selection.budget.bytes);
+    let packet;
+    try {
+        packet = JSON.parse(raw);
+    }
+    catch {
+        return fail('invalid batch JSON');
+    }
+    if (!packet || Object.keys(packet).sort().join(',') !== 'context,profile,receipts' || packet.profile !== PLACE_ACT_CONTEXT || typeof packet.context !== 'string' || !Array.isArray(packet.receipts) || JSON.stringify(packet) + '\n' !== raw)
+        fail('unsupported/noncanonical batch envelope');
+    return commitPlaceAct(storeOf(root), packet.context, packet.receipts, selected.trust, selected.selection.storageBudget);
+}
+export function contextualAct(root, identity) {
+    const selected = declaredRootClockSource(root), bundle = placeActResult(storeOf(root), identity, selected.trust, selected.selection.storageBudget);
+    if (!bundle)
+        return undefined;
+    const all = new Map(committedPlaceActResults(storeOf(root), selected.trust, selected.selection.storageBudget).map(a => [a.identity, a])), kept = new Set(), contexts = [];
+    const visit = (id) => { if (kept.has(id))
+        return; const a = all.get(id); if (!a)
+        return; kept.add(id); const decoded = readPlaceActContext(a.bundle.context, selected.selection.budget); for (const p of decoded.places)
+        visit(p.previous); contexts.push({ identity: a.identity, context: a.bundle.context, receipts: a.bundle.receipts, authority: selected.authority(a.bundle.context) }); };
+    visit(identity);
+    return { profile: PLACE_ACT_CONTEXT, identity, context: bundle.context, receipts: bundle.receipts, contexts };
+}
+/** Carriers retain exact originals and authenticated context/receipts. Each
+ * namespace folds independently; labels assert no statistical independence. */
+export function contextualStanding(root) {
+    const selected = declaredRootClockSource(root), acts = committedPlaceActResults(storeOf(root), selected.trust, selected.selection.storageBudget);
+    const groups = new Map();
+    for (const act of acts) {
+        const decoded = readPlaceActContext(act.bundle.context, selected.selection.budget);
+        for (const p of decoded.places) {
+            const key = JSON.stringify([decoded.root.namespace, p.place]), group = groups.get(key) ?? { namespace: decoded.root.namespace, place: p.place, lines: [], contexts: [] };
+            group.lines.push(...p.records);
+            group.contexts.push({ identity: act.identity, context: act.bundle.context, receipts: act.bundle.receipts });
+            groups.set(key, group);
+        }
+    }
+    const legacyPlaces = placesIn(root).map(place => { const history = appliedHistoryIn(root, place), folded = foldClaims(history); return { namespace: 'legacy-global', place: [place, 'TARGET.bound'].join('/'), standing: folded.standing.filter(line => fieldOf(line, 'value') !== 'withdraw'), history }; });
+    return { profile: PLACE_ACT_CONTEXT, root: authenticatedRootStanding(root), legacyPlaces, contexts: acts.map(a => ({ identity: a.identity, context: a.bundle.context, receipts: a.bundle.receipts, authority: selected.authority(a.bundle.context) })), places: [...groups.values()].map(group => { const folded = foldClaims(group.lines); return { namespace: group.namespace, place: group.place, standing: folded.standing.filter(line => fieldOf(line, 'value') !== 'withdraw'), retracted: folded.retracted, superseded: folded.superseded, forks: folded.forks, contexts: group.contexts }; }) };
+}

package/dist/host/hash.d.ts

@@ -1,2 +1,9 @@
+import { type Hash } from 'node:crypto';
 /** SHA-256 byte hashing for host formats that explicitly name this algorithm. */
 export declare const sha: (bytes: string | Uint8Array) => string;
+/** Typed digest spelling shared by fixed host boundaries; hashes identical bytes. */
+export declare const sha256: (bytes: string | Uint8Array) => string;
+/** Length-delimited UTF-8 fields for existing host history identities. */
+export declare function hashText(hash: Hash, value: string): void;
+/** Exact typed SHA-256 spelling used by fixed host declarations. */
+export declare const isSha256: (value: unknown) => value is string;

package/dist/host/hash.js

@@ -1,3 +1,9 @@
 import { createHash } from 'node:crypto';
 /** SHA-256 byte hashing for host formats that explicitly name this algorithm. */
 export const sha = (bytes) => createHash('sha256').update(bytes).digest('hex');
+/** Typed digest spelling shared by fixed host boundaries; hashes identical bytes. */
+export const sha256 = (bytes) => 'sha256:' + sha(bytes);
+/** Length-delimited UTF-8 fields for existing host history identities. */
+export function hashText(hash, value) { hash.update(String(Buffer.byteLength(value, 'utf8')) + ':'); hash.update(value, 'utf8'); }
+/** Exact typed SHA-256 spelling used by fixed host declarations. */
+export const isSha256 = (value) => typeof value === 'string' && /^sha256:[0-9a-f]{64}$/.test(value);

package/dist/host/io.d.ts

@@ -7,3 +7,5 @@ export { basename, dirname, join, relative, resolve } from 'node:path';
 export { fileURLToPath } from 'node:url';
 export { parentPort, workerData } from 'node:worker_threads';
 export { gzipSync } from 'node:zlib';
+/** UTF-8 encoding for host byte formats. */
+export declare const encodeUTF8: (text: string) => Uint8Array;

package/dist/host/io.js

@@ -7,3 +7,5 @@ export { basename, dirname, join, relative, resolve } from 'node:path';
 export { fileURLToPath } from 'node:url';
 export { parentPort, workerData } from 'node:worker_threads';
 export { gzipSync } from 'node:zlib';
+/** UTF-8 encoding for host byte formats. */
+export const encodeUTF8 = (text) => new TextEncoder().encode(text);

package/dist/host/lifetime.js

@@ -1,14 +1,11 @@
 import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-// This is a host mechanism, not a wire reader or a provider. The parent supplies its already selected policy.
-const request = JSON.parse(readFileSync(0, 'utf8'));
-if (!Number.isSafeInteger(request.limits.timeoutMs) || request.limits.timeoutMs <= 0 || !Number.isSafeInteger(request.limits.responseBytes) || request.limits.responseBytes <= 0)
+const deadline = BigInt(process.argv[2] ?? '0'), responseBytes = Number(process.argv[3]);
+if (deadline <= 0n || !Number.isSafeInteger(responseBytes) || responseBytes <= 0)
     throw Error('REFUSE·reader invalid process limits');
-const grouped = process.platform !== 'win32';
-const child = spawn(request.command, [...request.args], { cwd: request.cwd, env: request.env, detached: grouped, stdio: ['pipe', 'pipe', 'pipe'] });
+let child, finished = false, failure, size = 0;
 const stdout = [], stderr = [];
-let size = 0, failure, finished = false;
-const cancel = () => { if (child.pid === undefined)
+const grouped = process.platform !== 'win32';
+const cancel = () => { if (child?.pid === undefined)
     return; try {
     if (grouped)
         process.kill(-child.pid, 'SIGKILL');
@@ -16,25 +13,67 @@ const cancel = () => { if (child.pid === undefined)
         child.kill('SIGKILL');
 }
 catch { } };
-const refuse = (why) => { failure ?? (failure = why); cancel(); };
-const receive = (chunks, bytes) => { size += bytes.length; if (size > request.limits.responseBytes) {
-    refuse('response exceeds declared byte bound');
-    return;
-} chunks.push(bytes); };
-child.stdout.on('data', (bytes) => receive(stdout, bytes));
-child.stderr.on('data', (bytes) => receive(stderr, bytes));
-child.stdin.on('error', error => { if (!finished)
-    refuse(`input failed: ${error.message}`); });
-const timer = setTimeout(() => refuse('declared timeout exhausted'), request.limits.timeoutMs);
 const finish = (status, signal) => {
     if (finished)
         return;
     finished = true;
     clearTimeout(timer);
     cancel();
-    const result = { stdout: failure ? '' : Buffer.concat(stdout).toString('utf8'), stdoutBytes: failure ? '' : Buffer.concat(stdout).toString('base64'), stderr: failure ? '' : Buffer.concat(stderr).toString('utf8'), status, signal, ...(failure ? { failure } : {}) };
+    child?.stdin?.destroy();
+    child?.stdout?.destroy();
+    child?.stderr?.destroy();
+    process.stdin.destroy();
+    const bytes = failure ? Buffer.alloc(0) : Buffer.concat(stdout);
+    const result = { stdout: bytes.toString('utf8'), stdoutBytes: bytes.toString('base64'), stderr: Buffer.concat(stderr).toString('utf8'), status, signal, ...(failure ? { failure } : {}) };
     process.stdout.write(JSON.stringify(result));
 };
-child.on('error', error => { failure = error.message; finish(null, null); });
-child.on('close', finish);
-child.stdin.end(request.input);
+const refuse = (why) => { if (failure && why === 'response exceeds declared byte bound' && !failure.includes(why))
+    failure += ' · ' + why;
+else
+    failure ?? (failure = why); finish(null, 'SIGKILL'); };
+// A closed input pipe can precede the queued stderr/close events of an early
+// rejecting child. Cancel immediately, but drain only until the SAME deadline.
+const inputFailed = (why) => { if (finished)
+    return; failure ?? (failure = why); stdout.length = 0; cancel(); child?.stdin?.destroy(); process.stdin.destroy(); if (process.hrtime.bigint() >= deadline)
+    finish(null, 'SIGKILL'); };
+const remaining = Number(deadline - process.hrtime.bigint()) / 1e6;
+const timer = setTimeout(() => refuse('declared timeout exhausted'), Math.max(0, remaining));
+process.once('SIGTERM', () => refuse('interrupted'));
+try {
+    if (remaining <= 0)
+        refuse('declared timeout exhausted');
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        if (finished)
+            break;
+        chunks.push(Buffer.from(chunk));
+    }
+    if (!finished) {
+        const request = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        if (request.limits.responseBytes !== responseBytes || !Number.isSafeInteger(request.limits.timeoutMs) || request.limits.timeoutMs <= 0)
+            throw Error('invalid process limits');
+        // Parsing is synchronous; recheck before spawning even if the timer has not
+        // had a turn to run. An expired handoff must never start the command.
+        if (process.hrtime.bigint() >= deadline) {
+            refuse('declared timeout exhausted');
+        }
+        else {
+            child = spawn(request.command, [...request.args], { cwd: request.cwd, env: request.env, detached: grouped, stdio: ['pipe', 'pipe', 'pipe'] });
+            const receive = (items, bytes) => { if (finished)
+                return; size += bytes.length; if (size > responseBytes)
+                refuse('response exceeds declared byte bound');
+            else if (!failure || items === stderr)
+                items.push(bytes); };
+            child.stdout.on('data', (b) => receive(stdout, b));
+            child.stderr.on('data', (b) => receive(stderr, b));
+            child.stdin.on('error', error => inputFailed('input failed: ' + error.message));
+            child.once('error', error => refuse(error.message));
+            child.once('close', finish);
+            child.stdin.end(request.input);
+        }
+    }
+}
+catch {
+    if (!finished)
+        refuse('input unavailable or malformed');
+}

package/dist/host/native/bounded-file.d.ts

@@ -0,0 +1,8 @@
+/** The opened descriptor is bounded before allocation/read. Growth after fstat
+ * is detected with one sentinel byte; no oversized buffer reaches decode/hash.
+ */
+export declare function readBoundedFile(path: string, remaining: number, coordinate: string): Buffer;
+export declare function readBoundedBatch(paths: readonly {
+    path: string;
+    coordinate: string;
+}[], budget: number): readonly Buffer[];

package/dist/host/native/bounded-file.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+/** The opened descriptor is bounded before allocation/read. Growth after fstat
+ * is detected with one sentinel byte; no oversized buffer reaches decode/hash.
+ */
+export function readBoundedFile(path, remaining, coordinate) {
+    if (!Number.isSafeInteger(remaining) || remaining < 0)
+        throw Error('REFUSE·native file missing byte budget ' + coordinate);
+    const fd = fs.openSync(path, 'r');
+    try {
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || !Number.isSafeInteger(stat.size) || stat.size > remaining)
+            throw Error('REFUSE·native file byte budget before read ' + coordinate);
+        const bytes = Buffer.alloc(stat.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const count = fs.readSync(fd, bytes, offset, bytes.length - offset, null);
+            if (!count)
+                throw Error('REFUSE·native file changed during read ' + coordinate);
+            offset += count;
+        }
+        if (fs.readSync(fd, Buffer.alloc(1), 0, 1, null) !== 0)
+            throw Error('REFUSE·native file grew during read ' + coordinate);
+        return bytes;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export function readBoundedBatch(paths, budget) {
+    let bytes = 0;
+    return paths.map(file => { const data = readBoundedFile(file.path, budget - bytes, file.coordinate); bytes += data.length; return data; });
+}

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

@@ -0,0 +1,36 @@
+import type { CommandPort, CommandLot } from '@lapxo/topos/contract';
+type Phase = 'selection' | 'help' | 'check' | 'preview' | 'sign' | 'act';
+export interface Invocation {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly hostEnvelope?: Uint8Array;
+    readonly envelopeBytes?: number;
+}
+export interface HostBoundary {
+    readonly admitsDeclaration: (port: CommandPort) => boolean;
+    readonly covers: (coordinate: string) => boolean;
+    readonly verifies: (digest: string) => boolean;
+    /** Host chooses a verified invocation. A capsule cannot supply a program. */
+    readonly resolve: (port: CommandPort) => Invocation;
+    /** Independent loader-closure proof, not a digest-list membership test. */
+    readonly loaderClosure: (port: CommandPort, invocation: Invocation) => 'verified' | 'unmeasured';
+}
+/** macOS prototype: bounded async invocation with POSIX child-group cancellation.
+ * No acquisition or persistence on prospective paths; no partial success frames.
+ * Host callbacks are trusted admission/verification operations, never signatures
+ * or authority assertions supplied by the command's own output. */
+export declare function executeLot(options: {
+    port: CommandPort;
+    lot: CommandLot;
+    host: HostBoundary;
+    phase: Phase;
+    environment: Readonly<Record<string, string>>;
+    signal?: AbortSignal;
+    accepts: (member: unknown, index: number) => boolean;
+}): Promise<{
+    readonly members: readonly unknown[];
+    readonly stderr: string;
+    readonly invocations: 1;
+}>;
+export {};

package/dist/host/native/command.js

@@ -0,0 +1,91 @@
+import { spawn } from 'node:child_process';
+import { channel } from 'node:diagnostics_channel';
+import { isAbsolute } from 'node:path';
+import { checkCommandPort, commandRequest, commandResponse } from '@lapxo/topos/contract';
+import { requireEffects } from "../read-only.js";
+import { assertNativeRuntime } from "./runtime.js";
+import { scheduleDeadline } from "./deadline.js";
+const rejectedCommand = channel('bound.command.refusal');
+/** macOS prototype: bounded async invocation with POSIX child-group cancellation.
+ * No acquisition or persistence on prospective paths; no partial success frames.
+ * Host callbacks are trusted admission/verification operations, never signatures
+ * or authority assertions supplied by the command's own output. */
+export async function executeLot(options) {
+    const start = process.hrtime.bigint();
+    const { host, signal, phase, accepts } = options;
+    // Admitted semantic configuration is snapshotted for the whole invocation;
+    // mutations of a caller's delivery object cannot alter checks mid-flight.
+    const port = Object.freeze({ ...options.port, closure: Object.freeze([...options.port.closure]), environment: Object.freeze([...options.port.environment]) });
+    const lot = Object.freeze({ ...options.lot, requests: Object.freeze([...options.lot.requests]) });
+    const environment = Object.freeze({ ...options.environment });
+    assertNativeRuntime(environment, []);
+    const refuse = (why) => { throw Error(`REFUSE·port ${port.coordinate} ${why}`); };
+    if (phase !== 'act')
+        refuse('invocation forbidden during ' + phase);
+    requireEffects('command ' + port.coordinate);
+    if (signal?.aborted)
+        refuse('interrupted before invocation');
+    checkCommandPort(port, host);
+    const deadline = start + BigInt(port.timeoutMs) * 1000000n;
+    const resolved = host.resolve(port), invocation = Object.freeze({ ...resolved, args: Object.freeze([...resolved.args]) });
+    if (!isAbsolute(invocation.command) || !isAbsolute(invocation.cwd))
+        refuse('host invocation needs absolute coordinates');
+    if (host.loaderClosure(port, invocation) !== 'verified')
+        refuse('runtime-loader closure unmeasured');
+    const names = Object.keys(environment).sort(), declared = [...new Set(port.environment)].sort();
+    if (names.length !== declared.length || names.some((name, index) => name !== declared[index]) || names.some(name => typeof environment[name] !== 'string' || environment[name].includes('\0')))
+        refuse('environment differs from declared handoff');
+    const frame = commandRequest(port, lot);
+    const envelope = invocation.hostEnvelope;
+    if (envelope && (!Number.isSafeInteger(invocation.envelopeBytes) || invocation.envelopeBytes < 1 || envelope.byteLength > invocation.envelopeBytes))
+        refuse('host envelope byte resources');
+    if (process.hrtime.bigint() >= deadline)
+        refuse('timeout before invocation');
+    if (signal?.aborted)
+        refuse('interrupted before invocation');
+    const result = await new Promise((resolve, reject) => {
+        const child = spawn(invocation.command, [...invocation.args], { cwd: invocation.cwd, env: { ...environment }, shell: false, detached: false, stdio: envelope ? ['pipe', 'pipe', 'pipe', 'pipe'] : ['pipe', 'pipe', 'pipe'] });
+        const stdout = [], stderr = [];
+        let bytes = 0, why, done = false;
+        const stop = (cause) => { if (why)
+            return; why = cause; try {
+            child.kill('SIGKILL');
+        }
+        catch { } child.stdin.destroy(); if (envelope)
+            child.stdio[3]?.destroy(); };
+        const cancelTimer = scheduleDeadline(deadline, () => stop('timeout'));
+        const abort = () => stop('interrupted');
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        const collect = (target, chunk, channel) => { if (why)
+            return; bytes += chunk.length; if (bytes > port.responseBytes) {
+            stop('response-bytes exceeded');
+            return;
+        } if (channel === 'stderr' && port.stderr === 'reject') {
+            rejectedCommand.publish({ coordinate: port.coordinate, stderr: chunk.subarray(0, Math.min(port.responseBytes, 1024)).toString('utf8') });
+            stop('stderr forbidden');
+            return;
+        } target.push(chunk); };
+        child.stdout.on('data', (chunk) => collect(stdout, chunk, 'stdout'));
+        child.stderr.on('data', (chunk) => collect(stderr, chunk, 'stderr'));
+        child.stdin.on('error', () => stop('request handoff failed'));
+        const finish = (status, error) => { if (done)
+            return; done = true; cancelTimer(); signal?.removeEventListener('abort', abort); if (error || why) {
+            reject(Error(`REFUSE·port ${port.coordinate} ${why ?? error.message}`));
+            return;
+        } resolve({ status, interrupted: false, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') }); };
+        child.once('error', error => finish(null, error));
+        child.once('close', status => finish(status));
+        if (envelope) {
+            const pipe = child.stdio[3];
+            const header = Buffer.alloc(8);
+            header.writeBigUInt64BE(BigInt(envelope.byteLength));
+            pipe.on('error', () => stop('host envelope handoff failed'));
+            pipe.end(Buffer.concat([header, Buffer.from(envelope)]));
+        }
+        child.stdin.end(frame);
+    });
+    const members = commandResponse(port, lot, result, accepts);
+    return { members, stderr: result.stderr, invocations: 1 };
+}

package/dist/host/native/control-bridge-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/host/native/control-bridge-worker.js

@@ -0,0 +1,88 @@
+/** Sealed Root control code: one fresh custodian connection per request. */
+import { parentPort, workerData } from 'node:worker_threads';
+import { createConnection } from 'node:net';
+const { endpoint, deadlineMs, shared, inputBytes, outputBytes } = workerData;
+const port = parentPort;
+if (!port)
+    throw Error('REFUSE·Root control transport parent absent');
+const header = new Int32Array(shared, 0, 8), input = new Uint8Array(shared, 32, inputBytes), output = new Uint8Array(shared, 32 + inputBytes, outputBytes);
+const initial = Math.min(endpoint.timeoutMs, deadlineMs - Date.now());
+const deadline = process.hrtime.bigint() + BigInt(Math.max(0, initial)) * 1000000n;
+const remaining = () => Math.max(0, Number((deadline - process.hrtime.bigint() + 999999n) / 1000000n));
+let busy = false, red, active;
+function finish(state, bytes) {
+    if (bytes.byteLength > outputBytes) {
+        state = 3;
+        bytes = Buffer.from('REFUSE·reply bytes').subarray(0, outputBytes);
+    }
+    output.set(bytes);
+    Atomics.store(header, 3, bytes.byteLength);
+    Atomics.store(header, 0, state);
+    Atomics.notify(header, 0);
+}
+// Timer slices never widen the original monotonic deadline.
+let timer;
+function arm() {
+    const left = remaining();
+    if (left > 0) {
+        timer = setTimeout(arm, Math.min(left, 2147483647));
+        timer.unref();
+        return;
+    }
+    red ?? (red = 'REFUSE·parent deadline');
+    active?.destroy(Error(red));
+    if (Atomics.load(header, 0) === 1)
+        finish(3, Buffer.from(red).subarray(0, outputBytes));
+    port.close();
+}
+arm();
+port.on('close', () => { clearTimeout(timer); active?.destroy(); });
+port.on('message', async (message) => {
+    if (busy || red || message !== Atomics.load(header, 1) || Atomics.load(header, 0) !== 1) {
+        red ?? (red = 'REFUSE·sequence/state');
+        finish(3, Buffer.from(red).subarray(0, outputBytes));
+        return;
+    }
+    busy = true;
+    try {
+        const length = Atomics.load(header, 2);
+        if (length < 1 || length > inputBytes)
+            throw Error('REFUSE·request bytes');
+        if (remaining() <= 0)
+            throw Error('REFUSE·parent deadline');
+        const frame = Buffer.from(input.slice(0, length));
+        const bytes = await new Promise((resolve, reject) => {
+            const socket = createConnection(endpoint.socket);
+            active = socket;
+            const chunks = [];
+            let size = 0, done = false;
+            const end = (error) => { if (done)
+                return; done = true; if (error)
+                reject(error);
+            else
+                resolve(Buffer.concat(chunks)); };
+            socket.once('connect', () => socket.write(Buffer.concat([frame, Buffer.from('\n')])));
+            socket.on('data', chunk => { size += chunk.length; if (size > outputBytes)
+                socket.destroy(Error('REFUSE·reply bytes'));
+            else
+                chunks.push(chunk); });
+            socket.once('error', end);
+            socket.once('close', () => end());
+        });
+        active = undefined;
+        if (!bytes.length)
+            throw Error('REFUSE·interrupted before reply');
+        if (remaining() <= 0)
+            throw Error('REFUSE·parent deadline');
+        busy = false;
+        finish(2, bytes);
+    }
+    catch (error) {
+        active = undefined;
+        red ?? (red = error instanceof Error ? error.message : String(error));
+        busy = false;
+        finish(3, Buffer.from(red).subarray(0, outputBytes));
+    }
+});
+Atomics.store(header, 5, 1);
+Atomics.notify(header, 5);

package/dist/host/native/control-bridge.d.ts

@@ -0,0 +1,30 @@
+export interface ControlEndpoint {
+    readonly socket: string;
+    readonly timeoutMs: number;
+    readonly deadlineMs: number;
+    readonly responseBytes: number;
+}
+export interface FixedControlBinding {
+    readonly endpoint: ControlEndpoint;
+    readonly workerBytes: Uint8Array;
+    readonly worker: {
+        readonly digest: string;
+        readonly coordinate: string;
+        readonly bytes: number;
+    };
+    readonly runtime: {
+        readonly path: string;
+        readonly digest: string;
+        readonly bytes: number;
+    };
+    readonly resources: {
+        readonly inputBytes: number;
+        readonly outputBytes: number;
+        readonly sharedBytes: number;
+    };
+    readonly deadlineMs: number;
+}
+export declare function createFixedControlBridge(inputBinding: FixedControlBinding): {
+    exchange(frame: string): string;
+    close(): Promise<void>;
+};