feat(task-graph): materialize object dependsOn edges (#479)

## Motivation

Stacked on #478 (the revert of the query-time implementation).

Object-form `dependsOn` entries — `{ "task": "build", "from": ["dependencies", "devDependencies"] }` — run a task in the direct workspace packages listed under a package.json dependency field. The previous implementation (#467/#469, reverted in #478) expanded these at query time, so the selections never appeared in the global task graph.

This reimplements the feature at **graph-load time**: each object entry is resolved against the package dependency graph and the matching `package#task` selections become ordinary task graph edges (`add_package_dependency_edges`). Because they are now plain edges:

- they appear in the global task graph, and
- they flow through the existing dependency machinery for free — including `--ignore-depends-on`, which drops them at query time like any other `dependsOn` edge.

Only direct dependencies are followed, and an edge is added only when the dependency package actually defines the task. Supported fields are `dependencies`, `devDependencies`, and `peerDependencies`.

## Snapshot coverage

Because the edges now live in the global task graph, the fixture asserts edge construction through the rendered `task_graph.md`: every `from` variant, recursive cross-package chains, and the exclusion of peer-only and missing-task dependencies are all visible there. The only behavior the static graph cannot express — `--ignore-depends-on` removing the materialized edges at query time — is kept as the single per-case plan snapshot. The other four per-case snapshots in the original change were redundant re-assertions of edges already shown in `task_graph.md`, so they were dropped.

## Behavior note vs #467/#469

The reverted query-stage impl also preserved ordering *among* the sibling dependency tasks selected by a single object `dependsOn` (e.g. `ui#build → shared#build` when `app#test` selected both and `ui` depends on `shared`), scoped to that one query's execution graph. The graph-stage model intentionally does not: every edge here is global, and a global `ui#build → shared#build` edge would make a plain `vp run ui#build` also build `shared`, contradicting vp's rule that topological ordering applies only with `-r`/`-t`. Ordering among selected dependencies instead comes from each task declaring its own `dependsOn` (the recursive-expansion path documented in `task-query.md`).

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

https://claude.ai/code/session_01QowxsN8vDKKbQdaSMdxL67

Author: wan9chi

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 - **Added** First-party support for caching `vite build` with zero cache config, giving Vite projects correct cache hits out of the box ([vitejs/vite#22453](https://github.com/vitejs/vite/pull/22453)).
+- **Added** Object-form `dependsOn` entries for direct workspace dependencies ([#479](https://github.com/voidzero-dev/vite-task/pull/479)).
 - **Added** [`@voidzero-dev/vite-task-client`](https://npmx.dev/package/@voidzero-dev/vite-task-client), allowing tools to report cache information to Vite Task at runtime so users do not need to configure it manually ([#441](https://github.com/voidzero-dev/vite-task/pull/441), [#454](https://github.com/voidzero-dev/vite-task/pull/454), [#449](https://github.com/voidzero-dev/vite-task/pull/449), [#450](https://github.com/voidzero-dev/vite-task/pull/450), [#458](https://github.com/voidzero-dev/vite-task/pull/458), [#431](https://github.com/voidzero-dev/vite-task/pull/431), [#459](https://github.com/voidzero-dev/vite-task/pull/459), [#472](https://github.com/voidzero-dev/vite-task/pull/472)).
 - **Changed** Cached tasks now restore automatically tracked output files by default; use `output: []` to disable restoration ([#460](https://github.com/voidzero-dev/vite-task/pull/460), [#461](https://github.com/voidzero-dev/vite-task/pull/461)).
 - **Changed** Environment values in task cache fingerprints are now stored only as SHA-256 digests, and env-related cache miss details report names without values ([#455](https://github.com/voidzero-dev/vite-task/pull/455)).

Cargo.lock

@@ -13,7 +13,7 @@ Both are built once and reused for every query, including nested `vp run` calls
 
 ### What goes into the task graph
 
-The task graph contains a node for every task in every package, and edges only for explicit `dependsOn` declarations:
+The task graph contains a node for every task in every package, and edges only for explicit `dependsOn` declarations.
 
 ```jsonc
 // packages/app/vite.config.*
@@ -38,6 +38,33 @@ Task graph:
 
 Package dependency ordering (app depends on lib) is NOT stored as edges in the task graph. Why not is explained below.
 
+Object-form `dependsOn` entries are also explicit task dependencies. At startup,
+they are resolved against the declaring package's direct `package.json`
+dependency fields and materialized as task graph edges:
+
+```jsonc
+// packages/app/vite.config.*
+{
+  "tasks": {
+    "test": {
+      "command": "vitest run",
+      "dependsOn": [{ "task": "build", "from": ["dependencies", "devDependencies"] }],
+    },
+  },
+}
+```
+
+If `app` directly depends on `ui` and `shared`, and both packages have `build`,
+the task graph contains:
+
+```
+app#test ──dependsOn──> ui#build
+app#test ──dependsOn──> shared#build
+```
+
+Dependency packages without the requested task are skipped. Recursive expansion
+comes from dependency tasks declaring their own `dependsOn` entries.
+
 ## What happens when you run a query
 
 Every `vp run` command goes through two stages:
@@ -188,7 +215,7 @@ If you run `vp run --filter app build`, the package subgraph contains only `app`
 
 This is intentional — `dependsOn` is an explicit declaration that a task can't run without its dependency. Ignoring it would break the build. (Users can skip this with `--ignore-depends-on`.)
 
-The expansion only follows explicit edges, not topological ones. Topological ordering comes from the package subgraph — it's already baked into the task execution graph by Stage 2.
+The expansion follows explicit `dependsOn` edges, including edges materialized from object-form entries. It does not follow topological package edges. Topological ordering comes from the package subgraph — it's already baked into the task execution graph by Stage 2.
 
 ## Nested `vp run`
 

crates/vite_task/docs/task-query.md

@@ -18,6 +18,7 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
+vec1 = { workspace = true, features = ["serde"] }
 vite_path = { workspace = true }
 vite_str = { workspace = true }
 vite_workspace = { workspace = true }

crates/vite_task_graph/Cargo.toml

@@ -8,6 +8,12 @@ auto: boolean, };
 
 export type Command = string | Array<string>;
 
+export type DependencyType = "dependencies" | "devDependencies" | "peerDependencies";
+
+export type DependsOnEntry = string | UserPackageDependency;
+
+export type DependsOnFrom = DependencyType | Array<DependencyType>;
+
 export type GlobWithBase = {
 /**
  * The glob pattern (positive or negative starting with `!`)
@@ -30,9 +36,16 @@ command: Command,
  */
 cwd?: string,
 /**
- * Dependencies of this task. Use `package-name#task-name` to refer to tasks in other packages.
+ * Tasks that must run before this task.
+ *
+ * - A string runs one named task, such as `"build"` in the same package or
+ *   `"package-name#build"` in another package.
+ * - An object runs a task in direct workspace dependency packages selected
+ *   from package.json fields. For example,
+ *   `{ "task": "build", "from": "dependencies" }` runs `build` in each
+ *   direct workspace dependency that defines a `build` task.
  */
-dependsOn?: Array<string>, } & ({
+dependsOn?: Array<DependsOnEntry>, } & ({
 /**
  * Whether to cache the task
  */
@@ -95,6 +108,16 @@ scripts?: boolean,
  */
 tasks?: boolean, };
 
+export type UserPackageDependency = {
+/**
+ * Task name to run in dependency packages.
+ */
+task: string,
+/**
+ * Package.json dependency field or fields to use when selecting direct dependency packages.
+ */
+from: DependsOnFrom, };
+
 export type RunConfig = {
 /**
  * Root-level cache configuration.

crates/vite_task_graph/run-config.ts

@@ -7,8 +7,9 @@ use rustc_hash::FxHashSet;
 use serde::Serialize;
 pub use user::{
     AutoTracking, Command, EnabledCacheConfig, GlobWithBase, InputBase, ResolvedGlobalCacheConfig,
-    UserCacheConfig, UserGlobalCacheConfig, UserInputEntry, UserInputsConfig, UserOutputEntry,
-    UserRunConfig, UserTaskConfig, UserTaskDefinition,
+    UserCacheConfig, UserDependencyType, UserDependsOnEntry, UserDependsOnFrom,
+    UserGlobalCacheConfig, UserInputEntry, UserInputsConfig, UserOutputEntry,
+    UserPackageDependency, UserRunConfig, UserTaskConfig, UserTaskDefinition,
 };
 use vite_path::AbsolutePath;
 use vite_str::Str;

crates/vite_task_graph/src/config/mod.rs

@@ -7,6 +7,7 @@ use rustc_hash::FxHashMap;
 use serde::Deserialize;
 #[cfg(all(test, not(clippy)))]
 use ts_rs::TS;
+use vec1::Vec1;
 use vite_path::RelativePathBuf;
 use vite_str::Str;
 
@@ -65,6 +66,70 @@ pub enum UserInputEntry {
 /// Default (when field omitted): `[{auto: true}]` - infer from file accesses.
 pub type UserInputsConfig = Vec<UserInputEntry>;
 
+/// A supported package.json dependency field for package dependency selection.
+#[derive(Debug, Deserialize, PartialEq, Eq, Clone, Copy)]
+// TS derive macro generates code using std types that clippy disallows; skip derive during linting
+#[cfg_attr(all(test, not(clippy)), derive(TS), ts(rename = "DependencyType"))]
+#[serde(rename_all = "camelCase")]
+pub enum UserDependencyType {
+    /// Traverse dependencies declared in the package.json `dependencies` field.
+    Dependencies,
+    /// Traverse dependencies declared in the package.json `devDependencies` field.
+    DevDependencies,
+    /// Traverse dependencies declared in the package.json `peerDependencies` field.
+    PeerDependencies,
+}
+
+/// The `from` selector for object-form `dependsOn` entries.
+#[derive(Debug, Deserialize, PartialEq, Eq, Clone)]
+// TS derive macro generates code using std types that clippy disallows; skip derive during linting
+#[cfg_attr(all(test, not(clippy)), derive(TS), ts(rename = "DependsOnFrom"))]
+#[serde(untagged)]
+pub enum UserDependsOnFrom {
+    /// Select one package.json dependency field.
+    Single(UserDependencyType),
+    /// Select the union of multiple package.json dependency fields.
+    Multiple(
+        #[cfg_attr(all(test, not(clippy)), ts(as = "Vec<UserDependencyType>"))]
+        Vec1<UserDependencyType>,
+    ),
+}
+
+impl UserDependsOnFrom {
+    #[must_use]
+    pub fn as_slice(&self) -> &[UserDependencyType] {
+        match self {
+            Self::Single(dependency_type) => std::slice::from_ref(dependency_type),
+            Self::Multiple(dependency_types) => dependency_types,
+        }
+    }
+}
+
+/// Object form for `dependsOn` entries that select direct workspace package dependencies.
+#[derive(Debug, Deserialize, PartialEq, Eq, Clone)]
+// TS derive macro generates code using std types that clippy disallows; skip derive during linting
+#[cfg_attr(all(test, not(clippy)), derive(TS))]
+#[serde(deny_unknown_fields)]
+pub struct UserPackageDependency {
+    /// Task name to run in dependency packages.
+    pub task: Str,
+
+    /// Package.json dependency field or fields to use when selecting direct dependency packages.
+    pub from: UserDependsOnFrom,
+}
+
+/// A single `dependsOn` entry.
+#[derive(Debug, Deserialize, PartialEq, Eq, Clone)]
+// TS derive macro generates code using std types that clippy disallows; skip derive during linting
+#[cfg_attr(all(test, not(clippy)), derive(TS), ts(rename = "DependsOnEntry"))]
+#[serde(untagged)]
+pub enum UserDependsOnEntry {
+    /// Same-package task or `package#task` specifier.
+    Task(Str),
+    /// Direct package dependency selection entry.
+    Package(UserPackageDependency),
+}
+
 /// A single output entry in the `output` array.
 ///
 /// Outputs can be:
@@ -168,8 +233,15 @@ pub struct UserTaskOptions {
     #[serde(rename = "cwd")]
     pub cwd_relative_to_package: Option<RelativePathBuf>,
 
-    /// Dependencies of this task. Use `package-name#task-name` to refer to tasks in other packages.
-    pub depends_on: Option<Arc<[Str]>>,
+    /// Tasks that must run before this task.
+    ///
+    /// - A string runs one named task, such as `"build"` in the same package or
+    ///   `"package-name#build"` in another package.
+    /// - An object runs a task in direct workspace dependency packages selected
+    ///   from package.json fields. For example,
+    ///   `{ "task": "build", "from": "dependencies" }` runs `build` in each
+    ///   direct workspace dependency that defines a `build` task.
+    pub depends_on: Option<Arc<[UserDependsOnEntry]>>,
 
     /// Cache-related fields
     #[serde(flatten)]
@@ -510,10 +582,73 @@ mod tests {
         );
         let options = user_config.options;
         assert_eq!(options.cwd_relative_to_package.as_ref().unwrap().as_str(), "src");
-        assert_eq!(options.depends_on.as_ref().unwrap().as_ref(), [Str::from("build")]);
+        assert_eq!(
+            options.depends_on.as_ref().unwrap().as_ref(),
+            [UserDependsOnEntry::Task(Str::from("build"))]
+        );
         assert_eq!(options.cache_config, UserCacheConfig::Disabled { cache: MustBe!(false) });
     }
 
+    #[test]
+    fn test_depends_on_package_dependency_single_from() {
+        let user_config_json = json!({
+            "command": "echo test",
+            "dependsOn": [{ "task": "build", "from": "dependencies" }]
+        });
+        let user_config: UserTaskConfig = serde_json::from_value(user_config_json).unwrap();
+        assert_eq!(
+            user_config.options.depends_on.as_ref().unwrap().as_ref(),
+            [UserDependsOnEntry::Package(UserPackageDependency {
+                task: "build".into(),
+                from: UserDependsOnFrom::Single(UserDependencyType::Dependencies),
+            })]
+        );
+    }
+
+    #[test]
+    fn test_depends_on_package_dependency_array_from() {
+        let user_config_json = json!({
+            "command": "echo test",
+            "dependsOn": [{
+                "task": "build",
+                "from": ["dependencies", "devDependencies", "peerDependencies"]
+            }]
+        });
+        let user_config: UserTaskConfig = serde_json::from_value(user_config_json).unwrap();
+        assert_eq!(
+            user_config.options.depends_on.as_ref().unwrap().as_ref(),
+            [UserDependsOnEntry::Package(UserPackageDependency {
+                task: "build".into(),
+                from: UserDependsOnFrom::Multiple(
+                    Vec1::try_from_vec(vec![
+                        UserDependencyType::Dependencies,
+                        UserDependencyType::DevDependencies,
+                        UserDependencyType::PeerDependencies,
+                    ])
+                    .unwrap()
+                ),
+            })]
+        );
+    }
+
+    #[test]
+    fn test_depends_on_package_dependency_empty_from_error() {
+        let user_config_json = json!({
+            "command": "echo test",
+            "dependsOn": [{ "task": "build", "from": [] }]
+        });
+        assert!(serde_json::from_value::<UserTaskConfig>(user_config_json).is_err());
+    }
+
+    #[test]
+    fn test_depends_on_package_dependency_unknown_from_error() {
+        let user_config_json = json!({
+            "command": "echo test",
+            "dependsOn": [{ "task": "build", "from": "optionalDependencies" }]
+        });
+        assert!(serde_json::from_value::<UserTaskConfig>(user_config_json).is_err());
+    }
+
     #[test]
     fn test_task_invalid_shorthand_error() {
         let user_config_json = json!({