@@ -122,21 +122,13 @@ pub struct Opts {
     #[cfg_attr(feature = "clap", clap(long))]
     pub generate_stubs: bool,
 
-    /// If specified, organize the bindings into a package for use as a library;
-    /// otherwise (if `None`), the bindings will be organized for use as a
-    /// standalone executable.
+    /// If set, organize the bindings as a library package: `imports` and
+    /// `exports` (if stubs are generated) each get their own directory named
+    /// after them. If `None`, organize the bindings for a standalone executable
+    /// instead.
     #[cfg_attr(feature = "clap", clap(long))]
     pub pkg_name: Option<String>,
 
-    /// When `--pkg-name` is specified, optionally specify a different package
-    /// for exports.
-    ///
-    /// This allows you to put the exports and imports in separate packages when
-    /// building a library.  If only `--pkg-name` is specified, this will
-    /// default to that value.
-    #[cfg_attr(feature = "clap", clap(long, requires = "pkg_name"))]
-    pub export_pkg_name: Option<String>,
-
     /// Print the version of the remote package being used for the shared WIT types.
     ///
     /// Must be specified in addition to the `pkg-name` flag.
@@ -248,11 +240,15 @@ struct Go {
 impl Go {
     /// Adds the bindings module prefix to a package name.
     fn mod_pkg(&self, for_export: bool, name: &str) -> String {
-        let prefix = for_export
-            .then_some(())
-            .and(self.opts.export_pkg_name.as_deref())
-            .or(self.opts.pkg_name.as_deref())
-            .unwrap_or("wit_component");
+        let prefix = if let Some(pkg) = self.opts.pkg_name.as_ref() {
+            if for_export {
+                format!("{pkg}/exports")
+            } else {
+                format!("{pkg}/imports")
+            }
+        } else {
+            "wit_component".to_string()
+        };
         format!(r#""{prefix}/{name}""#)
     }
 
@@ -951,7 +947,7 @@ impl WorldGenerator for Go {
                 println!("{}", remote_pkg_version());
             }
             // If a module name is specified, the generated files will be used as a library.
-            ("wit_exports/wit_exports.go", "wit_exports", "")
+            ("exports/wit_exports/wit_exports.go", "wit_exports", "")
         } else {
             files.push(
                 "go.mod",
@@ -980,7 +976,7 @@ func main() {}
         };
 
         files.push(
-            exports_file_path,
+            &exports_file_path,
             &maybe_gofmt(
                 self.opts.format,
                 format!(
@@ -1005,14 +1001,23 @@ var {SYNC_EXPORT_PINNER} = runtime.Pinner{{}}
             ),
         );
 
-        for (prefix, interfaces) in [("export_", &self.export_interfaces), ("", &self.interfaces)] {
+        let (import_path_prefix, export_path_prefix) = if self.opts.pkg_name.is_some() {
+            ("imports/", "exports/")
+        } else {
+            ("", "")
+        };
+
+        for (prefix, interfaces, path_prefix) in [
+            ("export_", &self.export_interfaces, export_path_prefix),
+            ("", &self.interfaces, import_path_prefix),
+        ] {
             for (name, data) in interfaces {
                 let imports = data.imports();
                 let code = &data.code;
                 let header = if data.has_stubs { stub_header } else { header };
 
                 files.push(
-                    &format!("{prefix}{name}/wit_bindings.go"),
+                    &format!("{path_prefix}{prefix}{name}/wit_bindings.go"),
                     &maybe_gofmt(
                         self.opts.format,
                         format!(
@@ -1030,7 +1035,7 @@ import (
                 );
 
                 files.push(
-                    &format!("{prefix}{name}/empty.s"),
+                    &format!("{path_prefix}{prefix}{name}/empty.s"),
                     r#"// This file exists for testing this package without WebAssembly,
 // allowing empty function bodies with a //go:wasmimport directive.
 // See https://pkg.go.dev/cmd/compile for more information."#
 
@@ -37,16 +37,24 @@ impl LanguageMethods for Go {
         runner: &Runner,
         name: &str,
         config: &crate::config::WitConfig,
-        _args: &[String],
+        args: &[String],
     ) -> bool {
         if config.error_context {
             return true;
         }
-        if name == "named-fixed-length-list.wit" {
+        if name.starts_with("named-fixed-length-list.wit") {
             return true;
         }
         if !runner.go_async_supported() {
-            return name == "async-trait-function.wit" || name == "issue-1598.wit";
+            // The `--pkg-name` (library) verify path runs `go build ./...`
+            // with no link step, so the missing `runtime.wasiOnIdle` symbol
+            // never causes a failure and these tests compile fine even on an
+            // unpatched toolchain. Only the c-shared (non-pkg) path fails.
+            let pkg_mode = args.iter().any(|a| a == "--pkg-name");
+            if !pkg_mode {
+                return name.starts_with("async-trait-function.wit")
+                    || name.starts_with("issue-1598.wit");
+            }
         }
 
         false
@@ -77,6 +85,15 @@ impl LanguageMethods for Go {
         &["--generate-stubs"]
     }
 
+    fn codegen_test_variants(&self) -> &[(&str, &[&str])] {
+        // Also run every codegen fixture through the `--pkg` library layout
+        // (imports/, exports/ subdirectories). `wit_component` matches the
+        // module name written by `replace_bindings_go_mod`, so the generated
+        // `wit_component/imports/...` and `wit_component/exports/...` import
+        // paths resolve against that go.mod.
+        &[("pkg-name", &["--pkg-name", "wit_component"])]
+    }
+
     fn prepare(&self, runner: &mut Runner) -> Result<()> {
         let cwd = env::current_dir()?;
         let dir = cwd.join(&runner.opts.artifacts).join("go");
@@ -189,18 +206,24 @@ func main() {}
                 .arg("./..."),
         )?;
 
-        // `go build`
-        runner.run_command(
-            Command::new("go")
-                .current_dir(verify.bindings_dir)
-                .env("GOOS", "wasip1")
-                .env("GOARCH", "wasm")
-                .arg("build")
-                .arg("-o")
+        // `go build`. In `--pkg` (library) mode there is no main package in the
+        // bindings root, so `-buildmode=c-shared` on the current directory fails.
+        // Instead compile every subpackage with `./...`.
+        let pkg_mode = verify.args.iter().any(|a| a == "--pkg-name");
+        let mut cmd = Command::new("go");
+        cmd.current_dir(verify.bindings_dir)
+            .env("GOOS", "wasip1")
+            .env("GOARCH", "wasm")
+            .arg("build");
+        if pkg_mode {
+            cmd.arg("./...");
+        } else {
+            cmd.arg("-o")
                 .arg(verify.artifacts_dir.join("tmp.wasm"))
                 .arg("-buildmode=c-shared")
-                .arg("-ldflags=-checklinkname=0"),
-        )?;
+                .arg("-ldflags=-checklinkname=0");
+        }
+        runner.run_command(&mut cmd)?;
         Ok(())
     }
 }