feat(task-graph): materialize object dependsOn edges

Co-authored-by: GPT-5 Codex <codex@openai.com>

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 can select direct workspace package dependencies by `dependencies`, `devDependencies`, and `peerDependencies`, and are materialized as task graph edges.
 - **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

@@ -7,16 +7,16 @@ How `vp run` decides which tasks to run and in what order.
 When `vp` starts, it builds two data structures from the workspace:
 
 1. **Package graph** — which packages depend on which. Built from `package.json` dependency fields.
-2. **Task graph** — which tasks exist and their explicit `dependsOn` relationships. Built from `vite-task.json` and `package.json` scripts.
+2. **Task graph** — which tasks exist and their explicit `dependsOn` relationships. Built from `vite.config.*` and `package.json` scripts.
 
 Both are built once and reused for every query, including nested `vp run` calls inside task scripts.
 
 ### 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-task.json
+// packages/app/vite.config.*
 {
   "tasks": {
     "build": {
@@ -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:
@@ -174,7 +201,7 @@ So we clone the `DiGraphMap` once and mutate the clone. We iterate the original
 After mapping the package subgraph to tasks, we follow explicit `dependsOn` edges from the task graph. This can pull in tasks from packages outside the selected set.
 
 ```jsonc
-// packages/app/vite-task.json
+// packages/app/vite.config.*
 {
   "tasks": {
     "build": {
@@ -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_graph_ser = { workspace = true }
 vite_path = { workspace = true }
 vite_str = { 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,12 @@ command: Command,
  */
 cwd?: string,
 /**
- * Dependencies of this task. Use `package-name#task-name` to refer to tasks in other packages.
+ * Dependencies of this task.
+ *
+ * String entries keep same-package / `package-name#task-name` behavior.
+ * Object entries select direct workspace dependency packages from package.json fields.
  */
-dependsOn?: Array<string>, } & ({
+dependsOn?: Array<DependsOnEntry>, } & ({
 /**
  * Whether to cache the task
  */
@@ -95,6 +104,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,11 @@ 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]>>,
+    /// Dependencies of this task.
+    ///
+    /// String entries keep same-package / `package-name#task-name` behavior.
+    /// Object entries select direct workspace dependency packages from package.json fields.
+    pub depends_on: Option<Arc<[UserDependsOnEntry]>>,
 
     /// Cache-related fields
     #[serde(flatten)]
@@ -510,10 +578,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!({