Please address the comments from this code review:
## Overall Comments
- The multipart streaming logic in async_base_view has grown quite complex; consider extracting the `stream` generator and multipart encoding into a reusable helper or class to improve readability and maintainability.
- In `encode_multipart_data`, computing `Content-Length` using `len(encoded_data)` may be incorrect for non-ASCII content or boundary bytes—consider using the byte length (`len(encoded_data.encode('utf-8'))`) or otherwise validating the header length.
- There are several `TODO` comments around error handling and result processing in the incremental execution paths—please address or formally track these work items so the core execution flow doesn’t rely on unfinished logic.

## Individual Comments

### Comment 1
<location> `strawberry/http/async_base_view.py:437` </location>
<code_context>
         )

     def encode_multipart_data(self, data: Any, separator: str) -> str:
+        encoded_data = self.encode_json(data)
+
</code_context>

<issue_to_address>
The separator is used as a boundary but is hardcoded as '-', which may not be unique.

Consider generating a unique boundary string instead of using '-', to prevent parsing errors if the payload contains the same sequence.

Suggested implementation:

```python
import uuid

                boundary = f"----strawberry-{uuid.uuid4().hex}"
                headers={
                    "Transfer-Encoding": "chunked",
                    "Content-Type": f'multipart/mixed; boundary="{boundary}"',
                },
            )

```

```python
            async def stream() -> AsyncGenerator[str, None]:
                yield f"--{boundary}"

```
</issue_to_address>

### Comment 2
<location> `strawberry/http/async_base_view.py:424` </location>
<code_context>
+                sub_response,
+                headers={
+                    "Transfer-Encoding": "chunked",
+                    "Content-Type": 'multipart/mixed; boundary="-"',
+                },
+            )
</code_context>

<issue_to_address>
The Content-Type boundary value should match the actual boundary used in the body.

Make sure the boundary in the header exactly matches the one used in the multipart body. It's best to use a unique string for the boundary.

Suggested implementation:

```python
                    boundary = "graphql-subscription-12345"
                    yield self.encode_multipart_data(response, boundary)

                yield f"--{boundary}--\r\n"

            return await self.create_streaming_response(
                request,
                stream,
                sub_response,
                headers={
                    "Transfer-Encoding": "chunked",

```

```python
                    "Content-Type": f'multipart/mixed; boundary={boundary}',
                },
            )

```
</issue_to_address>

### Comment 3
<location> `strawberry/http/__init__.py:19` </location>
<code_context>

-def process_result(result: ExecutionResult) -> GraphQLHTTPResponse:
-    data: GraphQLHTTPResponse = {"data": result.data}
+def process_result(result: ResultType) -> GraphQLHTTPResponse:
+    if isinstance(result, GraphQLIncrementalExecutionResults):
+        return result
</code_context>

<issue_to_address>
Returning 'result' directly when it's a GraphQLIncrementalExecutionResults may break expected return type.

Returning a GraphQLIncrementalExecutionResults instead of a GraphQLHTTPResponse may lead to type inconsistencies for consumers expecting a dictionary-like response.
</issue_to_address>

### Comment 4
<location> `strawberry/annotation.py:339` </location>
<code_context>
         return _annotation_is_maybe(annotation)

+    @classmethod
+    def _is_streamable(cls, annotation: Any, args: list[Any]) -> bool:
+        return any(isinstance(arg, StrawberryStreamable) for arg in args)
+
     @classmethod
</code_context>

<issue_to_address>
Type checking with isinstance on annotation arguments may not be robust.

Consider checking types directly or using typing.get_origin/get_args, as annotation arguments may not always be instances.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    def _is_streamable(cls, annotation: Any, args: list[Any]) -> bool:
        return any(isinstance(arg, StrawberryStreamable) for arg in args)
=======
    def _is_streamable(cls, annotation: Any, args: list[Any]) -> bool:
        from typing import get_origin, get_args

        def is_streamable_type(arg):
            # Check if the argument is the StrawberryStreamable type or a generic of it
            origin = get_origin(arg) or arg
            return origin is StrawberryStreamable

        return any(is_streamable_type(arg) for arg in args)
>>>>>>> REPLACE

</suggested_fix>

### Comment 5
<location> `strawberry/schema/schema.py:534` </location>
<code_context>
-def process_result(result: ExecutionResult) -> GraphQLHTTPResponse:
-    data: GraphQLHTTPResponse = {"data": result.data}
+def process_result(result: ResultType) -> GraphQLHTTPResponse:
+    if isinstance(result, GraphQLIncrementalExecutionResults):
+        return result

-    if result.errors:
</code_context>

<issue_to_address>
Returning the raw incremental execution result may break expected interfaces.

Returning GraphQLIncrementalExecutionResults instead of ExecutionResult may cause runtime errors if consumers expect the standard interface. Please ensure the returned type matches the expected interface.
</issue_to_address>