docs: Update to recommend workspace + deno.jsonc for dependency management

This commit restructures the documentation to present dependency management
more appropriately:

Key changes:
- Keep Getting Started simple with direct URL imports
- Add note in Getting Started pointing to tutorials for import maps
- Create new tutorial section "Managing Dependencies" explaining import maps
- Move all detailed import map explanations to the tutorial
- Revert Hello World tutorial to use direct URL imports
- Keep Maze tutorial using import maps as an advanced example

Structure improvements:
- Getting Started: Simple direct imports for beginners
- Tutorial: Dedicated section explaining the recommended approach
- Clear progression from simple to advanced patterns

The documentation now properly guides users:
1. Start simple with direct URL imports
2. Learn about import maps in the dedicated tutorial section
3. Apply import maps in real projects (Maze tutorial)

Technical notes:
- Import map features require Denops v8.0.0+
- Use @denops/std@^8.0.0 in import map examples
- Use @denops/std@^7.0.0 in direct import examples

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: lambdalisue

src/SUMMARY.md

@@ -10,6 +10,7 @@
   - [Creating a minimal Denops plugin](./tutorial/helloworld/creating-a-minimal-denops-plugin.md)
   - [Adding Denops APIs](./tutorial/helloworld/adding-an-api.md)
   - [Calling Vim features](./tutorial/helloworld/calling-vim-features.md)
+  - [Managing dependencies](./tutorial/helloworld/managing-dependencies.md)
 - [Tutorial (Maze)](./tutorial/maze/README.md)
   - [Utilizing third-party library](./tutorial/maze/utilizing-third-party-library.md)
   - [Outputting content to buffer](./tutorial/maze/outputting-content-to-buffer.md)

src/getting-started/README.md

@@ -33,6 +33,12 @@ export const main: Entrypoint = (denops) => {
 };
 ```
 
+> [!NOTE]
+>
+> This example uses direct URL imports for simplicity. The recommended approach
+> for managing dependencies is to use `deno.jsonc` with import maps, which
+> you'll learn about in the [tutorials](../tutorial.md).
+
 ## Activate the Plugin
 
 Add the following line to your Vim or Neovim configuration file (e.g.,

src/introduction.md

@@ -18,9 +18,10 @@ features:
 - **Unified codebase for Vim and Neovim**:<br>Denops provides a unified API for
   both Vim and Neovim. You can write a plugin that functions on both Vim and
   Neovim with a single codebase.
-- **No worries about dependency management**:<br>Deno includes a built-in
-  dependency management system, allowing developers to write plugins with
-  third-party libraries without concerns about dependency management.
+- **Modern dependency management**:<br>Deno's built-in dependency system with
+  import maps provides clean, maintainable dependency management. The workspace
+  configuration ensures each plugin's dependencies are isolated, preventing
+  conflicts when multiple Denops plugins are installed together.
 - **Simple and efficient code**:<br>Deno utilizes the V8 engine, significantly
   faster than Vim script. You can write a plugin with straightforward code,
   without the need for complex optimizations solely for performance.

src/tutorial/helloworld/calling-vim-features.md

@@ -57,8 +57,11 @@ as a result.
 
 ## Next Steps
 
-In the next step, follow the tutorial to learn how to develop a real Denops
-plugin.
+Learn about managing dependencies with import maps for cleaner code:
+
+- [Managing dependencies](./managing-dependencies.md)
+
+Or jump to the maze tutorial to learn more advanced concepts:
 
 - [Tutorial (Maze)](../../tutorial/maze/index.html)
 - [API reference](https://jsr.io/@denops/std)

src/tutorial/helloworld/managing-dependencies.md

@@ -0,0 +1,126 @@
+# Managing Dependencies with Import Maps
+
+In the previous examples, we used direct URL imports like
+`jsr:@denops/std@^7.0.0`. While this works, the recommended approach for Denops
+plugins (v8.0.0+) is to use import maps with `deno.jsonc` for cleaner and more
+maintainable dependency management.
+
+## Why Use Import Maps?
+
+When Vim/Neovim loads plugins, all plugin directories are merged into a single
+runtime path. This creates a challenge:
+
+```
+# Multiple plugins installed:
+~/.vim/pack/plugins/start/plugin-a/
+~/.vim/pack/plugins/start/plugin-b/
+
+# Merged runtime view:
+plugin/         # Files from both plugins
+denops/         # Unique subdirectories preserved
+├── plugin-a/
+└── plugin-b/
+```
+
+If we put configuration files in the root directory, they would conflict. That's
+why we place `deno.jsonc` inside each plugin's unique `denops/` subdirectory.
+
+## Setting Up Your Plugin Structure
+
+Update your `denops-helloworld` structure to include configuration files:
+
+```
+denops-helloworld/
+├── deno.jsonc                    # Development configuration
+├── denops/
+│   └── denops-helloworld/
+│       ├── deno.jsonc           # Runtime dependencies
+│       └── main.ts
+└── plugin/
+    └── denops-helloworld.vim
+```
+
+### Root deno.jsonc (Development)
+
+Create a `deno.jsonc` in your repository root for development tools:
+
+```json
+{
+  "workspace": [
+    "./denops/denops-helloworld"
+  ],
+  // Optional: Development tool configuration
+  "fmt": {
+    "indentWidth": 2,
+    "lineWidth": 80
+  },
+  "lint": {
+    "rules": {
+      "tags": ["recommended"]
+    }
+  }
+}
+```
+
+This enables commands like `deno fmt`, `deno lint`, and `deno test` to work from
+your project root.
+
+### Plugin deno.jsonc (Runtime)
+
+Create `denops/denops-helloworld/deno.jsonc` for runtime dependencies:
+
+```json
+{
+  "imports": {
+    "@denops/std": "jsr:@denops/std@^8.0.0",
+    "@core/unknownutil": "jsr:@core/unknownutil@^4.3.0"
+  }
+}
+```
+
+## Updating Your Code
+
+With import maps configured, update your imports from:
+
+```typescript
+import type { Entrypoint } from "jsr:@denops/std@^8.0.0";
+import { assert, is } from "jsr:@core/unknownutil@^4.3.0";
+```
+
+To cleaner versions:
+
+```typescript
+import type { Entrypoint } from "@denops/std";
+import { assert, is } from "@core/unknownutil";
+```
+
+## Alternative: import_map.json
+
+Denops also supports `import_map.json(c)` files, but they require more verbose
+configuration:
+
+```json
+// denops/denops-helloworld/import_map.json
+{
+  "imports": {
+    "@denops/std": "jsr:@denops/std@^8.0.0",
+    "@denops/std/": "jsr:@denops/std@^8.0.0/" // Required for submodules
+  }
+}
+```
+
+We recommend using `deno.jsonc` as it's less verbose and integrates better with
+Deno tooling.
+
+> [!IMPORTANT]
+>
+> Import map features require Denops v8.0.0 or later. For older versions,
+> continue using direct URL imports.
+
+## Benefits
+
+1. **Cleaner imports**: No more long URLs in your code
+2. **Version management**: Update dependencies in one place
+3. **Better IDE support**: Auto-completion and type checking work seamlessly
+4. **No conflicts**: Each plugin manages its own dependencies
+5. **Development tools**: Format and lint your code from the project root

src/tutorial/maze/adjusting-maze-size-to-fit-the-window.md

@@ -8,9 +8,9 @@ Let's modify the plugin to ensure the generated maze fits the current window
 size.
 
 ```typescript,title=denops/denops-helloworld/main.ts
-import type { Entrypoint } from "jsr:@denops/std@^7.0.0";
-import * as fn from "jsr:@denops/std@^7.0.0/function";
-import { Maze } from "npm:@thewizardbear/maze_generator@^0.4.0";
+import type { Entrypoint } from "@denops/std";
+import * as fn from "@denops/std/function";
+import { Maze } from "maze_generator";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {

src/tutorial/maze/creating-applicative-plugin.md

@@ -28,17 +28,31 @@ augroup denops_maze
 augroup END
 ```
 
-Then, modify the `main.ts` file to accept the optional argument for a custom
+Then, update your `denops/denops-maze/deno.jsonc` to include the unknownutil
+dependency:
+
+```json,title=denops/denops-maze/deno.jsonc
+{
+  "imports": {
+    "@denops/std": "jsr:@denops/std@^8.0.0",
+    "@denops/std/": "jsr:@denops/std@^8.0.0/",
+    "@core/unknownutil": "jsr:@core/unknownutil@^4.3.0",
+    "maze_generator": "npm:@thewizardbear/maze_generator@^0.4.0"
+  }
+}
+```
+
+Now modify the `main.ts` file to accept the optional argument for a custom
 opener, generate a maze that fits the current window size, configure the buffer
 options to make it non-file readonly buffer, etc.
 
 ```typescript,title=denops/denops-maze/main.ts
-import type { Entrypoint } from "jsr:@denops/std@^7.0.0";
-import { batch, collect } from "jsr:@denops/std@^7.0.0/batch";
-import * as fn from "jsr:@denops/std@^7.0.0/function";
-import * as op from "jsr:@denops/std@^7.0.0/option";
-import { Maze } from "npm:@thewizardbear/maze_generator@^0.4.0";
-import { assert, is } from "jsr:@core/unknownutil@^4.3.0";
+import type { Entrypoint } from "@denops/std";
+import { batch, collect } from "@denops/std/batch";
+import * as fn from "@denops/std/function";
+import * as op from "@denops/std/option";
+import { Maze } from "maze_generator";
+import { assert, is } from "@core/unknownutil";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {

src/tutorial/maze/outputting-content-to-buffer.md

@@ -7,8 +7,8 @@ the maze to a buffer so that users can yank the maze with daily Vim operations!
 Let's modify the code to make the generated maze output to a buffer.
 
 ```typescript,title=denops/denops-maze/main.ts
-import type { Entrypoint } from "jsr:@denops/std@^7.0.0";
-import { Maze } from "npm:@thewizardbear/maze_generator@^0.4.0";
+import type { Entrypoint } from "@denops/std";
+import { Maze } from "maze_generator";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {

src/tutorial/maze/properly-configured-the-buffer.md

@@ -7,11 +7,11 @@ buffer after closure. Open the `main.ts` file and modify the `maze` method as
 follows:
 
 ```typescript,title=denops/denops-maze/main.ts
-import type { Entrypoint } from "jsr:@denops/std@^7.0.0";
-import * as buffer from "jsr:@denops/std@^7.0.0/buffer";
-import * as fn from "jsr:@denops/std@^7.0.0/function";
-import * as op from "jsr:@denops/std@^7.0.0/option";
-import { Maze } from "npm:@thewizardbear/maze_generator@^0.4.0";
+import type { Entrypoint } from "@denops/std";
+import * as buffer from "@denops/std/buffer";
+import * as fn from "@denops/std/function";
+import * as op from "@denops/std/option";
+import { Maze } from "maze_generator";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {

src/tutorial/maze/properly-create-a-virtual-buffer.md

@@ -10,10 +10,10 @@ proper virtual buffer that concretizes the buffer content. Let's modify the
 `main.ts` file as follows:
 
 ```typescript,title=denops/denops-maze/main.ts
-import type { Entrypoint } from "jsr:@denops/std@^7.0.0";
-import * as buffer from "jsr:@denops/std@^7.0.0/buffer";
-import * as fn from "jsr:@denops/std@^7.0.0/function";
-import { Maze } from "npm:@thewizardbear/maze_generator@^0.4.0";
+import type { Entrypoint } from "@denops/std";
+import * as buffer from "@denops/std/buffer";
+import * as fn from "@denops/std/function";
+import { Maze } from "maze_generator";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {