docs(rsc): document viteRsc.import API

Add documentation for the new import.meta.viteRsc.import() API in both
README.md and types/index.d.ts with JSDoc, examples, and type signatures.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: hi-ogawa

packages/plugin-rsc/README.md

@@ -245,18 +245,33 @@ ssrModule.renderHTML(...);
 export function renderHTML(...) {}
 ```
 
-#### `import.meta.viteRsc.import(..., { environment: ... })`
+#### `import.meta.viteRsc.import`
 
-TODO
+- Type: `<T>(specifier: string, options: { environment: string }) => Promise<T>`
+
+A more ergonomic alternative to `loadModule`:
+
+1. No manual `rollupOptions.input` config needed - entries are auto-discovered
+2. Specifier matches the path in `typeof import(...)` type annotations
+
+**Comparison:**
 
 ```ts
-const ssrModule = await import.meta.viteRsc.import(
-  "./entry.ssr.tsx",
-  { with: { environment: "ssr" } }
+// Before (loadModule) - requires vite.config.ts:
+// environments.ssr.build.rollupOptions.input = { index: './entry.ssr.tsx' }
+import.meta.viteRsc.loadModule<typeof import('./entry.ssr.tsx')>('ssr', 'index')
+
+// After (import) - no config needed, auto-discovered
+import.meta.viteRsc.import<typeof import('./entry.ssr.tsx')>(
+  './entry.ssr.tsx',
+  { environment: 'ssr' },
 )
-ssrModule.renderHTML(...);
 ```
 
+During development, this works the same as `loadModule`, using the `__VITE_ENVIRONMENT_RUNNER_IMPORT__` function to import modules in the target environment.
+
+During production build, the plugin auto-discovers these imports and emits them as entries in the target environment. A manifest file (`__vite_rsc_env_imports_manifest.js`) is generated to map module specifiers to their output filenames.
+
 ### Available on `rsc` environment
 
 #### `import.meta.viteRsc.loadCss`

packages/plugin-rsc/types/index.d.ts

@@ -5,10 +5,28 @@ declare global {
       loadModule: <T>(environmentName: string, entryName?: string) => Promise<T>
       loadBootstrapScriptContent: (entryName: string) => Promise<string>
       /**
-       * TODO: jsdoc
-       * @experimental
+       * Import a module from another environment using a module specifier.
+       *
+       * A more ergonomic alternative to `loadModule` that takes a relative path
+       * instead of an entry name, so the specifier matches what you'd use in
+       * `typeof import(...)` type annotations.
+       *
+       * @example
+       * ```ts
+       * const ssr = await import.meta.viteRsc.import<typeof import('./entry.ssr')>(
+       *   './entry.ssr',
+       *   { environment: 'ssr' }
+       * );
+       * ```
+       *
+       * @param specifier - Relative path to the module (e.g., './entry.ssr')
+       * @param options - Options object with `environment` specifying the target environment
+       * @returns Promise resolving to the module exports
        */
-      import: <T>(specifier, attributes: { environment: string }) => Promise<T>
+      import: <T>(
+        specifier: string,
+        options: { environment: string },
+      ) => Promise<T>
     }
   }