chati-dev 4.5.28 → 4.5.29

package/node_modules/@chati/core/src/descriptor-fs.js

@@ -0,0 +1,222 @@
+import {
+  constants, linkSync, lstatSync, mkdirSync, openSync, readdirSync, readlinkSync, realpathSync, renameSync, unlinkSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+
+const require = createRequire(import.meta.url);
+let binding;
+
+function invalid(code, message) { throw Object.assign(new TypeError(message), { code }); }
+
+function descriptor(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 0x7fffffff) {
+    invalid('INVALID_STORAGE_ARGUMENT', 'storage descriptor must be a nonnegative signed integer');
+  }
+  return value;
+}
+
+function component(value) {
+  if (typeof value !== 'string' || !value || value === '.' || value === '..'
+    || /[/\\\0]/.test(value) || Buffer.byteLength(value) > 255) {
+    invalid('INVALID_STORAGE_NAME', 'storage name must be one bounded path component');
+  }
+  return value;
+}
+
+function linuxReference(fd, name) { return join(`/proc/self/fd/${descriptor(fd)}`, component(name)); }
+
+function native() {
+  assertDescriptorStorageSupported();
+  if (!binding) {
+    try { binding = require(`../native/prebuilds/${process.platform}-${process.arch}/descriptor-fs.node`); }
+    catch (cause) {
+      throw Object.assign(new Error('The native descriptor-storage binary is missing or incompatible; reinstall a package built for this platform'), {
+        code: 'NATIVE_STORAGE_UNAVAILABLE', cause,
+      });
+    }
+  }
+  return binding;
+}
+
+export function assertDescriptorStorageSupported() {
+  if (!['linux', 'darwin'].includes(process.platform)) {
+    throw Object.assign(new Error(`descriptor-relative storage is unsupported on ${process.platform}`), {
+      code: 'UNSUPPORTED_DESCRIPTOR_STORAGE_PLATFORM',
+    });
+  }
+}
+
+export function openAtSync(fd, name, flags, mode = 0o600) {
+  descriptor(fd); component(name);
+  descriptor(flags);
+  if (!Number.isInteger(mode) || mode < 0 || mode > 0o777) invalid('INVALID_STORAGE_ARGUMENT', 'invalid file mode');
+  if (process.platform === 'linux') return openSync(linuxReference(fd, name), flags | constants.O_NOFOLLOW, mode);
+  return native().openAt(fd, name, flags, mode);
+}
+
+export function tryExclusiveFileLockSync(fd) {
+  descriptor(fd);
+  const api = native();
+  if (typeof api.tryExclusiveFileLock !== 'function') {
+    throw Object.assign(new Error('native storage binary lacks descriptor locking; reinstall the matching package build'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.tryExclusiveFileLock(fd);
+}
+
+export function trySharedFileLockSync(fd) {
+  descriptor(fd);
+  const api = native();
+  if (typeof api.trySharedFileLock !== 'function') {
+    throw Object.assign(new Error('native storage binary lacks shared descriptor locking; reinstall the matching package build'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.trySharedFileLock(fd);
+}
+
+export function createProcessInfoPipeSync() {
+  const api = native();
+  if (typeof api.processPipe !== 'function') {
+    throw Object.assign(new Error('matching native storage lacks private process pipes'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.processPipe();
+}
+
+function darwinBrowserListenerApi() {
+  if (process.platform !== 'darwin') invalid('DARWIN_BROWSER_LISTENER_UNAVAILABLE', 'prebound Darwin listener requires macOS');
+  const api = native();
+  if (typeof api.createDarwinBrowserListener !== 'function' || typeof api.inspectDarwinBrowserListener !== 'function') {
+    invalid('NATIVE_STORAGE_UNAVAILABLE', 'matching native binary lacks prebound browser listeners');
+  }
+  return api;
+}
+
+function browserListenerPort(port) {
+  if (!Number.isInteger(port) || port < 1024 || port > 65535) invalid('INVALID_STORAGE_ARGUMENT', 'browser listener port must be an unprivileged TCP port');
+  return port;
+}
+
+export function createDarwinBrowserListenerSync(port) {
+  browserListenerPort(port);
+  return darwinBrowserListenerApi().createDarwinBrowserListener(port);
+}
+
+export function inspectDarwinBrowserListenerSync(fd, port) {
+  descriptor(fd); browserListenerPort(port);
+  return darwinBrowserListenerApi().inspectDarwinBrowserListener(fd, port);
+}
+
+// One bounded message per channel, authenticated by exclusive descriptor
+// inheritance at the caller. Partial data is not a message: EOF is required.
+export function readProcessInfoPipeSync(fd, timeoutMs = 5000) {
+  descriptor(fd);
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 30000) {
+    invalid('INVALID_STORAGE_ARGUMENT', 'process pipe deadline must be an integer between 0 and 30000 milliseconds');
+  }
+  const api = native();
+  if (typeof api.readProcessPipe !== 'function') {
+    throw Object.assign(new Error('matching native storage lacks private process pipe reading'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.readProcessPipe(fd, timeoutMs);
+}
+
+export function duplicateDirectorySync(fd) {
+  descriptor(fd);
+  if (process.platform === 'linux') return openSync(`/proc/self/fd/${fd}`, constants.O_RDONLY | constants.O_DIRECTORY);
+  return native().duplicateDirectory(fd);
+}
+
+export function directoryPathSync(fd) {
+  descriptor(fd);
+  if (process.platform === 'linux') return realpathSync(`/proc/self/fd/${fd}`);
+  return native().directoryPath(fd);
+}
+
+export function readDirectorySync(fd, { encoding = 'utf8' } = {}) {
+  descriptor(fd);
+  if (!['utf8', 'buffer'].includes(encoding)) invalid('INVALID_STORAGE_ARGUMENT', 'unsupported directory name encoding');
+  if (process.platform === 'linux') return readdirSync(`/proc/self/fd/${fd}`, { encoding });
+  const api = native();
+  if (encoding === 'utf8') return api.readDirectory(fd);
+  if (typeof api.readDirectoryBytes !== 'function') {
+    throw Object.assign(new Error('matching native storage lacks lossless directory enumeration'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.readDirectoryBytes(fd);
+}
+
+export function readlinkAtSync(fd, name) {
+  descriptor(fd); component(name);
+  if (process.platform === 'linux') return readlinkSync(linuxReference(fd, name), { encoding: 'buffer' });
+  const api = native();
+  if (typeof api.readlinkAt !== 'function') {
+    throw Object.assign(new Error('matching native storage lacks descriptor-relative symlink capture'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.readlinkAt(fd, name);
+}
+
+export function mkdirAtSync(fd, name, { mode = 0o700 } = {}) {
+  descriptor(fd); component(name);
+  if (!Number.isInteger(mode) || mode < 0 || mode > 0o777) invalid('INVALID_STORAGE_ARGUMENT', 'invalid directory mode');
+  if (process.platform === 'linux') return mkdirSync(linuxReference(fd, name), { mode });
+  return native().mkdirAt(fd, name, mode);
+}
+
+export function renameAtSync(fromFd, from, toFd, to) {
+  descriptor(fromFd); component(from); descriptor(toFd); component(to);
+  if (process.platform === 'linux') return renameSync(linuxReference(fromFd, from), linuxReference(toFd, to));
+  return native().renameAt(fromFd, from, toFd, to);
+}
+
+export function renameNoReplaceAtSync(fromFd, from, toFd, to) {
+  descriptor(fromFd); component(from); descriptor(toFd); component(to);
+  const api = native();
+  if (typeof api.renameNoReplaceAt !== 'function') {
+    throw Object.assign(new Error('matching native storage lacks atomic no-replace rename'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.renameNoReplaceAt(fromFd, from, toFd, to);
+}
+
+export function symlinkAtSync(target, fd, name) {
+  descriptor(fd); component(name);
+  if (!Buffer.isBuffer(target) || !target.length || target.includes(0)) invalid('INVALID_STORAGE_ARGUMENT', 'invalid raw symlink target');
+  const api = native();
+  if (typeof api.symlinkAt !== 'function') {
+    throw Object.assign(new Error('matching native storage lacks descriptor-relative symlink creation'), { code: 'NATIVE_STORAGE_UNAVAILABLE' });
+  }
+  return api.symlinkAt(target, fd, name);
+}
+
+export function linkAtSync(fromFd, from, toFd, to) {
+  descriptor(fromFd); component(from); descriptor(toFd); component(to);
+  if (process.platform === 'linux') return linkSync(linuxReference(fromFd, from), linuxReference(toFd, to));
+  return native().linkAt(fromFd, from, toFd, to);
+}
+
+export function unlinkAtSync(fd, name, { force = false } = {}) {
+  descriptor(fd); component(name);
+  try {
+    if (process.platform === 'linux') return unlinkSync(linuxReference(fd, name));
+    return native().unlinkAt(fd, name);
+  } catch (error) {
+    if (force && error.code === 'ENOENT') return undefined;
+    throw error;
+  }
+}
+
+export function lstatAtSync(fd, name, { bigint = false } = {}) {
+  descriptor(fd); component(name);
+  if (process.platform === 'linux') return lstatSync(linuxReference(fd, name), { bigint });
+  const raw = native().statAt(fd, name);
+  const stat = Object.fromEntries(Object.entries(raw).map(([key, value]) => [key, bigint ? value : Number(value)]));
+  for (const time of ['atime', 'mtime', 'ctime']) {
+    stat[`${time}Ms`] = bigint ? raw[`${time}Ns`] / 1_000_000n
+      : Number(raw[`${time}Ns`] / 1_000_000n) + Number(raw[`${time}Ns`] % 1_000_000n) / 1e6;
+    stat[time] = new Date(Number(raw[`${time}Ns`] / 1_000_000n));
+  }
+  const type = Number(raw.mode) & constants.S_IFMT;
+  for (const [method, kind] of Object.entries({
+    isFile: constants.S_IFREG, isDirectory: constants.S_IFDIR, isSymbolicLink: constants.S_IFLNK,
+    isFIFO: constants.S_IFIFO, isSocket: constants.S_IFSOCK,
+    isBlockDevice: constants.S_IFBLK, isCharacterDevice: constants.S_IFCHR,
+  })) stat[method] = () => type === kind;
+  return Object.freeze(stat);
+}

package/node_modules/@chati/core/src/execution-gate.js

@@ -0,0 +1,8 @@
+import { fileURLToPath } from 'node:url';
+import { assertDescriptorStorageSupported } from './descriptor-fs.js';
+
+/** A packaged native boundary, never downloaded or compiled at user runtime. */
+export function nativeExecutionGatePath() {
+  assertDescriptorStorageSupported();
+  return fileURLToPath(new URL(`../native/prebuilds/${process.platform}-${process.arch}/execution-gate`, import.meta.url));
+}

package/node_modules/@chati/core/src/host-boot-marker.js

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { captureDarwinHostBootIdentity } from './darwin-host-boot.js';
+
+const LINUX_BOOT_ID = '/proc/sys/kernel/random/boot_id';
+const MARKER_KEYS = ['schema_version', 'platform', 'boot_sha256'];
+const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+
+/** Cheap, unprivileged marker of the current kernel boot on this host, for
+ * lock-owner liveness only. A recycled PID after a reboot must not keep a lock
+ * busy forever. Returns null when the platform cannot supply one; callers then
+ * fall back to PID liveness alone. This is not an authority identity. */
+export function captureHostBootMarker() {
+  try {
+    if (process.platform === 'darwin') {
+      const identity = captureDarwinHostBootIdentity();
+      return Object.freeze({
+        schema_version: 1, platform: 'darwin',
+        boot_sha256: sha256(`chati-darwin-boot-v1\0${identity.host_id_sha256}\0${identity.boot_session_uuid}`),
+      });
+    }
+    if (process.platform === 'linux') {
+      const bootId = readFileSync(LINUX_BOOT_ID, 'utf8').trim();
+      if (!/^[a-f0-9-]{36}$/.test(bootId)) return null;
+      return Object.freeze({ schema_version: 1, platform: 'linux', boot_sha256: sha256(`chati-linux-boot-v1\0${bootId}`) });
+    }
+  } catch { /* unavailable on this host */ }
+  return null;
+}
+
+export function isHostBootMarker(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every((key) => MARKER_KEYS.includes(key))
+    && value.schema_version === 1
+    && (value.platform === 'darwin' || value.platform === 'linux')
+    && typeof value.boot_sha256 === 'string' && /^[a-f0-9]{64}$/.test(value.boot_sha256);
+}
+
+/** True only when both markers are well formed, describe the same platform,
+ * and name different boots. Malformed or missing markers never prove a change. */
+export function hostBootMarkerChanged(previous, current) {
+  if (!isHostBootMarker(previous) || !isHostBootMarker(current)) return false;
+  if (previous.platform !== current.platform) return false;
+  return previous.boot_sha256 !== current.boot_sha256;
+}

package/node_modules/@chati/core/src/index.js

@@ -1,5 +1,23 @@
 import { createHash } from 'node:crypto';
 
+export { nativeExecutionGatePath } from './execution-gate.js';
+export { assertDarwinHostBootIdentity, captureDarwinHostBootIdentity, compareDarwinHostBootIdentity, observeDarwinPreviousBoot } from './darwin-host-boot.js';
+export { assertLinuxHostBootIdentity, captureLinuxHostBootIdentity, compareLinuxHostBootIdentity } from './linux-host-boot.js';
+export { captureHostBootMarker, hostBootMarkerChanged, isHostBootMarker } from './host-boot-marker.js';
+export { darwinSupervisorNonce, parseDarwinReadyMessage, parseDarwinCompletionMessage } from './darwin-process.js';
+export { createDarwinSupervisorChannels } from './darwin-supervisor-channels.js';
+export { createDarwinBrowserProofChannels } from './darwin-browser-proof.js';
+export { PROVIDER_CONTROL_PLANE_DIRECTORIES, createDarwinTerminalLaunchBinding, assertDarwinTerminalLaunch, assertDarwinTerminalCompletion } from './darwin-terminal-receipt.js';
+export { createLinuxProcessInfoPipe, readLinuxProcessInfoPipe, captureLinuxNamespaceIdentity,
+  assertLinuxNamespaceIdentity, observeLinuxNamespace } from './linux-process.js';
+export {
+  assertDescriptorStorageSupported, directoryPathSync, duplicateDirectorySync,
+  createProcessInfoPipeSync, readProcessInfoPipeSync,
+  createDarwinBrowserListenerSync, inspectDarwinBrowserListenerSync,
+  linkAtSync, lstatAtSync, mkdirAtSync, openAtSync, readDirectorySync, readlinkAtSync, renameAtSync, renameNoReplaceAtSync, symlinkAtSync, unlinkAtSync,
+  tryExclusiveFileLockSync, trySharedFileLockSync,
+} from './descriptor-fs.js';
+
 export class ContractError extends Error {
   constructor(code, message, details = {}) {
     super(message);

package/node_modules/@chati/core/src/linux-host-boot.js

@@ -0,0 +1,218 @@
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import {
+  closeSync, constants, fstatSync, lstatSync, openSync, readlinkSync,
+  readSync, realpathSync, statfsSync,
+} from 'node:fs';
+
+const SUDO = '/usr/bin/sudo';
+const CAT = '/usr/bin/cat';
+const HOST = '/sys/devices/virtual/dmi/id/product_uuid';
+const BOOT = '/proc/sys/kernel/random/boot_id';
+const METHOD = 'sysfs-dmi-via-fixed-sudo-cat-v1';
+const SYSFS = 0x62656572n;
+const PROCFS = 0x9fa0n;
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+const META = ['dev', 'ino', 'mode', 'uid', 'gid'];
+const FILE_META = [...META, 'nlink', 'size', 'mtimeNs', 'ctimeNs'];
+const DIRECTORIES = ['/', '/usr', '/usr/bin', '/sys', '/sys/devices', '/sys/devices/virtual',
+  '/sys/devices/virtual/dmi', '/sys/devices/virtual/dmi/id', '/proc', '/proc/sys',
+  '/proc/sys/kernel', '/proc/sys/kernel/random'];
+const IDENTITY_KEYS = ['schema_version', 'platform', 'method', 'host_id_sha256', 'boot_id_sha256', 'provenance'];
+const PROVENANCE_KEYS = ['sudo_sha256', 'cat_sha256', 'pid_namespace_inode', 'mount_namespace_inode', 'user_namespace_inode'];
+
+function fail(code, message, stage) {
+  throw Object.assign(new Error(message), { code, ...(stage ? { stage } : {}) });
+}
+function check(condition) { if (!condition) throw new Error('Linux host observation check failed'); }
+function same(a, b, fields) { return fields.every(key => a[key] === b[key]); }
+function filesystem(path) {
+  if (path === '/sys' || path.startsWith('/sys/')) return SYSFS;
+  if (path === '/proc' || path.startsWith('/proc/')) return PROCFS;
+  return null;
+}
+function metadata(path, directory = false) {
+  check(realpathSync(path) === path);
+  const stat = lstatSync(path, { bigint: true });
+  check(!stat.isSymbolicLink() && (directory ? stat.isDirectory() : stat.isFile()));
+  check(stat.uid === 0n && stat.gid === 0n && (stat.mode & 0o022n) === 0n);
+  if (!directory) check(stat.nlink === 1n);
+  const type = filesystem(path);
+  if (type !== null) check(statfsSync(path, { bigint: true }).type === type);
+  return stat;
+}
+function pin(path, pins, { directory = false, readable = true } = {}) {
+  const stat = metadata(path, directory);
+  const record = { path, stat, directory, fd: null };
+  pins.push(record);
+  if (readable) {
+    record.fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+      | (directory ? constants.O_DIRECTORY : 0));
+    check(same(stat, fstatSync(record.fd, { bigint: true }), directory ? META : FILE_META));
+    const type = filesystem(path);
+    if (type !== null) check(statfsSync(`/proc/self/fd/${record.fd}`, { bigint: true }).type === type);
+  }
+  return record;
+}
+function assertPinned(record) {
+  const fields = record.directory ? META : FILE_META;
+  check(same(record.stat, metadata(record.path, record.directory), fields));
+  if (record.fd !== null) {
+    check(same(record.stat, fstatSync(record.fd, { bigint: true }), fields));
+    const type = filesystem(record.path);
+    if (type !== null) check(statfsSync(`/proc/self/fd/${record.fd}`, { bigint: true }).type === type);
+  }
+}
+function nativeImageHash(record) {
+  const { fd, stat, path } = record;
+  check(stat.size >= 20n && stat.size <= 16n * 1024n * 1024n);
+  check((stat.mode & 0o111n) !== 0n);
+  // Existing OS sudo may be setuid. Never copy it, run a package helper as
+  // root, or accept a setgid/sticky utility or a privileged cat wrapper.
+  check((stat.mode & (path === SUDO ? 0o3000n : 0o7000n)) === 0n);
+  const hash = createHash('sha256');
+  const buffer = Buffer.alloc(64 * 1024);
+  const header = Buffer.alloc(20);
+  let position = 0;
+  while (position < Number(stat.size)) {
+    const count = readSync(fd, buffer, 0, Math.min(buffer.length, Number(stat.size) - position), position);
+    check(count > 0);
+    if (position < header.length) buffer.copy(header, position, 0, Math.min(count, header.length - position));
+    hash.update(buffer.subarray(0, count));
+    position += count;
+  }
+  check(header.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46]))
+    && header[4] === 2 && header[5] === 1 && header[6] === 1
+    && [2, 3].includes(header.readUInt16LE(16))
+    && header.readUInt16LE(18) === (process.arch === 'x64' ? 62 : 183));
+  assertPinned(record);
+  return hash.digest('hex');
+}
+function normalizedUuid(bytes) {
+  check(Buffer.isBuffer(bytes) && (bytes.length === 36 || (bytes.length === 37 && bytes[36] === 10)));
+  check(bytes.every(byte => byte < 128));
+  const value = bytes.subarray(0, 36).toString('utf8').toLowerCase();
+  check(UUID.test(value) && value !== '00000000-0000-0000-0000-000000000000'
+    && value !== 'ffffffff-ffff-ffff-ffff-ffffffffffff');
+  return value;
+}
+function bootHash(record) {
+  const bytes = Buffer.alloc(129);
+  try {
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync(record.fd, bytes, length, bytes.length - length, length);
+      if (!count) break;
+      length += count;
+    }
+    const uuid = normalizedUuid(bytes.subarray(0, length));
+    assertPinned(record);
+    return createHash('sha256').update(`chati-linux-boot-v1\0${uuid}`).digest('hex');
+  } finally { bytes.fill(0); }
+}
+function namespaceContext() {
+  return Object.fromEntries([['pid', 'pid'], ['mnt', 'mount'], ['user', 'user']].map(([tag, name]) => {
+    const value = readlinkSync(`/proc/self/ns/${tag}`);
+    const match = new RegExp(`^${tag}:\\[([1-9][0-9]{0,19})\\]$`).exec(value);
+    check(match && BigInt(match[1]) <= 0xffffffffffffffffn);
+    return [`${name}_namespace_inode`, match[1]];
+  }));
+}
+function closedValues(value, keys) {
+  check(value && typeof value === 'object' && !Array.isArray(value)
+    && [Object.prototype, null].includes(Object.getPrototypeOf(value)));
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  check(Reflect.ownKeys(descriptors).length === keys.length
+    && keys.every(key => Object.hasOwn(descriptors, key) && Object.hasOwn(descriptors[key], 'value')));
+  return Object.fromEntries(keys.map(key => [key, descriptors[key].value]));
+}
+function identityValues(value) {
+  try {
+    const identity = closedValues(value, IDENTITY_KEYS);
+    const provenance = closedValues(identity.provenance, PROVENANCE_KEYS);
+    check(identity.schema_version === 1 && identity.platform === 'linux' && identity.method === METHOD);
+    for (const hash of [identity.host_id_sha256, identity.boot_id_sha256, provenance.sudo_sha256, provenance.cat_sha256]) {
+      check(typeof hash === 'string' && SHA256.test(hash));
+    }
+    for (const key of PROVENANCE_KEYS.slice(2)) {
+      check(typeof provenance[key] === 'string' && /^[1-9][0-9]{0,19}$/.test(provenance[key])
+        && BigInt(provenance[key]) <= 0xffffffffffffffffn);
+    }
+    return identity;
+  } catch {
+    return fail('INVALID_LINUX_HOST_BOOT_IDENTITY', 'A closed Linux host/boot observation is required');
+  }
+}
+
+/** Shape validation only. Neither hashes nor namespace inodes authenticate a
+ * host, rule out VM cloning, prove initial namespaces, or authorize recovery. */
+export function assertLinuxHostBootIdentity(identity) {
+  identityValues(identity);
+  return true;
+}
+
+/** Fixed existing OS privilege, not a privileged package helper. Never invoke
+ * from provider code or accept caller-supplied paths, observations or options.
+ * Success is identity metadata only, not a completion/quiescence receipt.
+ * A future barrier must separately authenticate and fence its execution domain. */
+export function captureLinuxHostBootIdentity() {
+  const pins = [];
+  let stage = 'preflight';
+  let output;
+  let identity;
+  try {
+    check(arguments.length === 0 && process.platform === 'linux' && ['x64', 'arm64'].includes(process.arch)
+      && typeof process.geteuid === 'function' && process.geteuid() !== 0);
+    for (const path of DIRECTORIES) pin(path, pins, { directory: true });
+    const sudo = pin(SUDO, pins), cat = pin(CAT, pins);
+    const sudoHash = nativeImageHash(sudo), catHash = nativeImageHash(cat);
+    const host = pin(HOST, pins, { readable: false });
+    const boot = pin(BOOT, pins);
+    check((host.stat.mode & 0o222n) === 0n && (boot.stat.mode & 0o222n) === 0n);
+    const context = namespaceContext();
+    const before = bootHash(boot);
+    stage = 'fixed-read';
+    const result = spawnSync(SUDO, ['-n', '--', CAT, HOST], {
+      shell: false, cwd: '/', env: { PATH: '/usr/bin:/bin', LANG: 'C', LC_ALL: 'C' },
+      stdio: ['ignore', 'pipe', 'ignore'], encoding: null,
+      timeout: 2000, killSignal: 'SIGKILL', maxBuffer: 128,
+    });
+    output = result?.stdout;
+    check(result && result.status === 0 && result.signal === null && !result.error);
+    const hostUuid = normalizedUuid(output);
+    const hostHash = createHash('sha256').update(`chati-linux-host-v1\0${hostUuid}`).digest('hex');
+    stage = 'recheck';
+    check(before === bootHash(boot));
+    const after = namespaceContext();
+    check(Object.keys(context).every(key => context[key] === after[key]));
+    for (const record of pins) assertPinned(record);
+    check(nativeImageHash(sudo) === sudoHash && nativeImageHash(cat) === catHash);
+    identity = Object.freeze({ schema_version: 1, platform: 'linux', method: METHOD,
+      host_id_sha256: hostHash, boot_id_sha256: before,
+      provenance: Object.freeze({ sudo_sha256: sudoHash, cat_sha256: catHash, ...context }) });
+    assertLinuxHostBootIdentity(identity);
+  } catch {
+    // Child-process errors can retain stdout/stderr. Never expose the caught
+    // error, cause, result or raw UUID in a diagnostic or authority record.
+    identity = null;
+  } finally {
+    if (Buffer.isBuffer(output)) output.fill(0);
+    for (const record of pins.reverse()) if (record.fd !== null) {
+      try { closeSync(record.fd); }
+      catch { identity = null; stage = 'cleanup'; }
+    }
+  }
+  if (!identity) fail('LINUX_HOST_BOOT_UNAVAILABLE', 'Fixed native Linux host/boot observation is unavailable', stage);
+  return identity;
+}
+
+/** Pure comparison of already observed/authenticated inputs. In particular,
+ * this does not compare an invented launch epoch for a historical execution. */
+export function compareLinuxHostBootIdentity(previous, current) {
+  const before = identityValues(previous), after = identityValues(current);
+  if (before.host_id_sha256 !== after.host_id_sha256) {
+    fail('LINUX_HOST_IDENTITY_MISMATCH', 'Host/boot observations belong to different machines');
+  }
+  return before.boot_id_sha256 === after.boot_id_sha256 ? 'same-boot' : 'previous-boot';
+}

package/node_modules/@chati/core/src/linux-process.js

@@ -0,0 +1,133 @@
+import { closeSync, constants, openSync, readFileSync, readlinkSync, readSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { hostname } from 'node:os';
+
+const require = createRequire(import.meta.url);
+let binding;
+function fail(code, message, cause) { throw Object.assign(new Error(message), { code, ...(cause ? { cause } : {}) }); }
+function native() {
+  if (process.platform !== 'linux') fail('UNSUPPORTED_PROCESS_IDENTITY_PLATFORM', 'PID-namespace identity requires Linux');
+  try { binding ??= require(`../native/prebuilds/linux-${process.arch}/descriptor-fs.node`); }
+  catch (error) { fail('NATIVE_PROCESS_CONTROL_UNAVAILABLE', 'matching packaged native process control is required', error); }
+  if (!['processPipe', 'readProcessPipe', 'openPidfd', 'waitPidfd', 'killPidfd'].every((key) => typeof binding[key] === 'function')) {
+    fail('NATIVE_PROCESS_CONTROL_UNAVAILABLE', 'the packaged native boundary lacks PID identity support');
+  }
+  return binding;
+}
+
+function integer(value, minimum = 0) {
+  if (!Number.isInteger(value) || value < minimum || value > 0x7fffffff) fail('INVALID_PROCESS_IDENTITY', 'invalid process descriptor or PID');
+  return value;
+}
+function bootId() {
+  const value = readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+  if (!/^[a-f0-9-]{36}$/.test(value)) fail('PROCESS_IDENTITY_UNVERIFIABLE', 'kernel boot identity is unavailable');
+  return value;
+}
+function namespaceInode(path) {
+  const match = /^pid:\[(\d+)\]$/.exec(readlinkSync(path));
+  if (!match) fail('PROCESS_IDENTITY_UNVERIFIABLE', 'kernel PID namespace identity is unavailable');
+  return match[1];
+}
+function boundedProcText(directory, name) {
+  const fd = openSync(`/proc/self/fd/${directory}/${name}`, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const buffer = Buffer.alloc(16385);
+    const count = readSync(fd, buffer, 0, buffer.length, 0);
+    if (count === buffer.length) fail('PROCESS_IDENTITY_UNVERIFIABLE', 'kernel process identity exceeds its bound');
+    return buffer.subarray(0, count).toString('utf8');
+  } finally { closeSync(fd); }
+}
+function snapshot(pid) {
+  const directory = openSync(`/proc/${integer(pid, 2)}`, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    const stat = boundedProcText(directory, 'stat');
+    const fields = stat.slice(stat.lastIndexOf(') ') + 2).trim().split(/\s+/);
+    if (!stat.startsWith(`${pid} (`) || fields.length < 20 || !/^\d+$/.test(fields[19])) {
+      fail('PROCESS_IDENTITY_UNVERIFIABLE', 'kernel process start identity is malformed');
+    }
+    const status = boundedProcText(directory, 'status');
+    const namespacePids = /^NSpid:\s+([\d\t ]+)$/m.exec(status)?.[1].trim().split(/\s+/).map(Number);
+    if (!namespacePids?.length || namespacePids[0] !== pid) fail('PROCESS_IDENTITY_UNVERIFIABLE', 'kernel namespace PID is unavailable');
+    return { start_time_ticks: fields[19], parent_pid: Number(fields[1]), namespace_pid: namespacePids.at(-1),
+      pid_namespace_inode: namespaceInode(`/proc/self/fd/${directory}/ns/pid`) };
+  } finally { closeSync(directory); }
+}
+
+export function createLinuxProcessInfoPipe() { return Object.freeze(native().processPipe()); }
+export function readLinuxProcessInfoPipe(fd, timeoutMs = 5000) {
+  integer(fd); integer(timeoutMs);
+  return native().readProcessPipe(fd, timeoutMs);
+}
+
+/** Must be called on the private information FD of the pinned bubblewrap. */
+export function captureLinuxNamespaceIdentity(info, monitorPid) {
+  const api = native();
+  integer(monitorPid, 2);
+  const pid = integer(info?.['child-pid'], 2);
+  if (!Number.isSafeInteger(info['pid-namespace']) || info['pid-namespace'] <= 0) {
+    fail('PROCESS_IDENTITY_UNVERIFIABLE', 'trusted isolator did not report a PID namespace');
+  }
+  const fd = api.openPidfd(pid);
+  try {
+    if (api.waitPidfd(fd, 0)) fail('PROCESS_NAMESPACE_ALREADY_EXITED', 'namespace exited before dispatch');
+    const observed = snapshot(pid);
+    if (observed.parent_pid !== monitorPid || observed.namespace_pid !== 1
+      || observed.pid_namespace_inode !== String(info['pid-namespace'])) {
+      fail('PROCESS_IDENTITY_UNVERIFIABLE', 'reported namespace does not match its actual kernel identity');
+    }
+    const observer = namespaceInode('/proc/self/ns/pid');
+    if (observer === observed.pid_namespace_inode) fail('PROCESS_IDENTITY_UNVERIFIABLE', 'provider must be in a distinct PID namespace');
+    if (api.waitPidfd(fd, 0)) fail('PROCESS_NAMESPACE_ALREADY_EXITED', 'namespace exited while its identity was captured');
+    return Object.freeze({ schema_version: 1, platform: 'linux', hostname: hostname(), boot_id: bootId(),
+      observer_pid_namespace_inode: observer, pid, namespace_pid: 1,
+      start_time_ticks: observed.start_time_ticks, pid_namespace_inode: observed.pid_namespace_inode });
+  } finally { closeSync(fd); }
+}
+
+export function assertLinuxNamespaceIdentity(identity) {
+  if (!identity || identity.schema_version !== 1 || identity.platform !== 'linux' || identity.namespace_pid !== 1
+    || typeof identity.hostname !== 'string' || !identity.hostname
+    || !/^[a-f0-9-]{36}$/.test(identity.boot_id ?? '')
+    || !['start_time_ticks', 'pid_namespace_inode', 'observer_pid_namespace_inode'].every((key) =>
+      typeof identity[key] === 'string' && /^\d+$/.test(identity[key]))
+    || identity.pid_namespace_inode === identity.observer_pid_namespace_inode) {
+    fail('INVALID_PROCESS_IDENTITY', 'an exact namespace-init identity is required');
+  }
+  integer(identity.pid, 2);
+}
+
+/** Verify persisted identity before any signal. No numeric-PID kill fallback. */
+export function observeLinuxNamespace(identity, { terminate = false, timeoutMs = 0 } = {}) {
+  assertLinuxNamespaceIdentity(identity);
+  const api = native();
+  integer(timeoutMs);
+  if (timeoutMs > 30000 || typeof terminate !== 'boolean') fail('INVALID_PROCESS_IDENTITY', 'invalid namespace observation options');
+  if (identity.hostname !== hostname()) fail('PROCESS_IDENTITY_REMOTE_HOST', 'namespace is on a different host');
+  if (identity.boot_id !== bootId()) return Object.freeze({ status: 'exited', reason: 'previous-boot', signal_sent: false });
+  if (identity.observer_pid_namespace_inode !== namespaceInode('/proc/self/ns/pid')) {
+    fail('PROCESS_IDENTITY_UNVERIFIABLE', 'observer PID namespace differs from the dispatch observer');
+  }
+  let fd;
+  try { fd = api.openPidfd(identity.pid); }
+  catch (error) {
+    if (error.code === 'ESRCH') return Object.freeze({ status: 'exited', reason: 'pid-absent', signal_sent: false });
+    throw error;
+  }
+  try {
+    if (api.waitPidfd(fd, 0)) return Object.freeze({ status: 'exited', reason: 'pidfd-exited', signal_sent: false });
+    let current;
+    try { current = snapshot(identity.pid); }
+    catch (error) {
+      if (api.waitPidfd(fd, 0)) return Object.freeze({ status: 'exited', reason: 'pidfd-exited', signal_sent: false });
+      fail('PROCESS_IDENTITY_UNVERIFIABLE', 'could not verify the live namespace identity', error);
+    }
+    if (current.start_time_ticks !== identity.start_time_ticks || current.pid_namespace_inode !== identity.pid_namespace_inode
+      || current.namespace_pid !== identity.namespace_pid) {
+      return Object.freeze({ status: 'exited', reason: 'identity-replaced', signal_sent: false });
+    }
+    const sent = terminate ? api.killPidfd(fd) : false;
+    const exited = api.waitPidfd(fd, timeoutMs);
+    return Object.freeze({ status: exited ? 'exited' : 'running', reason: exited ? 'pidfd-exited' : 'same-identity', signal_sent: sent });
+  } finally { closeSync(fd); }
+}