Merge c888f22cd0 into 0d3d4f5466

Closes https://github.com/denoland/deno/issues/27734

README.md

@@ -6,8 +6,8 @@
 
 <img align="right" src="https://deno.land/logo.svg" height="150px" alt="the deno mascot dinosaur standing in the rain">
 
-[Deno](https://www.deno.com)
-([/ˈdiːnoʊ/](http://ipa-reader.xyz/?text=%CB%88di%CB%90no%CA%8A), pronounced
+[Deno](https://deno.com)
+([/ˈdiːnoʊ/](https://ipa-reader.com/?text=%CB%88di%CB%90no%CA%8A), pronounced
 `dee-no`) is a JavaScript, TypeScript, and WebAssembly runtime with secure
 defaults and a great developer experience. It's built on [V8](https://v8.dev/),
 [Rust](https://www.rust-lang.org/), and [Tokio](https://tokio.rs/).

cli/graph_util.rs

@@ -149,6 +149,51 @@ pub fn graph_walk_errors<'a>(
   roots: &'a [ModuleSpecifier],
   options: GraphWalkErrorsOptions,
 ) -> impl Iterator<Item = JsErrorBox> + 'a {
+  fn should_ignore_resolution_error_for_types(err: &ResolutionError) -> bool {
+    match err {
+      ResolutionError::InvalidSpecifier { .. } => true,
+      ResolutionError::ResolverError { error, .. } => match error.as_ref() {
+        ResolveError::Specifier(_) => true,
+        ResolveError::ImportMap(err) => match err.as_kind() {
+          import_map::ImportMapErrorKind::UnmappedBareSpecifier(_, _) => true,
+          import_map::ImportMapErrorKind::JsonParse(_)
+          | import_map::ImportMapErrorKind::ImportMapNotObject
+          | import_map::ImportMapErrorKind::ImportsFieldNotObject
+          | import_map::ImportMapErrorKind::ScopesFieldNotObject
+          | import_map::ImportMapErrorKind::ScopePrefixNotObject(_)
+          | import_map::ImportMapErrorKind::BlockedByNullEntry(_)
+          | import_map::ImportMapErrorKind::SpecifierResolutionFailure {
+            ..
+          }
+          | import_map::ImportMapErrorKind::SpecifierBacktracksAbovePrefix {
+            ..
+          } => false,
+        },
+        ResolveError::Other(_) => false,
+      },
+      ResolutionError::InvalidDowngrade { .. }
+      | ResolutionError::InvalidJsrHttpsTypesImport { .. }
+      | ResolutionError::InvalidLocalImport { .. } => false,
+    }
+  }
+
+  fn should_ignore_module_graph_error_for_types(
+    err: &ModuleGraphError,
+  ) -> bool {
+    match err {
+      ModuleGraphError::ResolutionError(err) => {
+        should_ignore_resolution_error_for_types(err)
+      }
+      ModuleGraphError::TypesResolutionError(err) => {
+        should_ignore_resolution_error_for_types(err)
+      }
+      ModuleGraphError::ModuleError(module_error) => match module_error {
+        ModuleError::Missing { .. } => true,
+        _ => false,
+      },
+    }
+  }
+
   graph
     .walk(
       roots.iter(),
@@ -190,10 +235,7 @@ pub fn graph_walk_errors<'a>(
 
       if graph.graph_kind().include_types()
         && (message.contains(RUN_WITH_SLOPPY_IMPORTS_MSG)
-          || matches!(
-            error,
-            ModuleGraphError::ModuleError(ModuleError::Missing(..))
-          ))
+          || should_ignore_module_graph_error_for_types(&error))
       {
         // ignore and let typescript surface this as a diagnostic instead
         log::debug!("Ignoring: {}", message);

cli/tools/check.rs

@@ -326,6 +326,9 @@ impl TypeChecker {
       check_mode: type_check_mode,
     })?;
 
+    eprintln!("Ambient modules: {:?}", response.ambient_modules);
+    panic!("STOP"); // prevent saving the type checker cache
+
     let response_diagnostics =
       response.diagnostics.filter(filter_remote_diagnostics);
 

cli/tools/installer.rs

@@ -115,10 +115,16 @@ exec deno {} "$@"
   Ok(())
 }
 
-fn get_installer_root() -> Result<PathBuf, io::Error> {
-  if let Ok(env_dir) = env::var("DENO_INSTALL_ROOT") {
+fn get_installer_root() -> Result<PathBuf, AnyError> {
+  if let Some(env_dir) = env::var_os("DENO_INSTALL_ROOT") {
     if !env_dir.is_empty() {
-      return canonicalize_path_maybe_not_exists(&PathBuf::from(env_dir));
+      let env_dir = PathBuf::from(env_dir);
+      return canonicalize_path_maybe_not_exists(&env_dir).with_context(|| {
+        format!(
+          "Canonicalizing DENO_INSTALL_ROOT ('{}').",
+          env_dir.display()
+        )
+      });
     }
   }
   // Note: on Windows, the $HOME environment variable may be set by users or by
@@ -587,11 +593,22 @@ async fn resolve_shim_data(
     let copy_path = get_hidden_file_with_ext(&file_path, "deno.json");
     executable_args.push("--config".to_string());
     executable_args.push(copy_path.to_str().unwrap().to_string());
-    extra_files.push((
-      copy_path,
-      fs::read_to_string(config_path)
-        .with_context(|| format!("error reading {config_path}"))?,
-    ));
+    let mut config_text = fs::read_to_string(config_path)
+      .with_context(|| format!("error reading {config_path}"))?;
+    // always remove the import map field because when someone specifies `--import-map` we
+    // don't want that file to be attempted to be loaded and when they don't specify that
+    // (which is just something we haven't implemented yet)
+    if let Some(new_text) = remove_import_map_field_from_text(&config_text) {
+      if flags.import_map_path.is_none() {
+        log::warn!(
+          "{} \"importMap\" field in the specified config file we be ignored. Use the --import-map flag instead.",
+          crate::colors::yellow("Warning"),
+        );
+      }
+      config_text = new_text;
+    }
+
+    extra_files.push((copy_path, config_text));
   } else {
     executable_args.push("--no-config".to_string());
   }
@@ -631,6 +648,16 @@ async fn resolve_shim_data(
   })
 }
 
+fn remove_import_map_field_from_text(config_text: &str) -> Option<String> {
+  let value =
+    jsonc_parser::cst::CstRootNode::parse(config_text, &Default::default())
+      .ok()?;
+  let root_value = value.object_value()?;
+  let import_map_value = root_value.get("importMap")?;
+  import_map_value.remove();
+  Some(value.to_string())
+}
+
 fn get_hidden_file_with_ext(file_path: &Path, ext: &str) -> PathBuf {
   // use a dot file to prevent the file from showing up in some
   // users shell auto-complete since this directory is on the PATH
@@ -1585,4 +1612,17 @@ mod tests {
       assert!(!file_path.exists());
     }
   }
+
+  #[test]
+  fn test_remove_import_map_field_from_text() {
+    assert_eq!(
+      remove_import_map_field_from_text(
+        r#"{
+    "importMap": "./value.json"
+}"#,
+      )
+      .unwrap(),
+      "{}"
+    );
+  }
 }

cli/tsc/99_main_compiler.js

@@ -410,6 +410,7 @@ delete Object.prototype.__proto__;
     }
     if (start !== undefined && length !== undefined && file) {
       let startPos = file.getLineAndCharacterOfPosition(start);
+      /** @type {string | undefined} */
       let sourceLine = file.getFullText().split("\n")[startPos.line];
       const originalFileName = file.fileName;
       const fileName = ops.op_remap_specifier
@@ -1109,8 +1110,10 @@ delete Object.prototype.__proto__;
 
     performanceProgram({ program });
 
+    const checker = program.getProgram().getTypeChecker();
     ops.op_respond({
       diagnostics: fromTypeScriptDiagnostics(diagnostics),
+      ambientModules: checker.getAmbientModules().map((symbol) => symbol.name),
       stats: performanceEnd(),
     });
     debug("<<< exec stop");

cli/tsc/mod.rs

@@ -385,6 +385,7 @@ pub struct Response {
   pub diagnostics: Diagnostics,
   /// If there was any build info associated with the exec request.
   pub maybe_tsbuildinfo: Option<String>,
+  pub ambient_modules: Vec<String>,
   /// Statistics from the check.
   pub stats: Stats,
 }
@@ -1047,8 +1048,10 @@ fn op_is_node_file(state: &mut OpState, #[string] path: &str) -> bool {
 }
 
 #[derive(Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
 struct RespondArgs {
   pub diagnostics: Diagnostics,
+  pub ambient_modules: Vec<String>,
   pub stats: Stats,
 }
 
@@ -1163,14 +1166,13 @@ pub fn exec(request: Request) -> Result<Response, ExecError> {
   let state = op_state.take::<State>();
 
   if let Some(response) = state.maybe_response {
-    let diagnostics = response.diagnostics;
     let maybe_tsbuildinfo = state.maybe_tsbuildinfo;
-    let stats = response.stats;
 
     Ok(Response {
-      diagnostics,
+      diagnostics: response.diagnostics,
+      ambient_modules: response.ambient_modules,
       maybe_tsbuildinfo,
-      stats,
+      stats: response.stats,
     })
   } else {
     Err(ExecError::ResponseNotSet)
@@ -1506,6 +1508,7 @@ mod tests {
           reports_unnecessary: None,
           other: Default::default(),
         }]),
+        ambient_modules: vec![],
         stats: Stats(vec![("a".to_string(), 12)])
       })
     );

ext/node/lib.rs

@@ -226,7 +226,6 @@ deno_core::extension!(deno_node,
     ops::crypto::op_node_decipheriv_decrypt,
     ops::crypto::op_node_decipheriv_final,
     ops::crypto::op_node_decipheriv_set_aad,
-    ops::crypto::op_node_decipheriv_take,
     ops::crypto::op_node_dh_compute_secret,
     ops::crypto::op_node_diffie_hellman,
     ops::crypto::op_node_ecdh_compute_public_key,

ext/node/ops/crypto/cipher.rs

@@ -500,6 +500,11 @@ impl Decipher {
     auth_tag: &[u8],
   ) -> Result<(), DecipherError> {
     use Decipher::*;
+
+    if input.is_empty() && !matches!(self, Aes128Gcm(_) | Aes256Gcm(_)) {
+      return Ok(());
+    }
+
     match (self, auto_pad) {
       (Aes128Cbc(decryptor), true) => {
         assert!(input.len() == 16);

ext/node/ops/crypto/mod.rs

@@ -332,17 +332,6 @@ pub fn op_node_decipheriv_decrypt(
   true
 }
 
-#[op2(fast)]
-pub fn op_node_decipheriv_take(
-  state: &mut OpState,
-  #[smi] rid: u32,
-) -> Result<(), cipher::DecipherContextError> {
-  let context = state.resource_table.take::<cipher::DecipherContext>(rid)?;
-  Rc::try_unwrap(context)
-    .map_err(|_| cipher::DecipherContextError::ContextInUse)?;
-  Ok(())
-}
-
 #[op2]
 pub fn op_node_decipheriv_final(
   state: &mut OpState,

ext/node/polyfills/internal/crypto/cipher.ts

@@ -18,7 +18,6 @@ import {
   op_node_decipheriv_decrypt,
   op_node_decipheriv_final,
   op_node_decipheriv_set_aad,
-  op_node_decipheriv_take,
   op_node_private_decrypt,
   op_node_private_encrypt,
   op_node_public_encrypt,
@@ -352,14 +351,6 @@ export class Decipheriv extends Transform implements Cipher {
   }
 
   final(encoding: string = getDefaultEncoding()): Buffer | string {
-    if (!this.#needsBlockCache || this.#cache.cache.byteLength === 0) {
-      op_node_decipheriv_take(this.#context);
-      return encoding === "buffer" ? Buffer.from([]) : "";
-    }
-    if (this.#cache.cache.byteLength != 16) {
-      throw new Error("Invalid final block size");
-    }
-
     let buf = new Buffer(16);
     op_node_decipheriv_final(
       this.#context,
@@ -369,6 +360,13 @@ export class Decipheriv extends Transform implements Cipher {
       this.#authTag || NO_TAG,
     );
 
+    if (!this.#needsBlockCache || this.#cache.cache.byteLength === 0) {
+      return encoding === "buffer" ? Buffer.from([]) : "";
+    }
+    if (this.#cache.cache.byteLength != 16) {
+      throw new Error("Invalid final block size");
+    }
+
     buf = buf.subarray(0, 16 - buf.at(-1)); // Padded in Pkcs7 mode
     return encoding === "buffer" ? buf : buf.toString(encoding);
   }

ext/os/lib.rs

@@ -116,6 +116,12 @@ deno_core::extension!(
     "op_exit" | "op_set_exit_code" | "op_get_exit_code" =>
       op.with_implementation_from(&deno_core::op_void_sync()),
     _ => op,
+  },
+  state = |state| {
+    #[cfg(unix)]
+    {
+      state.put(ops::signal::SignalState::default());
+    }
   }
 );
 

ext/telemetry/lib.rs

@@ -42,6 +42,7 @@ use opentelemetry::metrics::InstrumentBuilder;
 use opentelemetry::metrics::MeterProvider as _;
 use opentelemetry::otel_debug;
 use opentelemetry::otel_error;
+use opentelemetry::trace::Link;
 use opentelemetry::trace::SpanContext;
 use opentelemetry::trace::SpanId;
 use opentelemetry::trace::SpanKind;
@@ -94,6 +95,7 @@ deno_core::extension!(
     op_otel_span_attribute1,
     op_otel_span_attribute2,
     op_otel_span_attribute3,
+    op_otel_span_add_link,
     op_otel_span_update_name,
     op_otel_metric_attribute3,
     op_otel_metric_record0,
@@ -1324,17 +1326,6 @@ impl OtelSpan {
     }
   }
 
-  #[fast]
-  fn drop_link(&self) {
-    let mut state = self.0.borrow_mut();
-    match &mut **state {
-      OtelSpanState::Recording(span) => {
-        span.links.dropped_count += 1;
-      }
-      OtelSpanState::Done(_) => {}
-    }
-  }
-
   #[fast]
   fn end(&self, end_time: f64) {
     let end_time = if end_time.is_nan() {
@@ -1448,6 +1439,48 @@ fn op_otel_span_update_name<'s>(
   }
 }
 
+#[op2(fast)]
+fn op_otel_span_add_link<'s>(
+  scope: &mut v8::HandleScope<'s>,
+  span: v8::Local<'s, v8::Value>,
+  trace_id: v8::Local<'s, v8::Value>,
+  span_id: v8::Local<'s, v8::Value>,
+  #[smi] trace_flags: u8,
+  is_remote: bool,
+  #[smi] dropped_attributes_count: u32,
+) -> bool {
+  let trace_id = parse_trace_id(scope, trace_id);
+  if trace_id == TraceId::INVALID {
+    return false;
+  };
+  let span_id = parse_span_id(scope, span_id);
+  if span_id == SpanId::INVALID {
+    return false;
+  };
+  let span_context = SpanContext::new(
+    trace_id,
+    span_id,
+    TraceFlags::new(trace_flags),
+    is_remote,
+    TraceState::NONE,
+  );
+
+  let Some(span) =
+    deno_core::_ops::try_unwrap_cppgc_object::<OtelSpan>(scope, span)
+  else {
+    return true;
+  };
+  let mut state = span.0.borrow_mut();
+  if let OtelSpanState::Recording(span) = &mut **state {
+    span.links.links.push(Link::new(
+      span_context,
+      vec![],
+      dropped_attributes_count,
+    ));
+  }
+  true
+}
+
 struct OtelMeter(opentelemetry::metrics::Meter);
 
 impl deno_core::GarbageCollected for OtelMeter {}

ext/telemetry/telemetry.ts

@@ -15,6 +15,7 @@ import {
   op_otel_metric_record2,
   op_otel_metric_record3,
   op_otel_metric_wait_to_observe,
+  op_otel_span_add_link,
   op_otel_span_attribute1,
   op_otel_span_attribute2,
   op_otel_span_attribute3,
@@ -186,7 +187,6 @@ interface OtelSpan {
   spanContext(): SpanContext;
   setStatus(status: SpanStatusCode, errorDescription: string): void;
   dropEvent(): void;
-  dropLink(): void;
   end(endTime: number): void;
 }
 
@@ -359,14 +359,24 @@ class Span {
     return this;
   }
 
-  addLink(_link: Link): Span {
-    this.#otelSpan?.dropLink();
+  addLink(link: Link): Span {
+    const droppedAttributeCount = (link.droppedAttributesCount ?? 0) +
+      (link.attributes ? ObjectKeys(link.attributes).length : 0);
+    const valid = op_otel_span_add_link(
+      this.#otelSpan,
+      link.context.traceId,
+      link.context.spanId,
+      link.context.traceFlags,
+      link.context.isRemote ?? false,
+      droppedAttributeCount,
+    );
+    if (!valid) return this;
     return this;
   }
 
   addLinks(links: Link[]): Span {
     for (let i = 0; i < links.length; i++) {
-      this.#otelSpan?.dropLink();
+      this.addLink(links[i]);
     }
     return this;
   }

tests/specs/cli/otel_basic/__test__.jsonc

@@ -22,6 +22,10 @@
       },
       "args": "run -A main.ts metric.ts",
       "output": "metric.out"
+    },
+    "links": {
+      "args": "run -A main.ts links.ts",
+      "output": "links.out"
     }
   }
 }

tests/specs/cli/otel_basic/links.out

@@ -0,0 +1,96 @@
+{
+  "spans": [
+    {
+      "traceId": "00000000000000000000000000000001",
+      "spanId": "0000000000000001",
+      "traceState": "",
+      "parentSpanId": "",
+      "flags": 1,
+      "name": "example span",
+      "kind": 1,
+      "startTimeUnixNano": "[WILDCARD]",
+      "endTimeUnixNano": "[WILDCARD]",
+      "attributes": [],
+      "droppedAttributesCount": 0,
+      "events": [],
+      "droppedEventsCount": 0,
+      "links": [
+        {
+          "traceId": "1234567890abcdef1234567890abcdef",
+          "spanId": "1234567890abcdef",
+          "traceState": "",
+          "attributes": [],
+          "droppedAttributesCount": 0,
+          "flags": 1
+        }
+      ],
+      "droppedLinksCount": 0,
+      "status": {
+        "message": "",
+        "code": 0
+      }
+    },
+    {
+      "traceId": "00000000000000000000000000000002",
+      "spanId": "0000000000000002",
+      "traceState": "",
+      "parentSpanId": "",
+      "flags": 1,
+      "name": "example span",
+      "kind": 1,
+      "startTimeUnixNano": "[WILDCARD]",
+      "endTimeUnixNano": "[WILDCARD]",
+      "attributes": [],
+      "droppedAttributesCount": 0,
+      "events": [],
+      "droppedEventsCount": 0,
+      "links": [
+        {
+          "traceId": "1234567890abcdef1234567890abcdef",
+          "spanId": "1234567890abcdef",
+          "traceState": "",
+          "attributes": [],
+          "droppedAttributesCount": 0,
+          "flags": 1
+        }
+      ],
+      "droppedLinksCount": 0,
+      "status": {
+        "message": "",
+        "code": 0
+      }
+    },
+    {
+      "traceId": "00000000000000000000000000000003",
+      "spanId": "0000000000000003",
+      "traceState": "",
+      "parentSpanId": "",
+      "flags": 1,
+      "name": "example span",
+      "kind": 1,
+      "startTimeUnixNano": "[WILDCARD]",
+      "endTimeUnixNano": "[WILDCARD]",
+      "attributes": [],
+      "droppedAttributesCount": 0,
+      "events": [],
+      "droppedEventsCount": 0,
+      "links": [
+        {
+          "traceId": "1234567890abcdef1234567890abcdef",
+          "spanId": "1234567890abcdef",
+          "traceState": "",
+          "attributes": [],
+          "droppedAttributesCount": 2,
+          "flags": 1
+        }
+      ],
+      "droppedLinksCount": 0,
+      "status": {
+        "message": "",
+        "code": 0
+      }
+    }
+  ],
+  "logs": [],
+  "metrics": []
+}

tests/specs/cli/otel_basic/links.ts

@@ -0,0 +1,40 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+import { trace } from "npm:@opentelemetry/api@1.9.0";
+
+const tracer = trace.getTracer("example-tracer");
+
+const span1 = tracer.startSpan("example span", {
+  links: [{
+    context: {
+      traceId: "1234567890abcdef1234567890abcdef",
+      spanId: "1234567890abcdef",
+      traceFlags: 1,
+    },
+  }],
+});
+span1.end();
+
+const span2 = tracer.startSpan("example span");
+span2.addLink({
+  context: {
+    traceId: "1234567890abcdef1234567890abcdef",
+    spanId: "1234567890abcdef",
+    traceFlags: 1,
+  },
+});
+span2.end();
+
+const span3 = tracer.startSpan("example span");
+span3.addLink({
+  context: {
+    traceId: "1234567890abcdef1234567890abcdef",
+    spanId: "1234567890abcdef",
+    traceFlags: 1,
+  },
+  attributes: {
+    key: "value",
+  },
+  droppedAttributesCount: 1,
+});
+span3.end();

tests/specs/install/global/config_file_import_map/__test__.jsonc

@@ -0,0 +1,5 @@
+{
+  "tempDir": true,
+  "args": "install -g --root ./folder --config deno.json main.ts --name my-cli",
+  "output": "install.out"
+}

tests/specs/install/global/config_file_import_map/deno.json

@@ -0,0 +1,3 @@
+{
+  "importMap": "./import_map.json"
+}

tests/specs/install/global/config_file_import_map/import_map.json

@@ -0,0 +1,2 @@
+{
+}

tests/specs/install/global/config_file_import_map/install.out

@@ -0,0 +1,3 @@
+Warning "importMap" field in the specified config file we be ignored. Use the --import-map flag instead.
+✅ Successfully installed my-cli
+[WILDCARD]

tests/specs/install/global/config_file_import_map/main.ts

@@ -0,0 +1 @@
+console.log(1);

tests/unit_node/crypto/crypto_cipher_gcm_test.ts

@@ -4,7 +4,7 @@ import crypto from "node:crypto";
 import { Buffer } from "node:buffer";
 import testVectors128 from "./gcmEncryptExtIV128.json" with { type: "json" };
 import testVectors256 from "./gcmEncryptExtIV256.json" with { type: "json" };
-import { assertEquals } from "@std/assert";
+import { assertEquals, assertThrows } from "@std/assert";
 
 const aesGcm = (bits: string, key: Uint8Array) => {
   const ALGO = bits == "128" ? `aes-128-gcm` : `aes-256-gcm`;
@@ -123,7 +123,7 @@ Deno.test({
 // Issue #27441
 // https://github.com/denoland/deno/issues/27441
 Deno.test({
-  name: "aes-256-gcm supports IV of non standard length",
+  name: "aes-256-gcm supports IV of non standard length and auth tag check",
   fn() {
     const decipher = crypto.createDecipheriv(
       "aes-256-gcm",
@@ -136,6 +136,10 @@ Deno.test({
       "utf-8",
     );
     assertEquals(decrypted, "this is a secret");
-    decipher.final();
+    assertThrows(
+      () => decipher.final(),
+      TypeError,
+      "Failed to authenticate data",
+    );
   },
 });

tools/release/npm/build.ts

@@ -48,8 +48,8 @@ const packages: Package[] = [{
 
 const markdownText = `# Deno
 
-[Deno](https://www.deno.com)
-([/ˈdiːnoʊ/](http://ipa-reader.xyz/?text=%CB%88di%CB%90no%CA%8A), pronounced
+[Deno](https://deno.com)
+([/ˈdiːnoʊ/](https://ipa-reader.com/?text=%CB%88di%CB%90no%CA%8A), pronounced
 \`dee-no\`) is a JavaScript, TypeScript, and WebAssembly runtime with secure
 defaults and a great developer experience. It's built on [V8](https://v8.dev/),
 [Rust](https://www.rust-lang.org/), and [Tokio](https://tokio.rs/).