@volter/tabnode 0.5.48 → 0.5.50

package/src/runtime.ts

@@ -9,6 +9,7 @@ import { VirtualFS } from './virtual-fs';
 import { guestPromise, intrinsicPromise } from './promise-ownership';
 import { guestFetch, rememberRequestBodySource } from './fetch-transport';
 import { installNodeResponse } from './node-response';
+import { withNodeRequestBody } from './node-body';
 import { forGuestRealm, installGuestRealm, takeFromHost, defineOnHost, heldWork } from './host-globals';
 import type { IRuntime, IExecuteResult, IRuntimeOptions } from './runtime-interface';
 import type { PackageJson } from './types/package-json';
@@ -2953,6 +2954,8 @@ forGuestRealm(() => {
     const kept = new WeakMap<object, Headers>();
     class NodeRequest extends Native {
       constructor(input: RequestInfo | URL, init?: RequestInit) {
+        // An async-iterable body (a Node stream) is read as undici reads it.
+        init = withNodeRequestBody(init);
         super(input as RequestInfo, init);
         rememberRequestBodySource(this, input, init);
         const asked = new Headers(init?.headers ?? (input instanceof Native ? (input as Request).headers : undefined));

package/src/shims/child_process.ts

@@ -268,6 +268,22 @@ export function registerRunStreams(token: ProcessToken, streams: RunStreams): vo
 /** Forget a run that has ended. */
 export function releaseRunStreams(token: ProcessToken): void {
   _runStreams.delete(token);
+  shellRuns.delete(token);
+  hostedNodes.delete(token);
+}
+
+/** Runs whose program is a shell or another non-node program: a `node` they run is their child. */
+const shellRuns = new Set<ProcessToken>();
+/** Runs that are themselves a hosted `node`: a further `node` under them is a child. */
+const hostedNodes = new Set<ProcessToken>();
+
+/** A child identity for a `node` a run's shell runs: its own token and pid under the run's, on the run's streams. */
+function nestedNodeToken(parentToken: ProcessToken, args: readonly string[], cwd: string | undefined): ProcessToken {
+  const token: ProcessToken = `child-${__nextChildRun++}`;
+  setRunPid(token, mintPid(), runPid(parentToken)?.pid ?? 0, { argv: ['node', ...args], ...(cwd ? { cwd } : {}) });
+  const parentStreams = runStreamsFor(parentToken);
+  if (parentStreams) registerRunStreams(token, parentStreams);
+  return token;
 }
 
 /** What the host gave the named run, while it lasts. */
@@ -429,14 +445,30 @@ export function initChildProcess(vfs: VirtualFS): void {
 
     // Capture this run's name, streams and cancellation before another Node
     // entry can start. Forks and shell entries reach this same dispatch seam.
-    const runToken = runTokenOf(ctx);
+    const parentToken = runTokenOf(ctx);
+    // A `node` a shell runs is a process of its own unless it is the run
+    // itself: the first `node` of a run that is not a shell's child is the
+    // run (the CMD `node server.js`, the page's `node -e`), and every other
+    // one, a line of a start script, the second command of a `-c` line, a
+    // step of a `sh file` child, gets a child token under the run's pid,
+    // the run's streams, and its own admission at the host. Admitted under
+    // the shell's own token, its exit was read as the shell's: a script
+    // ended at its first `node` line with nothing after it (measured
+    // 2026-09-28: `sh start.sh` printed its first step and stopped).
+    const nested = parentToken !== null && (shellRuns.has(parentToken) || hostedNodes.has(parentToken));
+    const runToken = nested ? nestedNodeToken(parentToken!, args, ctx.cwd) : parentToken;
     const streams = runToken === null ? undefined : runStreamsFor(runToken);
     const processHost = nodeProcessHostFor(runToken);
     if (processHost && runToken !== null) {
-      return runHostedNode(processHost, {
-        token: runToken, argv: [...args], cwd: ctx.cwd, filesystem: tree, env: guestEnvironmentOf(ctx),
-        ...(typeof ctx.stdin === 'string' ? { stdin: ctx.stdin } : {}), ...(streams ? { streams } : {}),
-      });
+      if (!nested) hostedNodes.add(runToken);
+      try {
+        return await runHostedNode(processHost, {
+          token: runToken, argv: [...args], cwd: ctx.cwd, filesystem: tree, env: guestEnvironmentOf(ctx),
+          ...(typeof ctx.stdin === 'string' ? { stdin: ctx.stdin } : {}), ...(streams ? { streams } : {}),
+        });
+      } finally {
+        if (nested) releaseRunStreams(runToken);
+      }
     }
 
     // Node reads its own options before the script: `node --turbo-fast-api-calls
@@ -1719,6 +1751,9 @@ function existsInTree(path: string): boolean {
  * a program the engine can run; the engine's own `node`, written to
  * `/usr/local/bin/node` when the shim is initialized, is one of those.
  */
+/** The shells a script or a `-c` line runs under; a child of these goes to the host when there is one. */
+const SHELL_PROGRAMS = new Set(['sh', 'bash', 'dash', '/bin/sh', '/bin/bash', '/usr/bin/sh', '/usr/bin/bash']);
+
 function engineProgramFor(file: string, cwd?: string): string {
   const name = __substrateProgramName(file);
   if (!name.includes('/')) return name;
@@ -1794,6 +1829,7 @@ function startChildRun(request: RunRequest): StartedRun {
   // A host terminal consumes input incrementally. The old string-only
   // route dropped every keystroke that arrived after a child was launched.
   const admittedNode = nodeProcessHostInstalled() && engineProgramFor(request.file, request.cwd) === 'node';
+  if (!admittedNode) shellRuns.add(token);
   const hostTerminal = request.terminal !== undefined && hostExecutor() !== null && !admittedNode;
   let wakeInput: (() => void) | undefined;
   /**
@@ -1904,7 +1940,14 @@ function startChildRun(request: RunRequest): StartedRun {
   const begin = (): void => {
     if (started || finished) return;
     started = true;
-    const engineFirst = !hostTerminal && programExists(request.file, request.cwd, request.env);
+    // A shell a hosted program spawns (`sh start.sh`, `sh -c '…'`) runs at
+    // the host when there is one, not in this worker's own bash: the host is
+    // where the programs the page registered live (`npx` under /usr/bin),
+    // and where a `node` inside the script is given a named run. Run here,
+    // the script's `node` found no name and was refused, and its `npx` was
+    // not found at all.
+    const shellChild = SHELL_PROGRAMS.has(engineProgramFor(request.file, request.cwd)) && hostExecutor() !== null;
+    const engineFirst = !hostTerminal && !shellChild && programExists(request.file, request.cwd, request.env);
     liveInput = !hostTerminal && !admittedNode && request.stdinIsPipe && !engineFirst;
     if (liveInput) {
       pendingStdin.unshift(...initialStdin);

package/src/shims/crypto-cipher.ts

@@ -0,0 +1,354 @@
+/**
+ * Node's `createCipheriv` and `createDecipheriv` for AES in GCM, CBC, CTR and
+ * ECB modes. A guest calls them synchronously and WebCrypto is async-only, so
+ * the modes are built here over one synchronous AES block (`@noble/ciphers`,
+ * pinned exactly: its single-block helpers are the library's unsafe surface)
+ * and GCM's GHASH. Every mode streams as OpenSSL does: `update` answers the
+ * bytes it can, `final` the rest, so a caller that reads `update` alone for a
+ * stream mode gets its ciphertext (jose's GCM encrypt: `const ciphertext =
+ * cipher.update(plaintext); cipher.final();`, which is how NextAuth seals its
+ * session cookie).
+ *
+ * Not here: the ciphers are not `stream.Transform`s (only `update`/`final`),
+ * and no mode but these four, nor ChaCha20-Poly1305, is offered.
+ */
+import { unsafe } from '@noble/ciphers/aes.js';
+import { GHASH } from '@noble/ciphers/_polyval.js';
+
+type Mode = 'gcm' | 'cbc' | 'ctr' | 'ecb';
+type Bytes = Uint8Array;
+
+export interface CipherDeps {
+  /** The guest's Buffer.from over bytes. */
+  toBuffer(bytes: Bytes): Uint8Array;
+  /** Bytes of a string (in its encoding) or a view, as the rest of crypto reads them. */
+  bytesOf(value: unknown, encoding?: string): Bytes;
+  /** A secret KeyObject's bytes, or undefined when the value is not a KeyObject. */
+  secretKeyBytes(value: unknown): Bytes | undefined;
+  /** Bytes in an output encoding, as `digest` answers them. */
+  encode(bytes: Bytes, encoding?: string): unknown;
+  error(code: string, message: string): Error;
+}
+
+const CIPHERS = /^aes-(128|192|256)-(gcm|cbc|ctr|ecb)$/u;
+
+/** The ciphers `createCipheriv` accepts, as `getCiphers` lists them. */
+export function cipherNames(): string[] {
+  const names: string[] = [];
+  for (const bits of [128, 192, 256]) for (const mode of ['cbc', 'ctr', 'ecb', 'gcm']) names.push(`aes-${bits}-${mode}`);
+  return names;
+}
+
+const GCM_TAG_LENGTHS = new Set([4, 8, 12, 13, 14, 15, 16]);
+
+export function createCipherClasses(deps: CipherDeps) {
+  const { error } = deps;
+
+  function parse(algorithm: unknown): { keyLength: number; mode: Mode } {
+    if (typeof algorithm !== 'string') throw Object.assign(new TypeError('The "cipher" argument must be of type string.'), { code: 'ERR_INVALID_ARG_TYPE' });
+    const match = CIPHERS.exec(algorithm.toLowerCase());
+    if (!match) throw error('ERR_CRYPTO_UNKNOWN_CIPHER', 'Unknown cipher');
+    return { keyLength: Number(match[1]) / 8, mode: match[2] as Mode };
+  }
+
+  function keyOf(key: unknown, keyLength: number): Bytes {
+    const bytes = deps.secretKeyBytes(key) ?? deps.bytesOf(key);
+    if (bytes.length !== keyLength) throw Object.assign(new RangeError('Invalid key length'), { code: 'ERR_CRYPTO_INVALID_KEYLEN' });
+    return new Uint8Array(bytes);
+  }
+
+  function ivOf(iv: unknown, mode: Mode): Bytes | undefined {
+    if (mode === 'ecb') {
+      if (iv === null || iv === undefined) return undefined;
+      const bytes = deps.bytesOf(iv);
+      if (bytes.length !== 0) throw Object.assign(new TypeError('Invalid initialization vector'), { code: 'ERR_CRYPTO_INVALID_IV' });
+      return undefined;
+    }
+    if (iv === null || iv === undefined) throw Object.assign(new TypeError('Invalid initialization vector'), { code: 'ERR_CRYPTO_INVALID_IV' });
+    const bytes = new Uint8Array(deps.bytesOf(iv));
+    if (mode === 'gcm' ? bytes.length === 0 : bytes.length !== 16) throw Object.assign(new TypeError('Invalid initialization vector'), { code: 'ERR_CRYPTO_INVALID_IV' });
+    return bytes;
+  }
+
+  /** One AES block, encrypted in place in a fresh aligned array. */
+  function encryptBlock(xk: Uint32Array, block: Bytes): Bytes {
+    const out = new Uint8Array(16);
+    out.set(block);
+    return unsafe.encryptBlock(xk, out) as Bytes;
+  }
+
+  function decryptBlock(xk: Uint32Array, block: Bytes): Bytes {
+    const out = new Uint8Array(16);
+    out.set(block);
+    return unsafe.decryptBlock(xk, out) as Bytes;
+  }
+
+  function concat(a: Bytes, b: Bytes): Bytes {
+    if (a.length === 0) return b;
+    if (b.length === 0) return a;
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a);
+    out.set(b, a.length);
+    return out;
+  }
+
+  /** A 128-bit big-endian counter, or its low 32 bits alone (GCM's inc32). */
+  function increment(counter: Bytes, from: number): void {
+    for (let i = 15; i >= from; i--) {
+      counter[i] = (counter[i]! + 1) & 0xff;
+      if (counter[i] !== 0) return;
+    }
+  }
+
+  // The subclasses' doors to the tag, which the base keeps private (as KeyObject's keyInfoOf reads its key).
+  let authTagOf: (cipher: CipherBase) => Bytes;
+  let expectTagOf: (cipher: CipherBase, tag: unknown, encoding?: string) => void;
+
+  class CipherBase {
+    static {
+      authTagOf = (cipher) => cipher.#getTag();
+      expectTagOf = (cipher, tag, encoding) => cipher.#setTag(tag, encoding);
+    }
+    readonly #decrypt: boolean;
+    readonly #mode: Mode;
+    readonly #xk: Uint32Array;
+    readonly #xkDec: Uint32Array | undefined;
+    #padding = true;
+    #finished = false;
+    #started = false;
+    /** CBC/ECB: bytes not yet a whole block (and, decrypting with padding, the last whole block). */
+    #pending: Bytes = new Uint8Array(0);
+    /** CBC's chaining block. */
+    #chain: Bytes | undefined;
+    /** CTR/GCM: the next counter block and what is left of the current keystream block. */
+    #counter: Bytes | undefined;
+    #keystream: Bytes = new Uint8Array(0);
+    /** GCM. */
+    #ghash: GHASH | undefined;
+    #tagMask: Bytes | undefined;
+    #ghashPending: Bytes = new Uint8Array(0);
+    #aadLength = 0;
+    #dataLength = 0;
+    #authTagLength: number | undefined;
+    #authTag: Bytes | undefined;
+
+    constructor(decrypt: boolean, algorithm: unknown, key: unknown, iv: unknown, options?: { authTagLength?: number }) {
+      const { keyLength, mode } = parse(algorithm);
+      this.#decrypt = decrypt;
+      this.#mode = mode;
+      const keyBytes = keyOf(key, keyLength);
+      const ivBytes = ivOf(iv, mode);
+      this.#xk = unsafe.expandKeyLE(keyBytes) as Uint32Array;
+      this.#xkDec = decrypt && (mode === 'cbc' || mode === 'ecb') ? unsafe.expandKeyDecLE(keyBytes) as Uint32Array : undefined;
+      const tagLength = options?.authTagLength;
+      if (tagLength !== undefined) {
+        if (mode !== 'gcm') throw Object.assign(new TypeError(`Invalid authentication tag length: ${tagLength}`), { code: 'ERR_CRYPTO_INVALID_AUTH_TAG' });
+        if (!GCM_TAG_LENGTHS.has(tagLength)) throw Object.assign(new TypeError(`Invalid authentication tag length: ${tagLength}`), { code: 'ERR_CRYPTO_INVALID_AUTH_TAG' });
+        this.#authTagLength = tagLength;
+      }
+      if (mode === 'cbc') this.#chain = ivBytes;
+      if (mode === 'ctr') this.#counter = new Uint8Array(ivBytes!);
+      if (mode === 'gcm') {
+        // NIST SP 800-38D: H = E_K(0), J0 from a 96-bit IV or GHASH of any other, the tag mask E_K(J0), and the
+        // payload counted from inc32(J0).
+        const h = encryptBlock(this.#xk, new Uint8Array(16));
+        let j0: Bytes;
+        if (ivBytes!.length === 12) {
+          j0 = new Uint8Array(16);
+          j0.set(ivBytes!);
+          j0[15] = 1;
+        } else {
+          const lengths = new Uint8Array(16);
+          new DataView(lengths.buffer).setBigUint64(8, BigInt(ivBytes!.length * 8), false);
+          const g = new GHASH(h);
+          g.update(ivBytes!).update(lengths);
+          j0 = g.digest() as Bytes;
+        }
+        this.#tagMask = encryptBlock(this.#xk, j0);
+        this.#counter = new Uint8Array(j0);
+        increment(this.#counter, 12);
+        this.#ghash = new GHASH(h);
+      }
+    }
+
+    setAutoPadding(autoPadding = true): this {
+      if (this.#finished) throw error('ERR_CRYPTO_INVALID_STATE', 'Invalid state for operation setAutoPadding');
+      this.#padding = Boolean(autoPadding);
+      return this;
+    }
+
+    setAAD(buffer: unknown, _options?: { plaintextLength?: number }): this {
+      if (this.#mode !== 'gcm' || this.#started || this.#finished) throw error('ERR_CRYPTO_INVALID_STATE', 'Invalid state for operation setAAD');
+      const aad = deps.bytesOf(buffer);
+      // GHASH pads each update to a block; AAD is padded once, as GCM pads it, whatever its length.
+      this.#ghash!.update(aad);
+      this.#aadLength += aad.length;
+      return this;
+    }
+
+    #getTag(): Bytes {
+      if (this.#mode !== 'gcm' || this.#decrypt || !this.#finished || !this.#authTag) throw error('ERR_CRYPTO_INVALID_STATE', 'Invalid state for operation getAuthTag');
+      return this.#authTag;
+    }
+
+    #setTag(tag: unknown, encoding?: string): void {
+      if (this.#mode !== 'gcm' || !this.#decrypt || this.#finished) throw error('ERR_CRYPTO_INVALID_STATE', 'Invalid state for operation setAuthTag');
+      const bytes = new Uint8Array(typeof tag === 'string' ? deps.bytesOf(tag, encoding) : deps.bytesOf(tag));
+      const allowed = this.#authTagLength === undefined ? GCM_TAG_LENGTHS.has(bytes.length) : bytes.length === this.#authTagLength;
+      if (!allowed) throw Object.assign(new TypeError(`Invalid authentication tag length: ${bytes.length}`), { code: 'ERR_CRYPTO_INVALID_AUTH_TAG' });
+      this.#authTag = bytes;
+    }
+
+    update(data: unknown, inputEncoding?: string, outputEncoding?: string): unknown {
+      if (this.#finished) throw error('ERR_CRYPTO_INVALID_STATE', 'Invalid state for operation update');
+      this.#started = true;
+      const input = typeof data === 'string' ? deps.bytesOf(data, inputEncoding) : deps.bytesOf(data);
+      return deps.encode(this.#process(new Uint8Array(input)), outputEncoding);
+    }
+
+    final(outputEncoding?: string): unknown {
+      if (this.#finished) throw error('ERR_CRYPTO_INVALID_STATE', 'Unsupported state');
+      this.#finished = true;
+      return deps.encode(this.#finish(), outputEncoding);
+    }
+
+    #process(input: Bytes): Bytes {
+      switch (this.#mode) {
+        case 'ctr': return this.#stream(input);
+        case 'gcm': {
+          if (this.#decrypt) this.#absorb(input);
+          const out = this.#stream(input);
+          if (!this.#decrypt) this.#absorb(out);
+          this.#dataLength += input.length;
+          return out;
+        }
+        default: return this.#blocks(input);
+      }
+    }
+
+    /** XOR with the counter's keystream, carrying a partial block across calls. */
+    #stream(input: Bytes): Bytes {
+      const out = new Uint8Array(input.length);
+      let at = 0;
+      while (at < input.length) {
+        if (this.#keystream.length === 0) {
+          this.#keystream = encryptBlock(this.#xk, this.#counter!);
+          increment(this.#counter!, this.#mode === 'gcm' ? 12 : 0);
+        }
+        const take = Math.min(this.#keystream.length, input.length - at);
+        for (let i = 0; i < take; i++) out[at + i] = input[at + i]! ^ this.#keystream[i]!;
+        this.#keystream = this.#keystream.subarray(take);
+        at += take;
+      }
+      return out;
+    }
+
+    /** GHASH over the ciphertext, in whole blocks: GHASH pads each update, so a partial block waits for the next. */
+    #absorb(ciphertext: Bytes): void {
+      const all = concat(this.#ghashPending, ciphertext);
+      const whole = all.length - (all.length % 16);
+      if (whole > 0) this.#ghash!.update(all.subarray(0, whole));
+      this.#ghashPending = all.slice(whole);
+    }
+
+    /** CBC and ECB: every whole block now; decrypting with padding, the last whole block waits for `final`. */
+    #blocks(input: Bytes): Bytes {
+      const all = concat(this.#pending, input);
+      let whole = all.length - (all.length % 16);
+      if (this.#decrypt && this.#padding && whole === all.length && whole > 0) whole -= 16;
+      const out = new Uint8Array(whole);
+      for (let at = 0; at < whole; at += 16) out.set(this.#block(all.subarray(at, at + 16)), at);
+      this.#pending = all.slice(whole);
+      return out;
+    }
+
+    #block(block: Bytes): Bytes {
+      if (this.#mode === 'ecb') return this.#decrypt ? decryptBlock(this.#xkDec!, block) : encryptBlock(this.#xk, block);
+      if (this.#decrypt) {
+        const plain = decryptBlock(this.#xkDec!, block);
+        for (let i = 0; i < 16; i++) plain[i] = plain[i]! ^ this.#chain![i]!;
+        this.#chain = new Uint8Array(block);
+        return plain;
+      }
+      const mixed = new Uint8Array(16);
+      for (let i = 0; i < 16; i++) mixed[i] = block[i]! ^ this.#chain![i]!;
+      const cipher = encryptBlock(this.#xk, mixed);
+      this.#chain = cipher;
+      return cipher;
+    }
+
+    #finish(): Bytes {
+      if (this.#mode === 'ctr') return new Uint8Array(0);
+      if (this.#mode === 'gcm') return this.#finishGcm();
+      const rest = this.#pending;
+      this.#pending = new Uint8Array(0);
+      if (!this.#decrypt) {
+        if (!this.#padding) {
+          if (rest.length !== 0) throw error('ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH', 'error:1C80006B:Provider routines::wrong final block length');
+          return rest;
+        }
+        const pad = 16 - rest.length;
+        const block = new Uint8Array(16);
+        block.set(rest);
+        block.fill(pad, rest.length);
+        return this.#block(block);
+      }
+      if (!this.#padding) {
+        if (rest.length !== 0) throw error('ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH', 'error:1C80006B:Provider routines::wrong final block length');
+        return rest;
+      }
+      if (rest.length !== 16) throw error('ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH', 'error:1C80006B:Provider routines::wrong final block length');
+      const plain = this.#block(rest);
+      const pad = plain[15]!;
+      let valid = pad >= 1 && pad <= 16;
+      for (let i = 16 - pad; valid && i < 16; i++) valid = plain[i] === pad;
+      if (!valid) throw error('ERR_OSSL_BAD_DECRYPT', 'error:1C800064:Provider routines::bad decrypt');
+      return plain.slice(0, 16 - pad);
+    }
+
+    #finishGcm(): Bytes {
+      if (this.#ghashPending.length) this.#ghash!.update(this.#ghashPending);
+      const lengths = new Uint8Array(16);
+      const view = new DataView(lengths.buffer);
+      view.setBigUint64(0, BigInt(this.#aadLength * 8), false);
+      view.setBigUint64(8, BigInt(this.#dataLength * 8), false);
+      const full = this.#ghash!.update(lengths).digest() as Bytes;
+      for (let i = 0; i < 16; i++) full[i] = full[i]! ^ this.#tagMask![i]!;
+      if (!this.#decrypt) {
+        this.#authTag = full.slice(0, this.#authTagLength ?? 16);
+        return new Uint8Array(0);
+      }
+      const expected = this.#authTag;
+      let same = expected !== undefined;
+      if (expected) for (let i = 0; i < expected.length; i++) same = same && full[i] === expected[i];
+      if (!same) throw new Error('Unsupported state or unable to authenticate data');
+      return new Uint8Array(0);
+    }
+  }
+
+  class Cipheriv extends CipherBase {
+    constructor(algorithm: unknown, key: unknown, iv: unknown, options?: { authTagLength?: number }) {
+      super(false, algorithm, key, iv, options);
+    }
+    getAuthTag(): Uint8Array {
+      return deps.toBuffer(authTagOf(this));
+    }
+  }
+
+  class Decipheriv extends CipherBase {
+    constructor(algorithm: unknown, key: unknown, iv: unknown, options?: { authTagLength?: number }) {
+      super(true, algorithm, key, iv, options);
+    }
+    setAuthTag(tag: unknown, encoding?: string): this {
+      expectTagOf(this, tag, encoding);
+      return this;
+    }
+  }
+
+  return {
+    Cipheriv,
+    Decipheriv,
+    createCipheriv: (algorithm: unknown, key: unknown, iv: unknown, options?: { authTagLength?: number }) => new Cipheriv(algorithm, key, iv, options),
+    createDecipheriv: (algorithm: unknown, key: unknown, iv: unknown, options?: { authTagLength?: number }) => new Decipheriv(algorithm, key, iv, options),
+  };
+}

package/src/shims/crypto.ts

@@ -21,6 +21,7 @@ import {
   validateNumber,
 } from '../node-internals';
 import { cryptoConstants as constants } from './crypto-constants';
+import { cipherNames, createCipherClasses } from './crypto-cipher';
 export { constants };
 
 interface DigestState {
@@ -911,7 +912,8 @@ function timingSafeEqual(a: Buffer | Uint8Array, b: Buffer | Uint8Array): boolea
 }
 
 function getCiphers(): string[] {
-  return ['aes-128-cbc', 'aes-256-cbc', 'aes-128-gcm', 'aes-256-gcm'];
+  // What createCipheriv accepts, no more, as getHashes is createHash's.
+  return cipherNames();
 }
 
 function getHashes(): string[] {
@@ -1133,11 +1135,34 @@ async function importKey(
   throw new Error(`Unsupported key format: ${keyInfo.format}`);
 }
 
+// ============================================================================
+// Ciphers
+// ============================================================================
+
+const { Cipheriv, Decipheriv, createCipheriv, createDecipheriv } = createCipherClasses({
+  toBuffer: (bytes) => Buffer.from(bytes),
+  bytesOf: (value, encoding) => cryptoBytes(value, encoding, true),
+  secretKeyBytes: (value) => {
+    if (!(value instanceof KeyObject)) return undefined;
+    const info = keyInfoOf(value);
+    if (info.type !== 'secret' || !(info.keyData instanceof Uint8Array)) {
+      throw Object.assign(new TypeError(`Invalid key object type ${info.type}, expected secret.`), { code: 'ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE' });
+    }
+    return info.keyData;
+  },
+  encode: (bytes, encoding) => digestResult(bytes, encoding),
+  error: cryptoError,
+});
+
 // ============================================================================
 // Exports
 // ============================================================================
 
 return {
+  Cipheriv,
+  Decipheriv,
+  createCipheriv,
+  createDecipheriv,
   unsupported,
   randomBytes,
   randomFill,
@@ -1167,6 +1192,6 @@ return {
 
 }
 const cryptoModule = createCryptoModule();
-export const { randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
+export const { Cipheriv, Decipheriv, createCipheriv, createDecipheriv, randomBytes, randomFillSync, randomFill, randomUUID, randomInt, getRandomValues, unsupported, createHash, createHmac, hash, pbkdf2Sync, pbkdf2, sign, verify, createSign, createVerify, KeyObject, createSecretKey, createPublicKey, createPrivateKey, generateKeyPair, timingSafeEqual, getCiphers, getHashes } = cryptoModule;
 export type KeyObject = InstanceType<typeof KeyObject>;
 export default cryptoModule;

package/src/shims/shell-jobs.ts

@@ -386,6 +386,78 @@ export function installShellJobs(bash: Bash, host: ShellJobsHost): void {
     return { stdout: held.stdout, stderr: held.stderr + stderr, exitCode: status };
   }));
 
+  // `sh file`, `sh -c line` and `sh` on stdin: the shell's own ran the script
+  // with the caller's exported variables alone, and a run's name travels in
+  // a variable the shell never exports, so a `node` on any line of a script
+  // found no named run and was refused ("Isolated Node execution requires a
+  // named run", a start script in browser-substrate's tab, 2026-09-28). The
+  // script is run as the shell's own would run it, with the name carried.
+  for (const shell of ['sh', 'bash'] as const) {
+    bash.registerCommand(defineCommand(shell, async (args, ctx) => {
+      const exec = ctx.exec;
+      if (!exec) return { stdout: '', stderr: `bash: ${shell}: needs a shell that can run a script\n`, exitCode: 1 };
+      let script: string;
+      let zero: string;
+      let positional: string[];
+      let sourced: string | undefined;
+      // Options before the script (`sh -e start.sh`, `bash -eu -c …`) are the
+      // shell's own; they are passed over rather than read as the file's name.
+      let at = 0;
+      while (at < args.length && /^[-+][a-bd-zA-Z]+$/u.test(args[at]!)) at++;
+      args = args.slice(at);
+      if (args[0] === '-c' && args.length >= 2) {
+        script = args[1]!;
+        zero = args[2] ?? shell;
+        positional = args.slice(3);
+      } else if (args.length === 0) {
+        if (!ctx.stdin?.trim()) return { stdout: '', stderr: '', exitCode: 0 };
+        script = ctx.stdin;
+        zero = shell;
+        positional = [];
+      } else {
+        const path = ctx.fs.resolvePath(ctx.cwd, args[0]!);
+        try { script = String(await ctx.fs.readFile(path)); }
+        catch { return { stdout: '', stderr: `${shell}: ${args[0]}: No such file or directory\n`, exitCode: 127 }; }
+        zero = args[0]!;
+        positional = args.slice(1);
+        sourced = path;
+      }
+      if (script.startsWith('#!')) {
+        const newline = script.indexOf('\n');
+        if (newline !== -1) script = script.slice(newline + 1);
+      }
+      const env: Record<string, string> = { ...(ctx.exportedEnv ?? {}), '0': zero, '#': String(positional.length), '@': positional.join(' '), '*': positional.join(' ') };
+      positional.forEach((word, index) => { env[String(index + 1)] = word; });
+      const token = ctx.env.get(PROCESS_TOKEN_ENV);
+      if (token) env[PROCESS_TOKEN_ENV] = token;
+      // A file is sourced by one statement of the nested run rather than run
+      // as the nested run's own script: a nested script of several lines
+      // stopped after its first hosted `node` in a tab (2026-09-28), while
+      // the same lines sourced from one statement ran whole. The shebang
+      // line is a comment to the shell that sources it.
+      if (sourced !== undefined) script = `. ${sourced.replace(/'/gu, "'\\''").replace(/^(.*)$/su, "'$1'")}`;
+      const result = await exec(script, { env, cwd: ctx.cwd, stdin: ctx.stdin, signal: (ctx as { signal?: AbortSignal }).signal });
+      return { stdout: result.stdout ?? '', stderr: result.stderr ?? '', exitCode: result.exitCode ?? 0 };
+    }));
+  }
+  // `exec command…` runs the command in the script's place, with the
+  // script's environment and its run's name, and answers with its status.
+  // The shell's own `exec` ran a builtin but a program the engine defines,
+  // `node`, ran nothing: a start script's `exec node server.js` ended with
+  // no server and no word. This one hands the line back to the shell, which
+  // is where `node`, `npm` and the host's programs are found. The shell is
+  // not replaced: a line after `exec` runs once the command ends, where
+  // bash would never reach it. A start script's `exec` is its last line, a
+  // server that does not end.
+  bash.registerCommand(defineCommand('exec', async (args, ctx) => {
+    if (args.length === 0) return { stdout: '', stderr: '', exitCode: 0 };
+    if (!ctx.exec) return { stdout: '', stderr: 'bash: exec: needs a shell that can run a line\n', exitCode: 1 };
+    const line = args.map((word) => /^[A-Za-z0-9_./:=@%+,-]+$/u.test(word) ? word : `'${word.replace(/'/gu, "'\\''")}'`).join(' ');
+    const env: Record<string, string> = Object.fromEntries(ctx.env);
+    const result = await ctx.exec(line, { env, cwd: ctx.cwd, replaceEnv: true });
+    return { stdout: result.stdout ?? '', stderr: result.stderr ?? '', exitCode: result.exitCode ?? 0 };
+  }));
+
   bash.registerCommand(defineCommand('kill', async (args) => {
     let signal = 'SIGTERM';
     let index = 0;