@amalgm/shell 0.1.164-preview.34187698689 → 0.1.164-preview.34192807991

package/PURPOSE.md

@@ -6,6 +6,9 @@ while its host can execute, recover without opening a UI, contain a failing
 workload, and leave the machine's resources available for useful work. Shell
 owns composition, process boot, and native host effects; Core and the product
 SDKs own the decisions those effects execute.
+At the completed brick/mortar boundary, compatible bricks advance through independently selected artifacts while Shell
+remains the mortar; publishing a brick must not require publishing unchanged
+Shell code.
 
 ## Operating axioms
 
@@ -15,6 +18,9 @@ defines the terms and examinations; the [September 2026 audit](docs/operating-au
 records implementation gaps and historical evidence.
 The [release environments plan](docs/release-environments-plan.md) records the
 agreed CI/CD and update evolution; its target behavior is not yet delivered.
+The owner permits temporary bundled Shell releases for brick changes during
+boundary cleanup. Independent brick adoption remains the target, and Engine
+migration is out of scope because no existing Engine users need it.
 
 - **O1 — Lifetime follows installation intent.** One installation owner keeps
   the enabled runtime available independently of its launching UI or terminal
@@ -66,12 +72,12 @@ native examinations before either becomes a managed public candidate. Public
 metadata records the exact internal archive it was derived from; no wrapper,
 copied Engine implementation or second dependency graph supplies runtime behavior.
 
-Consumer assembly reads dependencies from each declared package manifest and
-selects only registry candidates from the same managed branch. It changes exact
-pins and their locks in one reproducible composition change; the consumer's
-complete checks gate merging that exact tree against its unchanged base. Reconciliation keeps one
-pending change per branch, preserves human edits, and never republishes an
-unchanged consumer merely because a notification or check was repeated.
+At the target boundary, release assembly selects exact registry artifacts from the same managed branch
+into a signed installation recipe. Compatible brick changes reuse the existing
+Shell artifact without a Shell dependency-update PR or lockfile edit. A product
+owns changes to libraries embedded in its own artifact. Reconciliation preserves
+human edits, coalesces candidates, and never republishes unchanged components
+because a notification or check was repeated.
 
 1. **The shell implements host effects; SDKs own domain decisions.** Shell
    assembles published capabilities, implements their native effect ports,
@@ -157,17 +163,25 @@ changes it. Examinations inject their credential store explicitly.
    decisions receive effects explicitly and never discover ambient process
    state or disk on their own.
 
-5. **Bricks never update themselves; the shell updates.** Every direct `@amalgm/*`
-   dependency is pinned to an exact version — no ranges. Publishing a brick
-   changes nothing on any user machine until the shell bumps its pin and ships
-   a new release through its lane's signed runtime authority. Registry tags
-   locate published artifacts; fresh TUF metadata selects installed adoption.
-   One version number, one atomic update, one combination that was
-   actually tested together — never a per-brick drift of versions in the wild.
-   The shrinkwrap fixes the transitive graph as well; direct pins do not
-   imply that every consumer resolves the same Core version. Release proof
-   checks those actual resolutions and their public contracts, and upgrades
-   affected consumers deliberately instead of forcing an untested override.
+5. **Bricks release independently; one installation owner adopts the graph.**
+   Shell carries allowed component identities and supported host contracts,
+   without bundling brick implementations or pinning their runtime versions.
+   A separately signed recipe selects exact compatible artifacts and dependency
+   graphs; compatible brick changes reuse unchanged Shell and UI artifacts.
+   Registry tags locate candidates; fresh TUF metadata authorizes adoption.
+   Bricks never update themselves, and one coherent tested graph governs each
+   activation and its recovery. Artifact identity is separate from process
+   lifetime: a changed in-process implementation requires draining its actual
+   process cohort even when Shell's bytes stay unchanged. Release proof checks
+   actual dependency resolutions and public contracts; it never forces all
+   consumers onto one untested Core version.
+
+   Accepted transition: current Shell packages still bundle a pinned SDK graph,
+   and the current updater stages one Shell archive. A brick change may therefore
+   temporarily require a checked Shell release while the boundary is completed;
+   this does not block initial delivery. The
+   [release contract](docs/release-environments-plan.md#current-release-contract--2026-09-08)
+   defines the required transition and distinguishes it from existing evidence.
 
 The installed runtime follows the [update axioms](src/updates/README.md).
 Each public managed package declares its controller, process and state-format
@@ -997,7 +1011,7 @@ Local profiles retain their selected sources and do not follow managed targets.
 
 65. **A Shell release is tested as the artifact users install.** The release
     gate packs Shell, installs that tarball with the exact public Amalgm
-    dependency versions declared by its manifest, and exercises authorization
+    artifacts selected by the installation recipe, and exercises authorization
     through Chat using package exports only. Sibling repositories and source
     paths are never an integration-test dependency.
 

package/examinations/network-view.mjs

@@ -18,6 +18,32 @@ const run = (file, args, options = {}) => execFileSync(file, args, { encoding: '
 const sudo = (file, args) => run('sudo', ['-n', file, ...args]);
 const powershell = (source, env = {}) => run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', source], { env: { ...process.env, ...env } });
 
+async function waitForNativeResolution(hostsFile, expectedHosts) {
+  const deadline = Date.now() + 15_000;
+  let observed;
+  do {
+    try {
+      // A fresh, bounded process uses the OS resolver used by installed clients.
+      observed = JSON.parse(run(process.execPath, ['--input-type=module', '-e',
+        "import { lookup } from 'node:dns/promises'; process.stdout.write(JSON.stringify(await lookup(process.argv[1], { all: true })));",
+        canonicalHost], { timeout: Math.max(1, deadline - Date.now()) }));
+      if (observed.length > 0 && observed.every(value => value.address === '127.0.0.1')) return;
+    } catch (error) { observed = error.message; }
+    await new Promise(resolve => setTimeout(resolve, 100));
+  } while (Date.now() < deadline);
+  const bytes = await fs.readFile(hostsFile);
+  const stat = await fs.stat(hostsFile);
+  const hosts = { path: await fs.realpath(hostsFile), mode: (stat.mode & 0o777).toString(8),
+    uid: stat.uid, gid: stat.gid, exact: bytes.equals(expectedHosts),
+    entries: bytes.toString('utf8').split(/\r?\n/).filter(line => line.includes(canonicalHost)) };
+  let native;
+  if (process.platform === 'darwin') {
+    try { native = run('dscacheutil', ['-q', 'host', '-a', 'name', canonicalHost]); }
+    catch (error) { native = error.message; }
+  }
+  throw new Error(`The native resolver did not adopt the examination host: ${JSON.stringify({ observed, hosts, native })}`);
+}
+
 export async function startNetworkView({ temporary, immutable, previous = {}, candidate, artifacts = [], events, hint = {}, serviceEnvironment = false }) {
   assert.equal(process.env.CI, 'true');
   assert.equal(process.env.GITHUB_ACTIONS, 'true', 'Never replace DNS or TLS trust on a developer account');
@@ -29,7 +55,8 @@ export async function startNetworkView({ temporary, immutable, previous = {}, ca
   const ca = path.join(directory, 'ca.crt');
   const key = path.join(directory, 'server.key');
   const certificate = path.join(directory, 'server.crt');
-  const name = `Amalgm disposable native examination ${crypto.randomUUID()}`;
+  const name = `Amalgm native examination ${crypto.randomUUID()}`;
+  assert.ok(Buffer.byteLength(name, 'utf8') <= 64, 'A disposable authority must fit the X.509 common-name limit');
   const extension = path.join(directory, 'server.ext');
   await fs.writeFile(extension, `subjectAltName=DNS:${canonicalHost}\nextendedKeyUsage=serverAuth\n`);
   run('openssl', ['req', '-x509', '-newkey', 'rsa:2048', '-nodes', '-days', '1', '-subj', `/CN=${name}`, '-keyout', path.join(directory, 'ca.key'), '-out', ca], { stdio: 'pipe' });
@@ -39,9 +66,7 @@ export async function startNetworkView({ temporary, immutable, previous = {}, ca
   await fs.rm(path.join(directory, 'ca.key'));
   const hostsFile = process.platform === 'win32' ? path.join(process.env.SystemRoot, 'System32/drivers/etc/hosts') : '/etc/hosts';
   const originalHosts = await fs.readFile(hostsFile);
-  const hosts = path.join(directory, 'hosts');
-  await fs.writeFile(hosts, Buffer.concat([originalHosts, Buffer.from(`\n127.0.0.1 ${canonicalHost}\n`)]));
-  const original = path.join(directory, 'hosts.original'); await fs.writeFile(original, originalHosts);
+  const examinationHosts = Buffer.concat([originalHosts, Buffer.from(`\n127.0.0.1 ${canonicalHost}\n`)]);
   const linuxCa = `/usr/local/share/ca-certificates/amalgm-examination-${crypto.randomUUID()}.crt`;
   const nss = path.join(process.env.HOME || process.env.USERPROFILE, '.pki/nssdb');
   const fingerprint = run('openssl', ['x509', '-in', ca, '-noout', '-fingerprint', '-sha1']).split('=')[1].trim().replace(/:/g, '');
@@ -52,13 +77,27 @@ export async function startNetworkView({ temporary, immutable, previous = {}, ca
     else if (process.platform === 'linux') run('systemctl', ['--user', value === null ? 'unset-environment' : 'set-environment', value === null ? 'NODE_EXTRA_CA_CERTS' : `NODE_EXTRA_CA_CERTS=${value}`]);
     else powershell("[Environment]::SetEnvironmentVariable('NODE_EXTRA_CA_CERTS', $env:AMALGM_EXAMINATION_CA, 'User')", { AMALGM_EXAMINATION_CA: value ?? '' });
   };
-  const copyHosts = async source => {
-    if (process.platform === 'win32') await fs.copyFile(source, hostsFile);
-    else sudo('cp', [source, hostsFile]);
+  const writeHosts = bytes => {
+    // Preserve the existing readable inode and metadata for native observers.
+    // File-copy tools can temporarily make the destination root-only, causing
+    // the resolver to miss the data change while it cannot reopen the file.
+    run(process.platform === 'win32' ? process.execPath : 'sudo', [
+      ...(process.platform === 'win32' ? [] : ['-n', process.execPath]),
+      '--input-type=module', '-e', `
+        import fs from 'node:fs';
+        const bytes = fs.readFileSync(0);
+        const fd = fs.openSync(process.argv[1], 'r+');
+        try { fs.writeFileSync(fd, bytes); fs.ftruncateSync(fd, bytes.length); fs.fsyncSync(fd); }
+        finally { fs.closeSync(fd); }
+      `, hostsFile,
+    ], { input: bytes });
   };
   const close = async () => {
     const errors = [];
-    try {
+    const attempt = async effect => {
+      try { await effect(); } catch (error) { errors.push(error); }
+    };
+    await attempt(async () => {
       if (child && child.exitCode === null) {
         child.stdin.end();
         await new Promise((resolve, reject) => {
@@ -66,19 +105,28 @@ export async function startNetworkView({ temporary, immutable, previous = {}, ca
           child.once('exit', () => { clearTimeout(timeout); resolve(); });
         });
       }
-    } catch (error) { errors.push(error); }
-    if (changedHosts) await copyHosts(original);
-    if (changedServiceEnvironment) serviceCa(priorServiceCa);
+    });
+    if (changedHosts) await attempt(() => writeHosts(originalHosts));
+    if (changedServiceEnvironment) await attempt(() => serviceCa(priorServiceCa));
     if (process.platform === 'darwin') {
-      if (trusted) sudo('security', ['remove-trusted-cert', '-d', ca]);
-      sudo('dscacheutil', ['-flushcache']);
-      sudo('killall', ['-HUP', 'mDNSResponder']);
+      if (trusted) {
+        // Removing the last admin record can request GUI authorization on macOS.
+        // Explicitly revoke this CA, then delete its owned certificate; the
+        // negative trust record lasts only until this disposable CI VM ends.
+        await attempt(() => sudo('security', ['add-trusted-cert', '-d', '-r', 'deny', '-k', '/Library/Keychains/System.keychain', ca]));
+        await attempt(() => sudo('security', ['delete-certificate', '-Z', fingerprint, '/Library/Keychains/System.keychain']));
+      }
+      await attempt(() => sudo('dscacheutil', ['-flushcache']));
+      await attempt(() => sudo('killall', ['-HUP', 'mDNSResponder']));
     } else if (process.platform === 'linux') {
-      if (nssTrusted) run('certutil', ['-D', '-d', `sql:${nss}`, '-n', name]);
-      if (trusted) { sudo('rm', ['-f', linuxCa]); sudo('update-ca-certificates', []); }
+      if (nssTrusted) await attempt(() => run('certutil', ['-D', '-d', `sql:${nss}`, '-n', name]));
+      if (trusted) {
+        await attempt(() => sudo('rm', ['-f', linuxCa]));
+        await attempt(() => sudo('update-ca-certificates', []));
+      }
     } else {
-      if (trusted) run('certutil.exe', ['-user', '-delstore', 'Root', fingerprint]);
-      run('ipconfig.exe', ['/flushdns']);
+      if (trusted) await attempt(() => run('certutil.exe', ['-delstore', 'Root', fingerprint]));
+      await attempt(() => run('ipconfig.exe', ['/flushdns']));
     }
     if (errors.length) throw new AggregateError(errors, 'Examination transport cleanup failed');
   };
@@ -93,15 +141,16 @@ export async function startNetworkView({ temporary, immutable, previous = {}, ca
       run('certutil', ['-A', '-d', `sql:${nss}`, '-n', name, '-t', 'C,,', '-i', ca]); nssTrusted = true;
     } else {
       powershell("if (-not ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) { throw 'Disposable Windows CI account must be an administrator' }");
-      run('certutil.exe', ['-user', '-addstore', 'Root', ca]); trusted = true;
+      run('certutil.exe', ['-addstore', '-f', 'Root', ca]); trusted = true;
     }
     if (serviceEnvironment) {
       if (process.platform === 'darwin') { try { priorServiceCa = run('launchctl', ['getenv', 'NODE_EXTRA_CA_CERTS']).trim() || null; } catch { /* unset */ } }
       else if (process.platform === 'linux') priorServiceCa = run('systemctl', ['--user', 'show-environment']).split('\n').find(line => line.startsWith('NODE_EXTRA_CA_CERTS='))?.slice('NODE_EXTRA_CA_CERTS='.length) ?? null;
-      else priorServiceCa = JSON.parse(powershell("ConvertTo-Json -Compress -InputObject ([Environment]::GetEnvironmentVariable('NODE_EXTRA_CA_CERTS', 'User'))"));
+      else priorServiceCa = JSON.parse(powershell("ConvertTo-Json -Compress -InputObject @{ value = [Environment]::GetEnvironmentVariable('NODE_EXTRA_CA_CERTS', 'User') }")).value;
       serviceCa(ca); changedServiceEnvironment = true;
     }
-    await copyHosts(hosts); changedHosts = true;
+    changedHosts = true; writeHosts(examinationHosts);
+    assert.deepEqual(await fs.readFile(hostsFile), examinationHosts, 'The OS hosts file must contain the exact examination view');
     if (process.platform === 'darwin') { sudo('dscacheutil', ['-flushcache']); sudo('killall', ['-HUP', 'mDNSResponder']); }
     else if (process.platform === 'win32') run('ipconfig.exe', ['/flushdns']);
     const config = path.join(directory, 'config.json');
@@ -128,8 +177,13 @@ export async function startNetworkView({ temporary, immutable, previous = {}, ca
       });
     };
     await command({ operation: 'status' });
+    await waitForNativeResolution(hostsFile, examinationHosts);
     return { ca, close, command };
-  } catch (error) { await close(); throw error; }
+  } catch (error) {
+    try { await close(); }
+    catch (cleanup) { throw new AggregateError([error, cleanup], 'Examination transport initialization and cleanup failed'); }
+    throw error;
+  }
 }
 
 async function serve(configFile) {

package/examinations/network-view.native-test.mjs

@@ -0,0 +1,159 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import https from 'node:https';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile, execFileSync } from 'node:child_process';
+import { promisify } from 'node:util';
+import { canonicalHost, startNetworkView } from './network-view.mjs';
+
+const execute = promisify(execFile);
+const resource = value => ({ body: Buffer.from(value).toString('base64') });
+const run = (file, args) => execFileSync(file, args, { encoding: 'utf8', timeout: 15_000 });
+function serviceCa() {
+  if (process.platform === 'darwin') {
+    try { return run('launchctl', ['getenv', 'NODE_EXTRA_CA_CERTS']).trim() || null; }
+    catch { return null; }
+  }
+  if (process.platform === 'linux') return run('systemctl', ['--user', 'show-environment'])
+    .split('\n').find(line => line.startsWith('NODE_EXTRA_CA_CERTS='))?.slice('NODE_EXTRA_CA_CERTS='.length) ?? null;
+  return JSON.parse(run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+    "ConvertTo-Json -Compress -InputObject @{ value = [Environment]::GetEnvironmentVariable('NODE_EXTRA_CA_CERTS', 'User') }"])).value;
+}
+
+// Each request discovers the OS trust store anew. No supplied CA, DNS lookup,
+// disabled TLS validation or inherited Node options can substitute for it.
+async function nativeRequest(options) {
+  const env = { ...process.env };
+  for (const name of Object.keys(env)) {
+    if (/^(NODE_EXTRA_CA_CERTS|NODE_OPTIONS|NODE_TLS_REJECT_UNAUTHORIZED|SSL_CERT_FILE|SSL_CERT_DIR)$/i.test(name)) delete env[name];
+  }
+  const { stdout } = await execute(process.execPath, ['--use-system-ca', '--input-type=module', '-e', `
+    import https from 'node:https';
+    const result = await new Promise(resolve => {
+      const request = https.get({ ...JSON.parse(process.argv[1]), agent: false, signal: AbortSignal.timeout(10_000) }, response => {
+        const peer = { authorized: response.socket.authorized, address: response.socket.remoteAddress };
+        let body = '';
+        response.setEncoding('utf8');
+        response.on('data', data => { body += data; });
+        response.on('end', () => resolve({ status: response.statusCode, body, ...peer }));
+        response.on('error', error => resolve({ error: error.code, message: error.message }));
+      });
+      request.on('error', error => resolve({ error: error.code, message: error.message }));
+    });
+    process.stdout.write(JSON.stringify(result));
+  `, JSON.stringify(options)], { env, timeout: 15_000, maxBuffer: 64 * 1024 });
+  return JSON.parse(stdout);
+}
+
+test('disposable native transport owns DNS, TLS trust, selected views and cleanup', {
+  skip: process.env.AMALGM_TEST_NATIVE_NETWORK !== '1', timeout: 180_000,
+}, async () => {
+  assert.equal(process.env.CI, 'true');
+  assert.equal(process.env.GITHUB_ACTIONS, 'true', 'Native transport examination requires a disposable GitHub runner');
+  const hostsFile = process.platform === 'win32' ? path.join(process.env.SystemRoot, 'System32/drivers/etc/hosts') : '/etc/hosts';
+  const originalHosts = await fs.readFile(hostsFile);
+  const originalServiceCa = serviceCa();
+  const originalProcessCa = process.env.NODE_EXTRA_CA_CERTS;
+  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), 'amalgm-network-preflight-'));
+  const scope = '/trust/native-preflight';
+  const immutablePath = `${scope}/immutable`;
+  const selectedPath = `${scope}/selected`;
+  const events = `${scope}/events`;
+  let network; let leafServer; let streamRequest;
+  const failures = [];
+  const request = pathname => nativeRequest({ hostname: canonicalHost, path: pathname });
+  const expect = async (pathname, status, body) => {
+    assert.deepEqual(await request(pathname), { status, body, authorized: true, address: '127.0.0.1' });
+  };
+  try {
+    network = await startNetworkView({ temporary, events, serviceEnvironment: true,
+      immutable: { [immutablePath]: resource('immutable\n') },
+      previous: { [selectedPath]: resource('previous\n') },
+      candidate: { [selectedPath]: resource('candidate\n') },
+    });
+    assert.equal(serviceCa(), network.ca);
+    await expect(immutablePath, 200, 'immutable\n');
+    await expect(selectedPath, 200, 'previous\n');
+    await network.command({ operation: 'publish' });
+    await expect(selectedPath, 200, 'candidate\n');
+    await expect(immutablePath, 200, 'immutable\n');
+    await network.command({ operation: 'unavailable' });
+    await expect(selectedPath, 404, '');
+    await expect(events, 503, '');
+    await expect(immutablePath, 200, 'immutable\n');
+    await network.command({ operation: 'reset' });
+    await expect(selectedPath, 200, 'previous\n');
+
+    // Supply the original CA with the actual leaf so cleanup must revoke trust
+    // even when the peer supplies its full chain after OS certificate deletion.
+    const leaf = path.join(temporary, 'network/server.crt');
+    const caFile = network.ca;
+    const ca = await fs.readFile(caFile);
+    const nativeEvaluation = ['verify-cert', '-c', leaf, '-c', caFile, '-p', 'ssl', '-s', canonicalHost, '-L'];
+    if (process.platform === 'darwin') run('security', nativeEvaluation);
+    leafServer = https.createServer({
+      key: await fs.readFile(path.join(temporary, 'network/server.key')),
+      cert: Buffer.concat([await fs.readFile(leaf), ca]),
+    }, (_request, response) => response.end('same leaf\n'));
+    await new Promise((resolve, reject) => {
+      leafServer.once('error', reject); leafServer.listen(0, '127.0.0.1', resolve);
+    });
+    const leafAddress = { hostname: '127.0.0.1', port: leafServer.address().port, servername: canonicalHost, path: '/' };
+    assert.deepEqual(await nativeRequest(leafAddress), { status: 200, body: 'same leaf\n', authorized: true, address: '127.0.0.1' });
+
+    // Hold an event stream through cleanup; its lifetime belongs to the view.
+    let streamClosed;
+    await new Promise((resolve, reject) => {
+      streamRequest = https.get(`https://${canonicalHost}${events}`, { ca, agent: false, signal: AbortSignal.timeout(15_000) }, response => {
+        streamClosed = new Promise(done => response.once('close', done));
+        response.on('error', () => {}); // Shutdown may terminate the open stream.
+        if (response.statusCode !== 200) { response.resume(); reject(new Error(`Event stream returned ${response.statusCode}`)); return; }
+        let frame = ''; let ready = false;
+        response.setEncoding('utf8');
+        response.on('data', data => {
+          if (ready) return;
+          frame += data;
+          if (!frame.includes('\n\n')) return;
+          try { assert.match(frame, /^event: ready\n/); ready = true; resolve(); } catch (error) { reject(error); }
+        });
+        response.once('close', () => { if (!ready) reject(new Error('Event stream closed before readiness')); });
+      });
+      streamRequest.on('error', reject);
+    });
+    assert.equal((await network.command({ operation: 'status' })).subscribers, 1);
+    const closing = network; network = undefined;
+    await closing.close();
+    await streamClosed;
+    assert.deepEqual(await fs.readFile(hostsFile), originalHosts, 'DNS cleanup restores the exact prior hosts bytes');
+    assert.equal(serviceCa(), originalServiceCa, 'Native service-manager trust environment is restored');
+    assert.equal(process.env.NODE_EXTRA_CA_CERTS, originalProcessCa, 'Caller trust environment remains owned by the caller');
+    assert.equal((await nativeRequest({ hostname: '127.0.0.1', servername: canonicalHost, path: selectedPath })).error,
+      'ECONNREFUSED', 'The privileged HTTPS listener exits with its view');
+    const untrusted = await nativeRequest(leafAddress);
+    assert.match(untrusted.error ?? '', /^(UNABLE_TO_VERIFY_LEAF_SIGNATURE|UNABLE_TO_GET_ISSUER_CERT_LOCALLY|CERT_UNTRUSTED|CERT_REJECTED|SELF_SIGNED_CERT_IN_CHAIN|DEPTH_ZERO_SELF_SIGNED_CERT)$/,
+      `The retired disposable CA must no longer authorize its supplied chain: ${JSON.stringify(untrusted)}`);
+    if (process.platform === 'darwin') {
+      assert.throws(() => run('security', nativeEvaluation),
+        error => Number.isInteger(error.status) && error.status > 0 && error.signal === null,
+        'The same native SSL policy invocation must reject the chain it previously accepted');
+    }
+  } catch (error) { failures.push(error); }
+  finally {
+    // Cleanup has its own verdict; it must not erase the initiating failure or
+    // prevent the other owned resources from being released.
+    for (const close of [
+      () => streamRequest?.destroy(),
+      () => network?.close(),
+      async () => {
+        if (leafServer) { leafServer.closeAllConnections(); await new Promise(resolve => leafServer.close(resolve)); }
+      },
+      () => fs.rm(temporary, { recursive: true, force: true }),
+    ]) {
+      try { await close(); } catch (error) { failures.push(error); }
+    }
+  }
+  if (failures.length === 1) throw failures[0];
+  if (failures.length) throw new AggregateError(failures, 'Native transport examination and cleanup failed');
+});

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@amalgm/shell",
-  "version": "0.1.164-preview.34187698689",
+  "version": "0.1.164-preview.34192807991",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@amalgm/shell",
-      "version": "0.1.164-preview.34187698689",
+      "version": "0.1.164-preview.34192807991",
       "license": "UNLICENSED",
       "dependencies": {
         "@amalgm/agents": "0.2.3-preview.34176069706",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amalgm/shell",
-  "version": "0.1.164-preview.34187698689",
+  "version": "0.1.164-preview.34192807991",
   "description": "The Amalgm runtime host assembled from the published @amalgm SDK capabilities.",
   "type": "module",
   "private": false,
@@ -151,11 +151,11 @@
       }
     ]
   },
-  "gitHead": "dda47143429c299e10b59709f6dc328d96cedbd7",
+  "gitHead": "f61742639720d43804c6c19aa14c2bdda763a78d",
   "amalgmSource": {
     "repository": "amalgm-inc/amalgm-shell",
     "branch": "preview",
-    "commit": "dda47143429c299e10b59709f6dc328d96cedbd7",
-    "occurrence": "34187698689"
+    "commit": "f61742639720d43804c6c19aa14c2bdda763a78d",
+    "occurrence": "34192807991"
   }
 }