Implement text and bytes typed module imports

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ssrlive

ci/feature_probes/import-bytes-target.bin

@@ -0,0 +1 @@
+ABC

ci/feature_probes/import-bytes.js

@@ -0,0 +1,17 @@
+// module
+
+import("./import-bytes-target.bin", { with: { type: "bytes" } }).then(function(mod) {
+  var value = mod && mod.default;
+  if (
+    value instanceof Uint8Array &&
+    value.buffer instanceof ArrayBuffer &&
+    value.buffer.immutable === true &&
+    value.length === 4 &&
+    value[0] === 65 &&
+    value[1] === 66 &&
+    value[2] === 67 &&
+    value[3] === 10
+  ) {
+    console.log("OK");
+  }
+}).catch(function() {});

ci/feature_probes/import-text-target.txt

@@ -0,0 +1 @@
+hello from text

ci/feature_probes/import-text.js

@@ -0,0 +1,7 @@
+// module
+
+import("./import-text-target.txt", { with: { type: "text" } }).then(function(mod) {
+  if (mod && mod.default === "hello from text\n") {
+    console.log("OK");
+  }
+}).catch(function() {});

src/core/compiler.rs

@@ -725,7 +725,10 @@ impl<'gc> Compiler<'gc> {
     }
 
     /// Check if an import source refers to the current module (self-import)
-    fn is_self_import(&self, source: &str) -> bool {
+    fn is_self_import(&self, source: &str, import_type: Option<&str>) -> bool {
+        if import_type.is_some() {
+            return false;
+        }
         if let Some(ref fname) = self.script_filename {
             let import_base = source.strip_prefix("./").unwrap_or(source);
             let self_base = std::path::Path::new(fname).file_name().and_then(|n| n.to_str()).unwrap_or("");
@@ -736,11 +739,10 @@ impl<'gc> Compiler<'gc> {
     }
 
     /// Resolve an import specifier to a loaded module path, if available.
-    fn resolve_import_path(&self, source: &str) -> Option<String> {
+    fn resolve_import_path(&self, source: &str, import_type: Option<&str>) -> Option<String> {
         if let Some(ref fname) = self.script_filename {
             let base_path = std::path::Path::new(fname);
-            let resolved = crate::core::resolve_module_path(source, base_path);
-            let resolved_str = resolved.to_string_lossy().to_string();
+            let resolved_str = crate::core::resolve_module_request_key(source, base_path, import_type);
             if self.loaded_module_exports.contains_key(&resolved_str) {
                 Some(resolved_str)
             } else {
@@ -834,7 +836,7 @@ impl<'gc> Compiler<'gc> {
         let mut reexport_map: std::collections::HashMap<String, (String, String)> = std::collections::HashMap::new();
         for stmt in statements {
             if let StatementKind::Export(specs, _, Some(source)) = &*stmt.kind {
-                if self.is_self_import(source) {
+                if self.is_self_import(source, None) {
                     continue; // Skip self-re-exports
                 }
                 for spec in specs {
@@ -848,7 +850,7 @@ impl<'gc> Compiler<'gc> {
                         }
                         crate::core::statement::ExportSpecifier::Star => {
                             // export * from "module" — expand all exports (except default)
-                            if let Some(resolved) = self.resolve_import_path(source)
+                            if let Some(resolved) = self.resolve_import_path(source, None)
                                 && let Some(exports) = self.loaded_module_exports.get(&resolved)
                             {
                                 for export_name in exports.keys() {
@@ -868,16 +870,16 @@ impl<'gc> Compiler<'gc> {
         }
 
         for stmt in statements {
-            if let StatementKind::Import(specifiers, source) = &*stmt.kind
-                && self.is_self_import(source)
+            if let StatementKind::Import(specifiers, source, import_type) = &*stmt.kind
+                && self.is_self_import(source, import_type.as_deref())
             {
                 for spec in specifiers {
                     match spec {
                         ImportSpecifier::Named(name, alias) => {
                             let local = alias.as_deref().unwrap_or(name).to_string();
                             // Check if this is a re-export → redirect to loaded module
                             if let Some((re_src, orig_name)) = reexport_map.get(name)
-                                && let Some(resolved) = self.resolve_import_path(re_src)
+                                && let Some(resolved) = self.resolve_import_path(re_src, None)
                             {
                                 self.chunk.loaded_module_vars.insert(local.clone(), (resolved, orig_name.clone()));
                                 self.chunk.const_import_bindings.insert(local);
@@ -892,7 +894,7 @@ impl<'gc> Compiler<'gc> {
                         ImportSpecifier::Default(local) => {
                             // Check if default is a re-export
                             if let Some((re_src, orig_name)) = reexport_map.get("default")
-                                && let Some(resolved) = self.resolve_import_path(re_src)
+                                && let Some(resolved) = self.resolve_import_path(re_src, None)
                             {
                                 self.chunk.loaded_module_vars.insert(local.clone(), (resolved, orig_name.clone()));
                                 self.chunk.const_import_bindings.insert(local.clone());
@@ -922,7 +924,7 @@ impl<'gc> Compiler<'gc> {
 
                             // Include re-exported names in the namespace
                             for (export_name, (re_src, orig_name)) in &reexport_map {
-                                if let Some(resolved) = self.resolve_import_path(re_src) {
+                                if let Some(resolved) = self.resolve_import_path(re_src, None) {
                                     let ns_reexport_key = format!("__ns_reexport_{}_{}", local, export_name);
                                     self.chunk
                                         .loaded_module_vars
@@ -954,7 +956,7 @@ impl<'gc> Compiler<'gc> {
                                 .collect();
 
                             for (export_name, (re_src, orig_name)) in &reexport_map {
-                                if let Some(resolved) = self.resolve_import_path(re_src) {
+                                if let Some(resolved) = self.resolve_import_path(re_src, None) {
                                     let ns_reexport_key = format!("__ns_reexport_{}_{}", local, export_name);
                                     self.chunk
                                         .loaded_module_vars
@@ -4379,7 +4381,7 @@ impl<'gc> Compiler<'gc> {
                     self.chunk.write_u16(idx);
                 }
             }
-            StatementKind::Import(specifiers, source) => {
+            StatementKind::Import(specifiers, source, import_type) => {
                 let define_binding = |this: &mut Self, local_name: &str| {
                     this.emit_define_var(local_name);
                 };
@@ -4417,7 +4419,7 @@ impl<'gc> Compiler<'gc> {
 
                 for spec in specifiers {
                     // Check for self-import first
-                    if self.is_self_import(source) {
+                    if self.is_self_import(source, import_type.as_deref()) {
                         match spec {
                             ImportSpecifier::Named(name, alias) => {
                                 let local = alias.as_deref().unwrap_or(name).to_string();
@@ -4585,7 +4587,7 @@ impl<'gc> Compiler<'gc> {
                             define_binding(self, local);
                         }
                         (_, ImportSpecifier::Namespace(local)) => {
-                            if let Some(resolved_str) = self.resolve_import_path(source) {
+                            if let Some(resolved_str) = self.resolve_import_path(source, import_type.as_deref()) {
                                 // Resolved from loaded module — value injected at runtime.
                                 // Still emit placeholder + define to keep stack balanced.
                                 self.chunk.write_opcode(Opcode::NewObject);
@@ -4600,7 +4602,7 @@ impl<'gc> Compiler<'gc> {
                             define_binding(self, local);
                         }
                         (_, ImportSpecifier::DeferredNamespace(local)) => {
-                            if let Some(resolved_str) = self.resolve_import_path(source) {
+                            if let Some(resolved_str) = self.resolve_import_path(source, import_type.as_deref()) {
                                 self.chunk.write_opcode(Opcode::NewObject);
                                 self.chunk.write_byte(0);
                                 self.chunk
@@ -4614,7 +4616,7 @@ impl<'gc> Compiler<'gc> {
                             define_binding(self, local);
                         }
                         (_, ImportSpecifier::Default(local)) => {
-                            let resolved = self.resolve_import_path(source);
+                            let resolved = self.resolve_import_path(source, import_type.as_deref());
                             if let Some(resolved_str) = resolved {
                                 // Resolved from loaded module — value injected at runtime.
                                 let idx = self.chunk.add_constant(Value::Undefined);
@@ -4633,7 +4635,7 @@ impl<'gc> Compiler<'gc> {
                         }
                         (_, ImportSpecifier::Named(name, alias)) => {
                             let local = alias.as_deref().unwrap_or(name).to_string();
-                            let resolved = self.resolve_import_path(source);
+                            let resolved = self.resolve_import_path(source, import_type.as_deref());
                             if let Some(resolved_str) = resolved {
                                 // Resolved from loaded module — value injected at runtime.
                                 let idx = self.chunk.add_constant(Value::Undefined);

src/core/mod.rs

@@ -169,6 +169,7 @@ pub(crate) enum ModuleRequestPhase {
 pub(crate) struct ModuleRequest {
     pub specifier: String,
     pub phase: ModuleRequestPhase,
+    pub import_type: Option<String>,
 }
 
 /// Resolve a module specifier relative to a base path.
@@ -184,6 +185,19 @@ pub(crate) fn resolve_module_path(specifier: &str, base_path: &std::path::Path)
     spec_path.to_path_buf()
 }
 
+pub(crate) fn module_request_key_from_resolved_path(resolved_path: &std::path::Path, import_type: Option<&str>) -> String {
+    let resolved = resolved_path.to_string_lossy().to_string();
+    match import_type {
+        Some(import_type) => format!("{resolved}\0{import_type}"),
+        None => resolved,
+    }
+}
+
+pub(crate) fn resolve_module_request_key(specifier: &str, base_path: &std::path::Path, import_type: Option<&str>) -> String {
+    let resolved_path = resolve_module_path(specifier, base_path);
+    module_request_key_from_resolved_path(&resolved_path, import_type)
+}
+
 /// Remove `.` and resolve `..` components from a path without touching the filesystem.
 fn normalize_path(path: &std::path::Path) -> std::path::PathBuf {
     let mut result = std::path::PathBuf::new();
@@ -2367,7 +2381,7 @@ fn collect_module_declared_names(statements: &[Statement], names: &mut std::coll
                     names.insert(def.name.clone());
                 }
             }
-            SK::Import(specs, _) => {
+            SK::Import(specs, _, _) => {
                 for spec in specs {
                     match spec {
                         crate::core::statement::ImportSpecifier::Default(n) => {
@@ -2570,9 +2584,9 @@ pub(crate) fn collect_module_sources(statements: &[Statement], self_basename: &s
 
     for stmt in statements {
         match &*stmt.kind {
-            StatementKind::Import(_, source) => {
+            StatementKind::Import(_, source, import_type) => {
                 let import_base = source.strip_prefix("./").unwrap_or(source);
-                if import_base == self_basename {
+                if import_type.is_none() && import_base == self_basename {
                     continue;
                 }
                 if known_builtins.contains(&source.as_str()) {
@@ -2604,29 +2618,30 @@ pub(crate) fn collect_module_requests(statements: &[Statement], self_basename: &
 
     for stmt in statements {
         let maybe_request = match &*stmt.kind {
-            StatementKind::Import(specifiers, source) => {
+            StatementKind::Import(specifiers, source, import_type) => {
                 let phase = if specifiers.iter().any(|spec| matches!(spec, ImportSpecifier::DeferredNamespace(_))) {
                     ModuleRequestPhase::Defer
                 } else {
                     ModuleRequestPhase::Evaluation
                 };
-                Some((source, phase))
+                Some((source, phase, import_type))
             }
-            StatementKind::Export(_specs, _, Some(source)) => Some((source, ModuleRequestPhase::Evaluation)),
+            StatementKind::Export(_specs, _, Some(source)) => Some((source, ModuleRequestPhase::Evaluation, &None)),
             _ => None,
         };
 
-        let Some((source, phase)) = maybe_request else {
+        let Some((source, phase, import_type)) = maybe_request else {
             continue;
         };
         let import_base = source.strip_prefix("./").unwrap_or(source);
-        if import_base == self_basename || known_builtins.contains(&source.as_str()) {
+        if (import_type.is_none() && import_base == self_basename) || known_builtins.contains(&source.as_str()) {
             continue;
         }
-        if seen.insert((source.clone(), phase)) {
+        if seen.insert((source.clone(), phase, import_type.clone())) {
             requests.push(ModuleRequest {
                 specifier: source.clone(),
                 phase,
+                import_type: import_type.clone(),
             });
         }
     }

src/core/parser.rs

@@ -2683,7 +2683,7 @@ fn parse_import_statement(t: &[TokenData], index: &mut usize) -> Result<Statemen
             }
         }
     }
-    consume_import_attributes_clause(t, index)?;
+    let import_type = consume_import_attributes_clause(t, index)?;
     if *index < t.len() && matches!(t[*index].token, Token::Semicolon) {
         *index += 1;
     }
@@ -2716,19 +2716,19 @@ fn parse_import_statement(t: &[TokenData], index: &mut usize) -> Result<Statemen
         }
     }
     Ok(Statement {
-        kind: Box::new(StatementKind::Import(specifiers, source)),
+        kind: Box::new(StatementKind::Import(specifiers, source, import_type)),
         line: t[start].line,
         column: t[start].column,
     })
 }
-fn consume_import_attributes_clause(t: &[TokenData], index: &mut usize) -> Result<(), JSError> {
+fn consume_import_attributes_clause(t: &[TokenData], index: &mut usize) -> Result<Option<String>, JSError> {
     if *index >= t.len() {
-        return Ok(());
+        return Ok(None);
     }
     let is_with_clause = (matches!(t[*index].token, Token::With) || matches!(&t[*index].token, Token::Identifier(s) if s == "with"))
         && !raw_identifier_source_has_escape(&t[*index]);
     if !is_with_clause {
-        return Ok(());
+        return Ok(None);
     }
     *index += 1;
     while *index < t.len() && matches!(t[*index].token, Token::LineTerminator) {
@@ -2739,6 +2739,7 @@ fn consume_import_attributes_clause(t: &[TokenData], index: &mut usize) -> Resul
     }
     *index += 1; // skip '{'
     let mut seen_keys: Vec<String> = Vec::new();
+    let mut import_type = None;
     loop {
         while *index < t.len() && matches!(t[*index].token, Token::LineTerminator) {
             *index += 1;
@@ -2748,7 +2749,7 @@ fn consume_import_attributes_clause(t: &[TokenData], index: &mut usize) -> Resul
         }
         if matches!(t[*index].token, Token::RBrace) {
             *index += 1;
-            return Ok(());
+            return Ok(import_type);
         }
         // Parse attribute key: IdentifierName or StringLiteral
         let key = match &t[*index].token {
@@ -2774,7 +2775,7 @@ fn consume_import_attributes_clause(t: &[TokenData], index: &mut usize) -> Resul
         if seen_keys.contains(&key) {
             return Err(raise_syntax_error!(format!("Duplicate import attribute key '{}'", key)));
         }
-        seen_keys.push(key);
+        seen_keys.push(key.clone());
         while *index < t.len() && matches!(t[*index].token, Token::LineTerminator) {
             *index += 1;
         }
@@ -2790,6 +2791,14 @@ fn consume_import_attributes_clause(t: &[TokenData], index: &mut usize) -> Resul
         if *index >= t.len() || !matches!(t[*index].token, Token::StringLit(_)) {
             return Err(raise_parse_error!("Import attribute value must be a string"));
         }
+        let value = if let Token::StringLit(s) = &t[*index].token {
+            utf16_to_utf8(s)
+        } else {
+            unreachable!()
+        };
+        if key == "type" {
+            import_type = Some(value);
+        }
         *index += 1;
         while *index < t.len() && matches!(t[*index].token, Token::LineTerminator) {
             *index += 1;
@@ -2953,7 +2962,7 @@ fn parse_export_statement(t: &[TokenData], index: &mut usize) -> Result<Statemen
                 }
             }
         }
-        consume_import_attributes_clause(t, index)?;
+        let _ = consume_import_attributes_clause(t, index)?;
         finish_statement_without_semicolon(t, index)?;
     } else if *index < t.len() && matches!(t[*index].token, Token::LBrace) {
         *index += 1;
@@ -3036,7 +3045,7 @@ fn parse_export_statement(t: &[TokenData], index: &mut usize) -> Result<Statemen
                 "A string literal cannot be used as an exported binding without `from`"
             ));
         }
-        consume_import_attributes_clause(t, index)?;
+        let _ = consume_import_attributes_clause(t, index)?;
         finish_statement_without_semicolon(t, index)?;
     } else {
         let stmt = match t[*index].token {

src/core/statement.rs

@@ -49,10 +49,10 @@ pub enum StatementKind {
     Continue(Option<String>),
     Debugger,
     Label(String, Box<Statement>),
-    Import(Vec<ImportSpecifier>, String), // import specifiers, module name
+    Import(Vec<ImportSpecifier>, String, Option<String>), // import specifiers, module name, optional import type
     Export(Vec<ExportSpecifier>, Option<Box<Statement>>, Option<String>), // export specifiers, optional inner declaration, optional source
-    Using(Vec<(String, Expr)>),           // using declarations: using x = expr, y = expr;
-    AwaitUsing(Vec<(String, Expr)>),      // await using declarations: await using x = expr;
+    Using(Vec<(String, Expr)>),                           // using declarations: using x = expr, y = expr;
+    AwaitUsing(Vec<(String, Expr)>),                      // await using declarations: await using x = expr;
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]