@@ -186,6 +186,9 @@ async for item in stream_handle(client, agent_id, topic=EVENTS).follow():
   `join(*, name, until=None)` writes a `JOIN`. It says the producer waited
   for the link up to `until`, or to the linked stream's end. A link names a
   Workflow's stream only. Any other ref raises `ValueError`.
+- **Mixed batches.** `append` also takes a `StreamLink` next to plain values,
+  so `append(event, StreamLink(LinkEvent.OPEN, ref, name))` writes the event
+  and its link as one batch, with one dedupe identity.
 - **Following.** `StreamHandle.follow()` and `ActivityStreamHandle.follow()`
   read a stream and the streams it links, from client or Activity code.
   Workflow code can't follow.
 
@@ -122,10 +122,14 @@ def attempt(self) -> int:
         """The attempt this producer writes."""
         return self._attempt
 
-    async def append(self, *values: T) -> Cursor:
+    async def append(self, *values: T | StreamLink) -> Cursor:
         """Append ``values`` as one batch and return the cursor of its last record.
 
-        The batch lands whole and in order. The producer moves its sequence
+        A :class:`temporalio.contrib.streams.StreamLink` among the values is a
+        ``LINK`` record, as :meth:`link` and :meth:`join` write it, and the
+        other values are ``DATA`` records. So one batch can hold a value and
+        the link that goes with it, under one dedupe identity. The batch lands
+        whole and in order. The producer moves its sequence
         past the batch only when the append succeeds, so a call that raised
         :class:`temporalio.contrib.streams.StreamOutcomeUnknownError` can be
         repeated with the same values: the store answers a repeat of the
@@ -151,11 +155,19 @@ async def append(self, *values: T) -> Cursor:
             StreamRefusedError: The store refused the batch, for example
                 because it is out of memory. Nothing was written.
             StreamClosedError: The stream refuses appends.
+            ValueError: A link names nothing, or names a stream that no
+                Workflow owns. Nothing was written.
         """
+        items: list[tuple[RecordKind, Any, StreamLink | None]] = [
+            (RecordKind.LINK, None, v)
+            if isinstance(v, StreamLink)
+            else (RecordKind.DATA, v, None)
+            for v in values
+        ]
         async with self._lock:
-            if not values:
+            if not items:
                 return self._last
-            return await self._write(RecordKind.DATA, values)
+            return await self._write(items)
 
     async def finish(self) -> Cursor:
         """Write ``FINISH`` for this producer on this topic and return its cursor.
@@ -164,7 +176,7 @@ async def finish(self) -> Cursor:
         work behind it succeeded, and it does not end anyone's read.
         """
         async with self._lock:
-            return await self._write(RecordKind.FINISH, [None])
+            return await self._write([(RecordKind.FINISH, None, None)])
 
     async def link(
         self,
@@ -189,7 +201,7 @@ async def link(
         """
         link = StreamLink(LinkEvent.OPEN, ref, name, after=after)
         async with self._lock:
-            return await self._write(RecordKind.LINK, [value], link)
+            return await self._write([(RecordKind.LINK, value, link)])
 
     async def join(self, *, name: str, until: Cursor | None = None) -> Cursor:
         """Write a ``LINK`` that says this producer waited for link ``name``.
@@ -203,10 +215,10 @@ async def join(self, *, name: str, until: Cursor | None = None) -> Cursor:
         """
         link = StreamLink(LinkEvent.JOIN, None, name, until=until)
         async with self._lock:
-            return await self._write(RecordKind.LINK, [None], link)
+            return await self._write([(RecordKind.LINK, None, link)])
 
     async def _write(
-        self, kind: RecordKind, values: Any, link: StreamLink | None = None
+        self, items: list[tuple[RecordKind, Any, StreamLink | None]]
     ) -> Cursor:
         converter = self._handle._converter
         wires = [
@@ -220,7 +232,7 @@ async def _write(
                 sequence=self._sequence + index,
                 link=link,
             )
-            for index, value in enumerate(values)
+            for index, (kind, value, link) in enumerate(items)
         ]
         request = AppendRequest(
             stream=self._handle._address(self._topic),
 
@@ -118,39 +118,53 @@ def topic(self) -> str:
         """The name of the topic this producer is bound to."""
         return self._topic
 
-    def append(self, value: T) -> None:
-        """Append ``value`` on this topic and return at once.
-
-        The value is converted here, with the Workflow's payload converter. A
-        :class:`temporalio.common.RawValue` passes through pre-encoded. The
-        record is visible when the activation that appended it completes,
+    def append(self, *values: T | StreamLink) -> None:
+        """Append ``values`` on this topic, in order, and return at once.
+
+        A :class:`temporalio.contrib.streams.StreamLink` among the values is a
+        ``LINK`` record, as :meth:`link` and :meth:`join` write it, and the
+        other values are ``DATA`` records. Every value is converted here, with
+        the Workflow's payload converter, before any record is added, so a
+        bad value adds none of them. A :class:`temporalio.common.RawValue`
+        passes through pre-encoded. The records go with the activation, in
+        one batch with the activation's other records. A record is visible
+        when the activation that appended it completes,
         which is before the Workflow Task completes. If the task then fails or
         times out, the record stays, and the task's rerun appends again under
         a higher attempt, which readers see as ``SUPERSEDED``.
 
         Raises:
-            ValueError: The topic was already finished in this run.
-            temporalio.contrib.streams.StreamError: The value's payload is
+            ValueError: The topic was already finished in this run, or a link
+                names nothing or names a stream that no Workflow owns.
+            temporalio.contrib.streams.StreamError: A value's payload is
                 over 1.5 MiB. Nothing is appended.
             temporalio.workflow.ReadOnlyContextError: Called from a query or
                 an update validator.
         """
         _check_writable("append to")
         if self._topic in self._producers.finished:
             raise ValueError(f"topic {self._topic!r} was already finished")
+        records = [
+            self._link_record(value, None)
+            if isinstance(value, StreamLink)
+            else self._data_record(value)
+            for value in values
+        ]
+        for record in records:
+            self._producers.add(record)
+
+    def _data_record(self, value: Any) -> OutputRecord:
         payload = workflow.payload_converter().to_payloads([value])[0]
         if payload.ByteSize() > _MAX_RECORD_BYTES:
             raise StreamError(
                 f"a record of {payload.ByteSize()} bytes on {self._topic!r} is over "
                 f"the per-record limit of {_MAX_RECORD_BYTES} bytes"
             )
-        self._producers.add(
-            OutputRecord(
-                topic=self._topic,
-                kind=StreamRecordKind.STREAM_RECORD_KIND_DATA,
-                body=payload,
-                content_hash=content_hash(payload),
-            )
+        return OutputRecord(
+            topic=self._topic,
+            kind=StreamRecordKind.STREAM_RECORD_KIND_DATA,
+            body=payload,
+            content_hash=content_hash(payload),
         )
 
     def link(
@@ -197,6 +211,9 @@ def _add_link(self, link: StreamLink, value: Any) -> None:
         _check_writable("link on")
         if self._topic in self._producers.finished:
             raise ValueError(f"topic {self._topic!r} was already finished")
+        self._producers.add(self._link_record(link, value))
+
+    def _link_record(self, link: StreamLink, value: Any) -> OutputRecord:
         record = OutputRecord(
             topic=self._topic,
             kind=StreamRecordKind.STREAM_RECORD_KIND_LINK,
@@ -211,7 +228,7 @@ def _add_link(self, link: StreamLink, value: Any) -> None:
                 )
             record.body.CopyFrom(payload)
             record.content_hash = content_hash(payload)
-        self._producers.add(record)
+        return record
 
     async def flush(self) -> None:
         """Return at once, since each record goes with its activation.
 
@@ -725,3 +725,79 @@ async def test_a_producer_links_and_joins(client: Client):
     assert records[1].value == {"label": "search"}
     assert records[2].link == StreamLink(LinkEvent.JOIN, None, "sub-1")
     assert [r.sequence for r in records] == [1, 2, 3]
+
+
+@workflow.defn
+class AppendsMixed:
+    @workflow.run
+    async def run(self) -> str:
+        steps = stream_producer(STEPS)
+        child = StreamRef.for_workflow("child")
+        steps.append("d1", StreamLink(LinkEvent.OPEN, child, "sub-1"), "d2")
+        try:
+            steps.append("lost", StreamLink(LinkEvent.OPEN, child, ""))
+        except ValueError as error:
+            return str(error)
+        return ""
+
+
+async def test_a_workflow_appends_values_and_links_in_one_call(client: Client):
+    streams = await connect_with(client, MemoryStreams())
+    workflow_id = new_workflow_id()
+    async with new_worker(streams, AppendsMixed) as worker:
+        refused = await streams.execute_workflow(
+            AppendsMixed.run, id=workflow_id, task_queue=worker.task_queue
+        )
+    records = await read_all(stream_handle(streams, workflow_id).read(topic=STEPS))
+    assert [(r.kind, r.value) for r in records] == [
+        (RecordKind.DATA, "d1"),
+        (RecordKind.LINK, None),
+        (RecordKind.DATA, "d2"),
+    ]
+    assert records[1].link == StreamLink(
+        LinkEvent.OPEN, StreamRef.for_workflow("child"), "sub-1"
+    )
+    # A bad link adds none of the call's records.
+    assert "1 to 256" in refused
+
+
+async def mixed_batch_appends_once(streams: Client) -> None:
+    async with new_worker(streams, Waits) as worker:
+        workflow_id = await running_owner(streams, worker.task_queue)
+        stream = stream_handle(streams, workflow_id, topic=STEPS)
+        child = StreamRef.for_workflow(f"{workflow_id}-child", topic=STEPS)
+        batch = (
+            "sent",
+            StreamLink(LinkEvent.OPEN, child, "sub-1"),
+            StreamLink(LinkEvent.JOIN, None, "sub-1"),
+            "received",
+        )
+        first = stream.producer(producer_id="agent", attempt=1)
+        last = await first.append(*batch)
+        # A resend of the same batch from a fresh producer object dedupes.
+        again = stream.producer(producer_id="agent", attempt=1)
+        assert await again.append(*batch) == last
+        with pytest.raises(ValueError, match="1 to 256"):
+            await first.append("x", StreamLink(LinkEvent.OPEN, child, ""))
+        await first.append("after")
+        await streams.get_workflow_handle(workflow_id).signal(Waits.finish)
+        records = await read_all(stream.read())
+    assert [r.kind for r in records] == [
+        RecordKind.DATA,
+        RecordKind.LINK,
+        RecordKind.LINK,
+        RecordKind.DATA,
+        RecordKind.DATA,
+    ]
+    assert records[3].cursor == last
+    assert records[1].link == StreamLink(LinkEvent.OPEN, child, "sub-1")
+    assert records[2].link == StreamLink(LinkEvent.JOIN, None, "sub-1")
+    assert [r.sequence for r in records] == [1, 2, 3, 4, 5]
+
+
+async def test_a_producer_appends_values_and_links_as_one_batch(client: Client):
+    await mixed_batch_appends_once(await connect_with(client, MemoryStreams()))
+
+
+async def test_a_resent_mixed_batch_dedupes_on_redis(client: Client):
+    await mixed_batch_appends_once(await connect_with(client, redis_store()))