feat(task-graph): materialize object dependsOn edges

Object-form `dependsOn` entries — `{ "task": "build", "from": "dependencies" }`
— run a task in the direct workspace packages listed under a package.json
dependency field (`dependencies`, `devDependencies`, and/or `peerDependencies`).

The earlier implementation expanded these selections at query time, so they
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 are added as ordinary task
graph edges (`add_package_dependency_edges`). Only direct dependencies are
followed, and an edge is added only when the dependency package defines the
task.

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

The fixture asserts edge construction through the rendered global
`task_graph.md` (every `from` variant, recursive cross-package chains, and the
exclusion of peer-only and missing-task dependencies). 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.

Co-authored-by: GPT-5 Codex <codex@openai.com>
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QowxsN8vDKKbQdaSMdxL67

Author: 2 people

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,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!({