visaljs 0.0.7 → 0.0.9

package/node/prelude/internal/compression_streams.js

@@ -0,0 +1,153 @@
+// CompressionStream and DecompressionStream, as Node's (lib/internal/webstreams/compression.js):
+// a node:zlib stream as a readable and writable pair of web streams. Decompression rejects
+// trailing data (rejectGarbageAfterEnd). Linked into programs that name them (implicitModules in
+// node/index.ts); they are globals and node:stream/web's.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { CompressionStream as CompressionWrapper, DecompressionStream as DecompressionWrapper } from "../stream_web.js";
+import { createBrotliCompress, createBrotliDecompress, createDeflate, createDeflateRaw, createGunzip, createGzip, createInflate,
+  createInflateRaw } from "../zlib.js";
+import { codeError, invalidArgType } from "./errors.js";
+import { provideClass } from "./features.js";
+
+const kInspect = Symbol.for("nodejs.util.inspect.custom");
+const FORMATS = new Set(["deflate", "deflate-raw", "gzip", "brotli"]);
+
+/** webidl's CompressionFormat enum */
+function format(value, constructor) {
+  const s = String(value);
+  if (!FORMATS.has(s)) {
+    throw codeError(TypeError, "ERR_INVALID_ARG_VALUE",
+      `Failed to construct '${constructor}': 1st argument '${s}' is not a valid enum value of type CompressionFormat.`);
+  }
+  return s;
+}
+
+/** newReadableWritablePairFromDuplex: the duplex's output as a ReadableStream, its input as a
+ *  WritableStream; an error of either side errors both */
+function pairFromDuplex(duplex) {
+  let readableController, writableController;
+  let closed = false;
+  const onError = (error) => {
+    if (closed) return;
+    closed = true;
+    readableController.error(error);
+    writableController.error(error);
+  };
+  duplex.on("error", onError);
+  const readable = new ReadableStream({
+    start(controller) {
+      readableController = controller;
+      duplex.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        if (controller.desiredSize <= 0) duplex.pause();
+      });
+      duplex.on("end", () => {
+        if (closed) return;
+        closed = true;
+        controller.close();
+      });
+    },
+    pull() {
+      duplex.resume();
+    },
+    cancel(reason) {
+      duplex.destroy(reason);
+    },
+  });
+  const writable = new WritableStream({
+    start(controller) {
+      writableController = controller;
+    },
+    write(chunk) {
+      /* a BufferSource, not backed by a SharedArrayBuffer */
+      if (typeof SharedArrayBuffer === "function" && (ArrayBuffer.isView(chunk) ? chunk.buffer : chunk) instanceof SharedArrayBuffer) {
+        throw invalidArgType("chunk", "an instance of ArrayBuffer, Buffer, TypedArray, or DataView", chunk);
+      }
+      return new Promise((resolve, reject) => {
+        try {
+          if (duplex.write(chunk)) resolve();
+          else duplex.once("drain", resolve);
+        } catch (error) {
+          duplex.destroy(error);
+          reject(error);
+        }
+      });
+    },
+    close() {
+      return new Promise((resolve, reject) => {
+        duplex.once("finish", resolve);
+        duplex.once("error", reject);
+        duplex.end();
+      });
+    },
+    abort(reason) {
+      duplex.destroy(reason);
+    },
+  });
+  return { readable, writable };
+}
+
+function inspectAs(name, self, depth, options, inspect) {
+  if (depth < 0) return self;
+  const opts = { ...options, depth: options.depth == null ? null : options.depth - 1 };
+  return `${name} ${inspect({ readable: self.readable, writable: self.writable }, opts)}`;
+}
+
+class CompressionStream {
+  #transform;
+
+  constructor(kind) {
+    kind = format(kind, "CompressionStream");
+    const handle = kind === "deflate" ? createDeflate() : kind === "deflate-raw" ? createDeflateRaw() : kind === "gzip" ? createGzip()
+      : createBrotliCompress();
+    this.#transform = pairFromDuplex(handle);
+  }
+
+  get readable() {
+    return this.#transform.readable;
+  }
+
+  get writable() {
+    return this.#transform.writable;
+  }
+
+  [kInspect](depth, options, inspect) {
+    return inspectAs("CompressionStream", this, depth, options, inspect);
+  }
+}
+
+class DecompressionStream {
+  #transform;
+
+  constructor(kind) {
+    kind = format(kind, "DecompressionStream");
+    const options = { rejectGarbageAfterEnd: true };
+    const handle = kind === "deflate" ? createInflate(options) : kind === "deflate-raw" ? createInflateRaw(options)
+      : kind === "gzip" ? createGunzip(options) : createBrotliDecompress(options);
+    this.#transform = pairFromDuplex(handle);
+  }
+
+  get readable() {
+    return this.#transform.readable;
+  }
+
+  get writable() {
+    return this.#transform.writable;
+  }
+
+  [kInspect](depth, options, inspect) {
+    return inspectAs("DecompressionStream", this, depth, options, inspect);
+  }
+}
+
+for (const [Class, name] of [[CompressionStream, "CompressionStream"], [DecompressionStream, "DecompressionStream"]]) {
+  Object.defineProperties(Class.prototype, {
+    readable: { enumerable: true },
+    writable: { enumerable: true },
+    [Symbol.toStringTag]: { configurable: true, value: name },
+  });
+}
+provideClass(CompressionWrapper, CompressionStream);
+provideClass(DecompressionWrapper, DecompressionStream);
+Object.defineProperty(globalThis, "CompressionStream", { value: CompressionWrapper, writable: true, enumerable: false, configurable: true });
+Object.defineProperty(globalThis, "DecompressionStream", { value: DecompressionWrapper, writable: true, enumerable: false, configurable: true });

package/node/prelude/internal/crypto/asym.js

@@ -1,7 +1,8 @@
-// node:crypto's asymmetric operations (ADR 0018): Sign and Verify (Writable streams, as Node's),
+// node:crypto's asymmetric operations: Sign and Verify (Writable streams, as Node's),
 // sign and verify, publicEncrypt, privateDecrypt, privateEncrypt and publicDecrypt, ECDH,
 // diffieHellman and getCurves: Node's lib/internal/crypto/{sig,cipher,diffiehellman}.js over the
 // runtime's C (crypto_asym.c), which signs digests: the hashing is the Hash primitives'.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   cryptoDigestFinal, cryptoDigestUpdate, cryptoEcdh, cryptoEcPoint, cryptoEcPrivate, cryptoHashNew, cryptoKeyGenerate, cryptoKeyParts,
   cryptoRsaCrypt, cryptoSign, cryptoSignMessage, cryptoVerify, cryptoVerifyMessage,
@@ -211,7 +212,9 @@ export function verify(algorithm, data, key, signature, callback) {
   getIntOption("padding", key);
   getIntOption("saltLength", key);
   getDSASignatureEncoding(key);
-  if (!isArrayBufferView(signature)) throw invalidArgType("signature", "an instance of Buffer, TypedArray, or DataView", signature);
+  /* Node 24: as the data, a string's UTF-8 bytes too */
+  signature = bytesOf(signature, "signature");
+  if (isAnyArrayBuffer(signature)) signature = new Uint8Array(signature);
   const handle = preparePublicOrPrivateKey(key);
   const run = signsMessages(handle) ? () => verifyMessage(handle, algorithm, data, signature) : () => {
     const hash = hashFor(algorithm, handle);
@@ -338,23 +341,33 @@ export function createECDH(curve) {
 
 /* ---- diffieHellman ----------------------------------------------------------------------------- */
 
-const keyObjectType = (actual, expected) =>
-  codeError(TypeError, "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", `Invalid key object type ${actual}, expected ${expected}.`);
+/** The two keys' types must match, and be ones Diffie-Hellman takes. */
+function dhKeyTypes(privateHandle, publicHandle) {
+  const privateType = asymmetricKeyTypeOf(privateHandle);
+  const publicType = asymmetricKeyTypeOf(publicHandle);
+  if (privateType !== publicType || (privateType !== "ec" && privateType !== "x25519" && privateType !== "dh")) {
+    throw codeError(Error, "ERR_CRYPTO_INCOMPATIBLE_KEY", `Incompatible key types for Diffie-Hellman: ${privateType} and ${publicType}`);
+  }
+  return privateType;
+}
 
+/* Node 24's: KeyObjects, or key material (PEM, DER, JWK) as createPrivateKey and createPublicKey
+   take it */
 export function diffieHellman(options) {
   validateObject(options, "options");
   const { privateKey, publicKey } = options;
-  if (!(privateKey instanceof KeyObject)) throw invalidArgValue("options.privateKey", "is invalid", privateKey);
-  if (!(publicKey instanceof KeyObject)) throw invalidArgValue("options.publicKey", "is invalid", publicKey);
-  if (privateKey.type !== "private") throw keyObjectType(privateKey.type, "private");
-  if (publicKey.type !== "public" && publicKey.type !== "private") throw keyObjectType(publicKey.type, "private or public");
-  const privateType = asymmetricKeyTypeOf(privateKey[kHandle]);
-  const publicType = asymmetricKeyTypeOf(publicKey[kHandle]);
-  if (privateType !== publicType || (privateType !== "ec" && privateType !== "x25519" && privateType !== "dh")) {
-    throw codeError(Error, "ERR_CRYPTO_INCOMPATIBLE_KEY", `Incompatible key types for Diffie-Hellman: ${privateType} and ${publicType}`);
+  if (privateKey === undefined) throw invalidArgValue("options.privateKey", "is invalid", privateKey);
+  if (publicKey === undefined) throw invalidArgValue("options.publicKey", "is invalid", publicKey);
+  /* two KeyObjects of usable types: their key types are checked first */
+  if (privateKey instanceof KeyObject && privateKey.type === "private" &&
+      publicKey instanceof KeyObject && (publicKey.type === "public" || publicKey.type === "private")) {
+    dhKeyTypes(privateKey[kHandle], publicKey[kHandle]);
   }
-  if (privateType === "dh") return dhStateless(cryptoKeyParts(privateKey[kHandle]), cryptoKeyParts(publicKey[kHandle]));
-  const ret = cryptoEcdh(privateKey[kHandle], publicKey[kHandle]);
+  const publicHandle = preparePublicOrPrivateKey(publicKey);
+  const privateHandle = preparePrivateKey(privateKey);
+  const type = dhKeyTypes(privateHandle, publicHandle);
+  if (type === "dh") return dhStateless(cryptoKeyParts(privateHandle), cryptoKeyParts(publicHandle));
+  const ret = cryptoEcdh(privateHandle, publicHandle);
   if (typeof ret === "number") throw asymError(9);
   return ret;
 }

package/node/prelude/internal/crypto/cipher.js

@@ -1,7 +1,8 @@
-// node:crypto's ciphers (ADR 0018): Cipheriv and Decipheriv (lazy Transform streams, as Node's),
+// node:crypto's ciphers: Cipheriv and Decipheriv (lazy Transform streams, as Node's),
 // getCiphers and getCipherInfo, Node's lib/internal/crypto/cipher.js over the runtime's C cipher
 // context. Output encodings go through a StringDecoder, so a multi-byte character or a base64
 // group isn't split between update and final.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   cryptoCipherFinal, cryptoCipherGetAuthTag, cryptoCipherInfo, cryptoCipherNew, cryptoCiphers, cryptoCipherSetAAD,
   cryptoCipherSetAuthTag, cryptoCipherSetPadding, cryptoCipherUpdate,
@@ -55,15 +56,18 @@ function bytesOf(value, name, encoding) {
   throw invalidArgType(name, "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", value);
 }
 
+/* Node 24's: an unknown encoding is ERR_UNKNOWN_ENCODING (StringDecoder's), a different one than
+   the first output's ERR_INVALID_ARG_VALUE */
 function getDecoder(decoder, encoding) {
+  const normalized = new StringDecoder(encoding).encoding;
   decoder ||= new StringDecoder(encoding);
-  if (decoder.encoding !== new StringDecoder(encoding).encoding) {
-    throw codeError(Error, "ERR_INTERNAL_ASSERTION", "Cannot change encoding\nThis is caused by either a bug in Node.js or incorrect " +
-      "usage of Node.js internals.\nPlease open an issue with this stack trace at https://github.com/nodejs/node/issues\n");
-  }
+  if (decoder.encoding !== normalized) throw invalidArgValue("outputEncoding", `cannot be changed from '${decoder.encoding}'`, encoding);
   return decoder;
 }
 
+const kGcmAnyTag = Symbol("kGcmAnyTag");
+let warnedShortTag = false;
+
 function createCipherWithIV(self, cipher, key, options, encrypt, iv) {
   validateString(cipher, "cipher");
   const encoding = getStringOption(options, "encoding");
@@ -73,6 +77,8 @@ function createCipherWithIV(self, cipher, key, options, encrypt, iv) {
   const handle = cryptoCipherNew(cipher, encrypt, key, iv, authTagLength);
   if (typeof handle === "number") throw cipherError(handle, cipher, authTagLength);
   self[kHandle] = handle;
+  /* GCM without authTagLength: a short tag on decryption is deprecated (DEP0182) */
+  self[kGcmAnyTag] = /-gcm$/i.test(cipher) && authTagLength === -1;
   self._decoder = null;
   LazyTransform.call(self, options);
 }
@@ -155,6 +161,11 @@ Decipheriv.prototype.setAuthTag = function setAuthTag(tagbuf, encoding) {
   const code = cryptoCipherSetAuthTag(this[kHandle], tagbuf);
   if (code === 5) throw invalidState("setAuthTag");
   if (code !== 0) throw cipherError(code, undefined, tagbuf.byteLength);
+  if (this[kGcmAnyTag] && tagbuf.byteLength !== 16 && !warnedShortTag) {
+    warnedShortTag = true;  /* once a process, as Node's */
+    process.emitWarning("Using AES-GCM authentication tags of less than 128 bits without specifying the authTagLength option " +
+      "when initializing decryption is deprecated.", "DeprecationWarning", "DEP0182");
+  }
   return this;
 };
 Decipheriv.prototype.setAAD = setAAD;

package/node/prelude/internal/crypto/diffiehellman.js

@@ -1,9 +1,10 @@
-// node:crypto's finite-field Diffie-Hellman and primes (ADR 0018): DiffieHellman, DiffieHellmanGroup,
+// node:crypto's finite-field Diffie-Hellman and primes: DiffieHellman, DiffieHellmanGroup,
 // createDiffieHellman, getDiffieHellman (createDiffieHellmanGroup), generatePrime(Sync) and
 // checkPrime(Sync), as Node's lib/internal/crypto/{diffiehellman,random}.js have them, over the
 // runtime's big integers (crypto_bn.c: modular exponentiation, prime generation and testing).
 // What OpenSSL decides beneath Node's API is OpenSSL's here too: the private key lengths of the
 // MODP groups, DH_check's flags (verifyError), the public key checks of computeSecret.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { cryptoCheckPrime, cryptoGeneratePrime, cryptoModExp, cryptoRandomFill } from "visaljs:host";
 import { codeError, invalidArgType, outOfRange, validateFunction } from "../errors.js";
 import { DH_GROUPS } from "./dh_groups.js";
@@ -157,7 +158,7 @@ function checkPeer(state, key) {
   const pub = toBig(key);
   const p = toBig(state.p);
   if (pub <= 1n) throw codeError(RangeError, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too small");
-  if (pub >= p - 1n) throw codeError(RangeError, "ERR_CRYPTO_INVALID_KEYTYPE", "Unspecified validation error");
+  if (pub >= p - 1n) throw codeError(RangeError, "ERR_CRYPTO_INVALID_KEYLEN", "Supplied key is too large");  /* Node 24 (OpenSSL 3.5) */
 }
 
 function dhComputeSecret(key, inEnc, outEnc) {

package/node/prelude/internal/crypto/hash.js

@@ -1,5 +1,6 @@
-// node:crypto's Hash and Hmac, and crypto.hash() (ADR 0018): Node's lib/internal/crypto/hash.js
+// node:crypto's Hash and Hmac, and crypto.hash(): Node's lib/internal/crypto/hash.js
 // over the host primitives, which hash in C (BoringSSL, and SHA-3 of our own).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   cryptoDigestFinal, cryptoDigestUpdate, cryptoHashCopy, cryptoHashes, cryptoHashInfo, cryptoHashNew, cryptoHmacNew,
 } from "visaljs:host";

package/node/prelude/internal/crypto/kdf.js

@@ -1,6 +1,7 @@
-// node:crypto's key derivation (ADR 0018): pbkdf2, hkdf and scrypt, Node's
+// node:crypto's key derivation: pbkdf2, hkdf and scrypt, Node's
 // lib/internal/crypto/{pbkdf2,hkdf,scrypt}.js over the runtime's C. The asynchronous forms
 // derive at the call and call back from a timer, where Node's thread pool would.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { cryptoHashInfo, cryptoHkdf, cryptoPbkdf2, cryptoScrypt, cryptoScryptCheck } from "visaljs:host";
 import { codeError, invalidArgType, outOfRange, validateFunction, validateString } from "../errors.js";
 import { KeyObject, prepareSecretKey } from "./keys.js";
@@ -8,6 +9,9 @@ import { isAnyArrayBuffer, isArrayBufferView, validateNumber } from "./util.js";
 
 const later = (fn) => setTimeout(fn, 0);
 const derivingFailed = () => new Error("Deriving bits failed");
+/* PBKDF2 and HKDF over SHAKE: OpenSSL 3.5 refuses an extendable-output function, with this error */
+const isXof = (digest) => typeof digest === "string" && /^shake(128|256)$/i.test(digest);
+const kdfFailed = (digest) => (isXof(digest) ? new Error("error:1C8000B7:Provider routines::xof digests not allowed") : derivingFailed());
 const invalidDigest = (digest) => codeError(TypeError, "ERR_CRYPTO_INVALID_DIGEST", "Invalid digest: " + digest);
 
 function validateIntegerIn(value, name, min, max) {
@@ -40,7 +44,7 @@ function checkPbkdf2(password, salt, iterations, keylen, digest) {
 function runPbkdf2({ password, salt, iterations, keylen, digest }) {
   const result = cryptoPbkdf2(digest, password, salt, iterations, keylen);
   if (result === null) throw invalidDigest(digest);
-  if (result === false) throw derivingFailed();
+  if (result === false) throw kdfFailed(digest);
   return result;
 }
 
@@ -57,7 +61,7 @@ export function pbkdf2(password, salt, iterations, keylen, digest, callback) {
   validateFunction(callback, "callback");
   const result = cryptoPbkdf2(digest, args.password, args.salt, iterations, keylen);
   if (result === null) throw invalidDigest(digest);
-  later(() => (result === false ? callback(derivingFailed()) : callback(null, result)));
+  later(() => (result === false ? callback(kdfFailed(digest)) : callback(null, result)));
 }
 
 /* ---- HKDF -------------------------------------------------------------------------------------- */
@@ -91,7 +95,7 @@ function runHkdf({ hash, key, salt, info, length }) {
 
 export function hkdfSync(hash, key, salt, info, length) {
   const result = runHkdf(checkHkdf(hash, key, salt, info, length));
-  if (result === false) throw derivingFailed();
+  if (result === false) throw kdfFailed(hash);
   return result;
 }
 
@@ -99,13 +103,14 @@ export function hkdf(hash, key, salt, info, length, callback) {
   const args = checkHkdf(hash, key, salt, info, length);
   validateFunction(callback, "callback");
   const result = runHkdf(args);
-  later(() => (result === false ? callback(derivingFailed()) : callback(null, result)));
+  later(() => (result === false ? callback(kdfFailed(hash)) : callback(null, result)));
 }
 
 /* ---- scrypt ------------------------------------------------------------------------------------ */
 
 const defaults = { N: 16384, r: 8, p: 1, maxmem: 32 << 20 };
-const invalidParameter = () => codeError(Error, "ERR_CRYPTO_SCRYPT_INVALID_PARAMETER", "Invalid scrypt parameter");
+/* Node 24: an option given under both its names */
+const optionPair = (a, b) => codeError(TypeError, "ERR_INCOMPATIBLE_OPTION_PAIR", `Option "${a}" cannot be used in combination with option "${b}"`);
 
 function checkScrypt(password, salt, keylen, options) {
   password = bytesOf(password, "password");
@@ -119,7 +124,7 @@ function checkScrypt(password, salt, keylen, options) {
       validateUint32(N, "N");
     }
     if (options.cost !== undefined) {
-      if (hasN) throw invalidParameter();
+      if (hasN) throw optionPair("N", "cost");
       N = options.cost;
       validateUint32(N, "cost");
     }
@@ -129,7 +134,7 @@ function checkScrypt(password, salt, keylen, options) {
       validateUint32(r, "r");
     }
     if (options.blockSize !== undefined) {
-      if (hasR) throw invalidParameter();
+      if (hasR) throw optionPair("r", "blockSize");
       r = options.blockSize;
       validateUint32(r, "blockSize");
     }
@@ -139,7 +144,7 @@ function checkScrypt(password, salt, keylen, options) {
       validateUint32(p, "p");
     }
     if (options.parallelization !== undefined) {
-      if (hasP) throw invalidParameter();
+      if (hasP) throw optionPair("p", "parallelization");
       p = options.parallelization;
       validateUint32(p, "parallelization");
     }

package/node/prelude/internal/crypto/keys.js

@@ -1,7 +1,8 @@
-// node:crypto's keys (ADR 0018): KeyObject and its subclasses, as Node's lib/internal/crypto/keys.js
-// defines them (the same symbols, so they inspect as Node's do), over the runtime's key handles,
+// node:crypto's keys: KeyObject and its subclasses, as Node 24's lib/internal/crypto/keys.js
+// defines them (their slots hidden, so they inspect as {} as Node's do), over the runtime's key handles,
 // which CryptoKey shares. PEM (base64 and its labels) and JWK (base64url and its members) are
 // here; DER is the runtime's.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   cryptoHashInfo, cryptoKeyEquals, cryptoRandomFill, cryptoKeyExport, cryptoKeyFromParts, cryptoKeyGenerate, cryptoKeyHandleOf, cryptoKeyInfo,
   cryptoKeyParse, cryptoKeyParts, cryptoKeyPublic, cryptoKeySecret, cryptoKeySecretBytes, cryptoToCryptoKey,
@@ -15,6 +16,11 @@ const kAsymmetricKeyType = Symbol("kAsymmetricKeyType");
 const kAsymmetricKeyDetails = Symbol("kAsymmetricKeyDetails");
 
 const later = (fn) => setTimeout(fn, 0);
+/* a slot of the key's: not enumerable, as Node 24's private fields aren't seen */
+const slot = (o, key, value) => {
+  Object.defineProperty(o, key, { value, enumerable: false, configurable: false, writable: false });
+  return value;
+};
 const isStringOrBuffer = (v) => typeof v === "string" || isArrayBufferView(v) || isAnyArrayBuffer(v);
 
 /* ---- errors ------------------------------------------------------------------------------------ */
@@ -23,7 +29,7 @@ const keyObjectType = (actual, expected) =>
   codeError(TypeError, "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", `Invalid key object type ${actual}, expected ${expected}.`);
 const incompatible = (encoding, why) =>
   codeError(Error, "ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS", `The selected key encoding ${encoding} ${why}.`);
-const invalidJwk = () => codeError(TypeError, "ERR_CRYPTO_INVALID_JWK", "Invalid JWK data");
+const invalidJwk = (message = "Invalid JWK data") => codeError(TypeError, "ERR_CRYPTO_INVALID_JWK", message);
 
 /* the runtime's error codes for a key it couldn't decode or encode */
 function keyError(code) {
@@ -97,14 +103,21 @@ export class KeyObject {
   constructor(type, handle) {
     if (type !== "secret" && type !== "public" && type !== "private") throw invalidArgValue("type", "is invalid", type);
     if (typeof handle !== "object" || handle === null || !isKeyHandle(handle)) throw invalidArgType("handle", "of type object", handle);
-    this[kKeyType] = type;
-    Object.defineProperty(this, kHandle, { value: handle, enumerable: false, configurable: false, writable: false });
+    slot(this, kKeyType, type);
+    slot(this, kHandle, handle);
   }
 
   get type() {
     return this[kKeyType];
   }
 
+  /* Node 24: on KeyObject, for every type */
+  toCryptoKey(algorithm, extractable, keyUsages) {
+    if (this.type === "secret") return cryptoToCryptoKey("raw", cryptoKeySecretBytes(this[kHandle]), algorithm, extractable, keyUsages);
+    const der = cryptoKeyExport(this[kHandle], this.type === "public" ? 0 : 2);
+    return cryptoToCryptoKey(this.type === "public" ? "spki" : "pkcs8", der, algorithm, extractable, keyUsages);
+  }
+
   static from(key) {
     const handle = cryptoKeyHandleOf(key);
     if (handle === undefined) throw invalidArgType("key", "an instance of CryptoKey", key);
@@ -134,10 +147,6 @@ class SecretKeyObject extends KeyObject {
     }
     return cryptoKeySecretBytes(this[kHandle]);
   }
-
-  toCryptoKey(algorithm, extractable, keyUsages) {
-    return cryptoToCryptoKey("raw", cryptoKeySecretBytes(this[kHandle]), algorithm, extractable, keyUsages);
-  }
 }
 
 /* asymmetricKeyDetails: Node's normalized form of the key's details */
@@ -168,7 +177,7 @@ function keyDetails(handle) {
 
 class AsymmetricKeyObject extends KeyObject {
   get asymmetricKeyType() {
-    return this[kAsymmetricKeyType] ||= cryptoKeyInfo(this[kHandle])[1];
+    return this[kAsymmetricKeyType] ?? slot(this, kAsymmetricKeyType, cryptoKeyInfo(this[kHandle])[1]);
   }
 
   get asymmetricKeyDetails() {
@@ -177,16 +186,12 @@ class AsymmetricKeyObject extends KeyObject {
       case "rsa-pss":
       case "ec":
       case "dsa":
-        return this[kAsymmetricKeyDetails] ||= keyDetails(this[kHandle]);
+        return { ...(this[kAsymmetricKeyDetails] ?? slot(this, kAsymmetricKeyDetails, keyDetails(this[kHandle]))) };
       default:
         return {};
     }
   }
 
-  toCryptoKey(algorithm, extractable, keyUsages) {
-    const der = cryptoKeyExport(this[kHandle], this.type === "public" ? 0 : 2);
-    return cryptoToCryptoKey(this.type === "public" ? "spki" : "pkcs8", der, algorithm, extractable, keyUsages);
-  }
 }
 
 class PublicKeyObject extends AsymmetricKeyObject {
@@ -231,8 +236,9 @@ function wrapHandle(handle) {
 const SPKI = 0, PKCS1 = 1, PKCS8 = 2, SEC1 = 3, CERT = 4;
 const ENCODING_NAMES = { pkcs1: PKCS1, spki: SPKI, pkcs8: PKCS8, sec1: SEC1 };
 
-function option(name, objName) {
-  return objName === undefined ? `options.${name}` : `options.${objName}.${name}`;
+/* an option's name in messages: options.format, or under a prefix (Node 24's), key.format */
+function option(name, prefix) {
+  return prefix === undefined ? `options.${name}` : `${prefix}.${name}`;
 }
 
 function parseKeyFormat(formatStr, defaultFormat, optionName) {
@@ -347,50 +353,56 @@ function exportJwk(handle, isPrivate) {
   throw codeError(Error, "ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE", "Unsupported JWK Key Type.");
 }
 
-function fromParts(kind, isPrivate, crv, parts) {
+function fromParts(kind, isPrivate, crv, parts, message = "Invalid JWK data") {
   const handle = cryptoKeyFromParts(kind, isPrivate, crv, parts);
-  if (typeof handle === "number") throw handle === 3 ? notSupported("This curve") : invalidJwk();
+  if (typeof handle === "number") throw handle === 3 ? notSupported("This curve") : invalidJwk(message);
   return handle;
 }
 
+/* A JWK's key, checked as Node 24's native import checks it: one of its messages for each
+   failure. A JWK with "d" is a private key's, whichever is wanted. */
 function keyFromJwk(key, isPublic) {
+  const handle = jwkHandle(key, isPublic);
+  /* a private JWK where a public key is wanted: its public half */
+  return isPublic && key.d !== undefined ? cryptoKeyPublic(handle) : handle;
+}
+
+function jwkHandle(key, isPublic) {
   validateObject(key, "key");
-  validateOneOf(key.kty, "key.kty", ["RSA", "EC", "OKP"]);
+  if (typeof key.kty !== "string") throw invalidJwk("Invalid JWK format");
   const b64 = (s) => Buffer.from(s, "base64");
+  const str = (v) => typeof v === "string";
+  const isPrivate = key.d !== undefined;
+  const noPrivate = () => invalidJwk("JWK does not contain private key material");
   if (key.kty === "OKP") {
-    validateString(key.crv, "key.crv");
-    validateOneOf(key.crv, "key.crv", ["Ed25519", "Ed448", "X25519", "X448"]);
-    validateString(key.x, "key.x");
-    if (!isPublic) validateString(key.d, "key.d");
-    const data = isPublic ? b64(key.x) : b64(key.d);
-    if (key.crv !== "X25519" && key.crv !== "Ed25519") throw notSupported(key.crv + " keys");
-    if (data.byteLength !== 32) throw invalidJwk();
+    const size = { Ed25519: 32, X25519: 32, Ed448: 57, X448: 56 }[key.crv];
+    if (size === undefined || !str(key.x) || b64(key.x).byteLength !== size) throw invalidJwk("Invalid JWK OKP key");
+    if (isPrivate && (!str(key.d) || b64(key.d).byteLength !== size)) throw invalidJwk("Invalid JWK OKP key");
+    if (!isPublic && !isPrivate) throw noPrivate();
+    if (size !== 32) throw notSupported(key.crv + " keys");
     const kind = key.crv.toLowerCase();
-    return isPublic ? fromParts(kind, false, undefined, [data]) : fromParts(kind, true, undefined, [undefined, data]);
+    return isPrivate ? fromParts(kind, true, undefined, [undefined, b64(key.d)]) : fromParts(kind, false, undefined, [b64(key.x)]);
   }
   if (key.kty === "EC") {
-    validateString(key.crv, "key.crv");
-    validateOneOf(key.crv, "key.crv", ["P-256", "secp256k1", "P-384", "P-521"]);
-    validateString(key.x, "key.x");
-    validateString(key.y, "key.y");
-    if (!isPublic) validateString(key.d, "key.d");
+    if (!str(key.crv)) throw invalidJwk("Invalid JWK EC key");
+    if (!["P-256", "secp256k1", "P-384", "P-521"].includes(key.crv)) throw codeError(TypeError, "ERR_CRYPTO_INVALID_CURVE", "Invalid EC curve name");
+    if (!str(key.x) || !str(key.y) || (isPrivate && !str(key.d))) throw invalidJwk("Invalid JWK EC key");
     const size = CURVE_SIZES[key.crv];
     const x = b64(key.x);
     const y = b64(key.y);
-    if (size !== undefined && (x.length !== size || y.length !== size)) throw invalidJwk();
+    if (size !== undefined && (x.length !== size || y.length !== size)) throw invalidJwk("Invalid JWK EC key");
+    if (!isPublic && !isPrivate) throw noPrivate();
     const point = Buffer.concat([Buffer.from([4]), x, y]);
-    return isPublic ? fromParts("ec", false, key.crv, [point]) : fromParts("ec", true, key.crv, [point, b64(key.d)]);
-  }
-  validateString(key.n, "key.n");
-  validateString(key.e, "key.e");
-  const names = ["n", "e"];
-  if (!isPublic) {
-    for (const name of ["d", "p", "q", "dp", "dq", "qi"]) {
-      validateString(key[name], "key." + name);
-      names.push(name);
-    }
+    return isPrivate ? fromParts("ec", true, key.crv, [point, b64(key.d)]) : fromParts("ec", false, key.crv, [point]);
+  }
+  if (key.kty === "RSA") {
+    const names = ["n", "e"];
+    if (isPrivate) names.push("d", "p", "q", "dp", "dq", "qi");
+    if (!names.every((name) => str(key[name]))) throw invalidJwk("Invalid JWK RSA key");
+    if (!isPublic && !isPrivate) throw noPrivate();
+    return fromParts("rsa", isPrivate, undefined, names.map((name) => b64(key[name])), "Invalid JWK RSA key");
   }
-  return fromParts("rsa", !isPublic, undefined, names.map((name) => b64(key[name])));
+  throw invalidJwk(`${key.kty} is not a supported JWK key type`);
 }
 
 /* ---- createSecretKey, createPublicKey, createPrivateKey ---------------------------------------- */
@@ -405,7 +417,7 @@ const CREATE_PUBLIC = 0, CREATE_PRIVATE = 1, CONSUME_PUBLIC = 2, CONSUME_PRIVATE
 
 /* a KeyObject (or CryptoKey) given where an asymmetric key is wanted */
 function handleOfKeyObject(key, ctx) {
-  if (ctx === CREATE_PRIVATE) throw invalidArgType("key", "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", key);
+  if (ctx === CREATE_PRIVATE) throw invalidArgType("key", "of type string or an instance of ArrayBuffer, Buffer, TypedArray, DataView, or URL", key);
   if (key.type !== "private") {
     if (ctx === CONSUME_PRIVATE || ctx === CREATE_PUBLIC) throw keyObjectType(key.type, "private");
     if (key.type !== "public") throw keyObjectType(key.type, "private or public");
@@ -436,12 +448,13 @@ function prepareAsymmetricKey(key, ctx) {
     if (!isStringOrBuffer(data)) {
       throw invalidArgType("key.key", "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", data);
     }
-    const { format: fmt, type } = parseKeyEncoding(key, undefined, wantPrivate ? false : undefined);
+    const { format: fmt, type } = parseKeyEncoding(key, undefined, wantPrivate ? false : undefined, "key");
     const bytes = typeof data === "string" && fmt === "der" ? Buffer.from(data, encoding ?? "utf8") : data;
     return { key: parseKey(bytes, fmt, type, wantPrivate) };
   }
+  /* Node 24 lists URL where a private key is wanted (an OpenSSL store's; not visaljs's yet) */
   const expected = ctx === CREATE_PRIVATE
-    ? "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView"
+    ? "of type string or an instance of ArrayBuffer, Buffer, TypedArray, DataView, or URL"
     : "of type string or an instance of ArrayBuffer, Buffer, TypedArray, DataView, KeyObject, or CryptoKey";
   throw invalidArgType("key", expected, key);
 }
@@ -518,11 +531,11 @@ function pairEncodings(keyType, options) {
   let pub, priv;
   if (publicKeyEncoding != null) {
     if (typeof publicKeyEncoding !== "object") throw invalidArgValue("options.publicKeyEncoding", "is invalid", publicKeyEncoding);
-    pub = publicKeyEncoding.format === "jwk" ? { format: "jwk" } : parseKeyEncoding(publicKeyEncoding, keyType, true, "publicKeyEncoding");
+    pub = publicKeyEncoding.format === "jwk" ? { format: "jwk" } : parseKeyEncoding(publicKeyEncoding, keyType, true, "options.publicKeyEncoding");
   }
   if (privateKeyEncoding != null) {
     if (typeof privateKeyEncoding !== "object") throw invalidArgValue("options.privateKeyEncoding", "is invalid", privateKeyEncoding);
-    priv = privateKeyEncoding.format === "jwk" ? { format: "jwk" } : parseKeyEncoding(privateKeyEncoding, keyType, false, "privateKeyEncoding");
+    priv = privateKeyEncoding.format === "jwk" ? { format: "jwk" } : parseKeyEncoding(privateKeyEncoding, keyType, false, "options.privateKeyEncoding");
     if (priv.cipher != null) throw notSupported("Encrypting a private key");
   }
   return { pub, priv };

package/node/prelude/internal/crypto/random.js

@@ -1,6 +1,7 @@
-// node:crypto's random numbers (ADR 0018): Node's lib/internal/crypto/random.js over the
+// node:crypto's random numbers: Node's lib/internal/crypto/random.js over the
 // runtime's CSPRNG (an HMAC_DRBG seeded from the system). The asynchronous forms fill at the
 // call and call back from a timer, where Node's thread pool would.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { cryptoHostRandomUUID, cryptoRandomFill } from "visaljs:host";
 import { invalidArgType, outOfRange, validateFunction } from "../errors.js";
 import { isAnyArrayBuffer, isArrayBufferView, validateBoolean, validateNumber, validateObject } from "./util.js";