ankka-flow 0.1.0__tar.gz

ankka_flow-0.1.0/.gitignore

@@ -0,0 +1,34 @@
+*.class
+*.tasty
+*.log
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+# sbt, IDEs, OS
+target/
+.bsp/
+.metals/
+.bloop/
+.idea/
+.vscode/
+.DS_Store
+*.tmp
+*.swp
+
+# Python (sdks/python, samples)
+__pycache__/
+*.pyc
+.venv/
+venv/
+dist/
+*.egg-info/
+.mypy_cache/
+.pytest_cache/
+sdks/python/src/ankka_flow/_proto/
+samples/*/src/*/_proto/
+
+# Kubernetes material that must never be committed
+*.secret.yaml
+kubeconfig*
+.env*

ankka_flow-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: ankka-flow
+Version: 0.1.0
+Summary: Write ankka-flow streamlets in Python: declare ports, process batches, let the sidecar own Kafka.
+Project-URL: Homepage, https://flow.ankka.cloud/
+Project-URL: Documentation, https://flow.ankka.cloud/reference/python-sdk/
+Project-URL: Repository, https://github.com/thinkmorestupidless/ankka-flow
+License-Expression: Apache-2.0
+Keywords: ankka,ankka-flow,kafka,sidecar,streaming
+Requires-Python: >=3.12
+Requires-Dist: grpcio<2,>=1.84
+Requires-Dist: protobuf<8,>=6
+Description-Content-Type: text/markdown
+
+# ankka-flow for Python
+
+Write [ankka-flow](https://flow.ankka.cloud/) streamlets in Python. You declare ports and parameters and
+implement `process`; the sidecar the platform runs beside your container owns everything Kafka.
+
+```python
+from collections.abc import Iterable
+from ankka_flow import Batch, Emit, IntegerParameter, JsonInlet, JsonOutlet, Streamlet, json, serve
+
+class CartRouter(Streamlet):
+    name = "cart-router"
+    inlet = JsonInlet("in", schema_name="cart-events.v1")
+    valid = JsonOutlet("valid", schema_name="cart-events.v1")
+    review = JsonOutlet("review", schema_name="cart-events.v1")
+    threshold = IntegerParameter("review-threshold", default=100)
+
+    def process(self, batch: Batch) -> Iterable[Emit]:
+        for record in batch:
+            event = json.loads(record.value)
+            yield (self.review if event["total"] > self.config[self.threshold] else self.valid).emit(record)
+
+if __name__ == "__main__":
+    serve(CartRouter())          # 127.0.0.1:$FLOW_PROCESS_PORT (9010), loopback only
+```
+
+- `process` runs once per batch on a worker thread. One batch per partition is in flight at a time,
+  so it never runs twice for one partition at once; different partitions run concurrently.
+- Returning acknowledges the batch. Raising fails it, and the sidecar redelivers it from the last
+  commit. Yielding nothing for a record skips it.
+- Records are bytes with a key and headers. The SDK decodes nothing; `ankka_flow.json` helps.
+
+## Descriptor
+
+`uv run descriptor` writes `flow/descriptor.json` from the streamlet named by
+`[tool.ankka-flow] streamlet = "module:Class"` in your `pyproject.toml` (or `$FLOW_STREAMLET`).
+Commit it. `uv run descriptor --check` fails when it is stale. The format is
+[`proto/DESCRIPTOR.md`](https://github.com/thinkmorestupidless/ankka-flow/blob/main/sdks/python/proto/DESCRIPTOR.md).
+
+## Testing without Kafka
+
+```python
+from ankka_flow.testkit import Harness
+
+h = Harness(CartRouter(), config={"review-threshold": 50})
+h.inlet("in").put(key=b"cart-1", value=b'{"total": 10}')
+h.run()
+assert [r.key for r in h.outlet("valid").records] == [b"cart-1"]
+```
+
+## Developing the SDK
+
+```bash
+uv sync
+uv run python scripts/proto.py   # copy ../../protocol into proto/ (committed) and generate src/ankka_flow/_proto/
+uv run mypy                      # strict
+uv run pytest -q                 # fixtures, the server against a scripted sidecar, the harness
+uv run conformance               # the reference streamlet against the platform's conformance suite
+```
+
+`proto/` must equal `../../protocol` byte for byte; CI diffs it. `tests/test_descriptor_fixtures.py`
+proves this SDK writes every fixture descriptor exactly.
+
+A new project starts from [`template/`](https://github.com/thinkmorestupidless/ankka-flow/tree/main/sdks/python/template), which carries a compose file with Kafka and the
+sidecar for the laptop loop.
+
+## Conformance
+
+`uv run conformance` serves the reference streamlet (`ankka_flow._conformance`) on
+`127.0.0.1:$FLOW_PROCESS_PORT` and runs the sidecar's conformance suite against it from the
+repository root (sbt and a JDK are needed). Last run: every one of the 18 cases that apply to an SDK
+passes; the five `violation.*` and `version.*` cases are skipped, as they only run against the
+Scala double.
+
+Two deliberate breaks prove the suite points at what broke:
+
+| `ANKKA_FLOW_BREAK` | what it breaks | cases that fail |
+|---|---|---|
+| `keyless-empty-key` | a keyless emit carries an empty key | exactly `run.unkeyed-emit` (SC-005) |
+| `ack-first` | the ack is sent before the batch's emits | the 12 cases that emit, `run.emits-precede-ack` among them |

ankka_flow-0.1.0/README.md

@@ -0,0 +1,79 @@
+# ankka-flow for Python
+
+Write [ankka-flow](https://flow.ankka.cloud/) streamlets in Python. You declare ports and parameters and
+implement `process`; the sidecar the platform runs beside your container owns everything Kafka.
+
+```python
+from collections.abc import Iterable
+from ankka_flow import Batch, Emit, IntegerParameter, JsonInlet, JsonOutlet, Streamlet, json, serve
+
+class CartRouter(Streamlet):
+    name = "cart-router"
+    inlet = JsonInlet("in", schema_name="cart-events.v1")
+    valid = JsonOutlet("valid", schema_name="cart-events.v1")
+    review = JsonOutlet("review", schema_name="cart-events.v1")
+    threshold = IntegerParameter("review-threshold", default=100)
+
+    def process(self, batch: Batch) -> Iterable[Emit]:
+        for record in batch:
+            event = json.loads(record.value)
+            yield (self.review if event["total"] > self.config[self.threshold] else self.valid).emit(record)
+
+if __name__ == "__main__":
+    serve(CartRouter())          # 127.0.0.1:$FLOW_PROCESS_PORT (9010), loopback only
+```
+
+- `process` runs once per batch on a worker thread. One batch per partition is in flight at a time,
+  so it never runs twice for one partition at once; different partitions run concurrently.
+- Returning acknowledges the batch. Raising fails it, and the sidecar redelivers it from the last
+  commit. Yielding nothing for a record skips it.
+- Records are bytes with a key and headers. The SDK decodes nothing; `ankka_flow.json` helps.
+
+## Descriptor
+
+`uv run descriptor` writes `flow/descriptor.json` from the streamlet named by
+`[tool.ankka-flow] streamlet = "module:Class"` in your `pyproject.toml` (or `$FLOW_STREAMLET`).
+Commit it. `uv run descriptor --check` fails when it is stale. The format is
+[`proto/DESCRIPTOR.md`](https://github.com/thinkmorestupidless/ankka-flow/blob/main/sdks/python/proto/DESCRIPTOR.md).
+
+## Testing without Kafka
+
+```python
+from ankka_flow.testkit import Harness
+
+h = Harness(CartRouter(), config={"review-threshold": 50})
+h.inlet("in").put(key=b"cart-1", value=b'{"total": 10}')
+h.run()
+assert [r.key for r in h.outlet("valid").records] == [b"cart-1"]
+```
+
+## Developing the SDK
+
+```bash
+uv sync
+uv run python scripts/proto.py   # copy ../../protocol into proto/ (committed) and generate src/ankka_flow/_proto/
+uv run mypy                      # strict
+uv run pytest -q                 # fixtures, the server against a scripted sidecar, the harness
+uv run conformance               # the reference streamlet against the platform's conformance suite
+```
+
+`proto/` must equal `../../protocol` byte for byte; CI diffs it. `tests/test_descriptor_fixtures.py`
+proves this SDK writes every fixture descriptor exactly.
+
+A new project starts from [`template/`](https://github.com/thinkmorestupidless/ankka-flow/tree/main/sdks/python/template), which carries a compose file with Kafka and the
+sidecar for the laptop loop.
+
+## Conformance
+
+`uv run conformance` serves the reference streamlet (`ankka_flow._conformance`) on
+`127.0.0.1:$FLOW_PROCESS_PORT` and runs the sidecar's conformance suite against it from the
+repository root (sbt and a JDK are needed). Last run: every one of the 18 cases that apply to an SDK
+passes; the five `violation.*` and `version.*` cases are skipped, as they only run against the
+Scala double.
+
+Two deliberate breaks prove the suite points at what broke:
+
+| `ANKKA_FLOW_BREAK` | what it breaks | cases that fail |
+|---|---|---|
+| `keyless-empty-key` | a keyless emit carries an empty key | exactly `run.unkeyed-emit` (SC-005) |
+| `ack-first` | the ack is sent before the batch's emits | the 12 cases that emit, `run.emits-precede-ack` among them |

ankka_flow-0.1.0/proto/DESCRIPTOR.md

@@ -0,0 +1,109 @@
+# The descriptor file
+
+A streamlet's descriptor is the discovery `Spec` message written as JSON by the SDK at build time.
+The same declaration produces the same bytes in every language, which the fixtures prove. It is
+never written by hand: the CLI and the sidecar refuse one whose fingerprints do not match their
+schema names.
+
+It is read in three places: the CLI verifies a blueprint against it, the operator mounts it into the
+sidecar, and the sidecar compares it field by field with the process's answer to `Discover`.
+
+## Canonical JSON
+
+1. Field names are the proto field names (snake_case): `protocol_version`, `schema_name`,
+   `config_parameters`, `default_value`.
+2. Object keys are sorted lexicographically (byte order) at every level.
+3. `inlets` and `outlets` are sorted by `name`; `config_parameters` by `key`. The SDK sorts; a
+   declaration order is never meaningful.
+4. Enums are their names (`"INTEGER"`), never numbers.
+5. A field at its proto3 default is omitted (`""`, `0`, `false`, an empty list, an unset
+   `optional`). `ConfigType.STRING` is therefore omitted, which is the rule, not a bug.
+6. Two-space indentation, `": "` and `,\n` separators, LF line endings, UTF-8, exactly one trailing
+   newline, no BOM.
+
+Python: `json.dumps(MessageToDict(spec, preserving_proto_field_name=True), sort_keys=True,
+indent=2, ensure_ascii=False) + "\n"`. Scala: `protocol`'s `DescriptorJson.write(spec)`, which is
+tested against every fixture.
+
+## Example: the cart router
+
+`protocol/fixtures/declarations/cart-router.md` describes the declaration; every SDK's sample
+declares it and `protocol/fixtures/descriptors/cart-router.json` is the expected output:
+
+```json
+{
+  "protocol_version": "1.0",
+  "sdk": {
+    "name": "fixture",
+    "version": "0.0.0"
+  },
+  "streamlet": {
+    "config_parameters": [
+      {
+        "default_value": "100",
+        "description": "Carts with a total above this go to the review outlet.",
+        "key": "review-threshold",
+        "type": "INTEGER"
+      }
+    ],
+    "description": "Routes cart events to the valid or review outlet.",
+    "inlets": [
+      {
+        "contract": {
+          "fingerprint": "nXhoFwNZSB7DKScFuZUtZ1gnAYkIxadumsXNHWwbLfM=",
+          "format": "json",
+          "schema_name": "cart-events.v1"
+        },
+        "name": "in"
+      }
+    ],
+    "name": "cart-router",
+    "outlets": [
+      {
+        "contract": {
+          "fingerprint": "nXhoFwNZSB7DKScFuZUtZ1gnAYkIxadumsXNHWwbLfM=",
+          "format": "json",
+          "schema_name": "cart-events.v1"
+        },
+        "name": "review"
+      },
+      {
+        "contract": {
+          "fingerprint": "nXhoFwNZSB7DKScFuZUtZ1gnAYkIxadumsXNHWwbLfM=",
+          "format": "json",
+          "schema_name": "cart-events.v1"
+        },
+        "name": "valid"
+      }
+    ]
+  }
+}
+```
+
+A fixture's `sdk` block is pinned to `{"name": "fixture", "version": "0.0.0"}` so that one file is
+the expected output of every SDK. Outside the fixture test an SDK writes its real name and version.
+
+## Fixtures
+
+| fixture | declares |
+|---|---|
+| `minimal` | one inlet, one outlet, no parameters, no description |
+| `cart-router` | the sample above |
+| `every-type` | one parameter of every `ConfigType`, one required (no default), unicode in a description |
+| `many-ports` | five inlets and five outlets declared out of order, to prove sorting |
+| `sink` | inlets only, no outlets |
+| `conformance` | the reference streamlet of the conformance suite (`../README.md`) |
+
+Each SDK's test suite declares each fixture's streamlet in its own language and asserts the
+written bytes equal the fixture. The Scala `protocol` test does the same for `DescriptorJson` and
+also parses each fixture back and re-writes it unchanged (FR-002, S5.2).
+
+## Validation (the CLI and the sidecar apply the same rules)
+
+- `streamlet.name` matches `[a-z0-9-]{1,63}` and does not start or end with `-`.
+- Port names match `[a-z][a-z0-9-]{0,62}` and are unique across inlets and outlets together.
+- `contract.format` is `json` (version one); `contract.fingerprint` equals
+  `Base64(SHA-256(UTF-8(schema_name)))` with standard alphabet and padding.
+- Parameter keys match `[a-z][a-z0-9-]*` and are unique; a `default_value` parses as its `type`
+  (`DURATION` as HOCON durations, `MEMORY_SIZE` as HOCON sizes).
+- `protocol_version` is `MAJOR.MINOR` with both parts unsigned integers.

ankka_flow-0.1.0/proto/README.md

@@ -0,0 +1,80 @@
+# The ankka-flow streamlet protocol, `ankka.flow.v1`
+
+This directory is the platform's promise to every SDK. Copy it into an SDK **verbatim**; CI diffs
+each copy against this one. It holds:
+
+| path | what |
+|---|---|
+| `src/main/protobuf/ankka/flow/v1/payload.proto` | `Record`, `Header`, `Error`, `Problems` |
+| `src/main/protobuf/ankka/flow/v1/discovery.proto` | `Discovery`: the process describes itself; the descriptor is its `Spec` |
+| `src/main/protobuf/ankka/flow/v1/streamlet.proto` | `Streamlet.Run`: one bidirectional conversation per streamlet instance |
+| `DESCRIPTOR.md` | the descriptor file's canonical JSON |
+| `fixtures/declarations/` | streamlet declarations in prose |
+| `fixtures/descriptors/` | the exact bytes each declaration must produce |
+| `fixtures/conversations/` | the scripted inputs the conformance suite sends |
+
+## Directions
+
+The developer's process serves `Discovery` and `Streamlet` on `127.0.0.1:$FLOW_PROCESS_PORT`
+(default 9010), bound to loopback only. The sidecar dials it. The sidecar binds no gRPC port in
+`1.x`; 9011 and `FLOW_SIDECAR_PORT` are reserved for a callback service a later minor may add.
+The sidecar sends no HTTP/2 keepalive pings, so a process keeps its gRPC library's default ping
+policy; one that ends connections for too many pings is never provoked.
+
+## Discovery
+
+1. The sidecar calls `Discover`, retrying with backoff (500 ms doubling to 10 s) until the process
+   answers. It is not ready until then.
+2. It checks the `Spec`'s protocol version, validates the descriptor, and compares it field by
+   field with the descriptor it was deployed with.
+3. On any problem it calls `ReportError` once with every problem, logs them, and exits.
+
+## Run
+
+1. The sidecar sends `Start`. The process sends nothing before it.
+2. The sidecar sends `Batch`es: at most one in flight per (inlet, partition), each partition's in
+   offset order. Batches for different partitions interleave freely.
+3. The process answers each batch with zero or more `Emit` and then exactly one `Ack` or `Fail`.
+   Messages for different batches may interleave.
+4. On `Ack` the sidecar produces the batch's emits, waits for the broker to confirm every one, and
+   only then commits the batch's offsets.
+5. On shutdown the sidecar sends `Stop` and half-closes.
+
+## Rules the messages do not state
+
+- **One batch in flight per (inlet, partition).** A partition's batches arrive in offset order.
+- **Emits precede the ack.** An emit after its batch's ack fails the stream.
+- **Commit after the write.** Offsets are committed only after every emit for the batch is confirmed.
+- **A `Fail` fails the stream, and nothing is skipped.** The sidecar voids every in-flight batch,
+  reconnects with backoff, repeats discovery, sends a new `Start`, and redelivers from the last
+  commit, indefinitely.
+- **Skipping is acking without emitting.** The sidecar never knows a record was skipped.
+- **A rebalance discards.** An emit or ack for a partition the sidecar no longer owns is dropped
+  silently and nothing is committed for it; the new owner reads it again. This is not a violation.
+- **The sidecar never decodes a value.** A contract is a format and a fingerprint.
+- **A keyless emit is partitioned by Kafka's default partitioner.** Per-key order is promised for
+  keyed records only.
+- **A new `Start` voids everything.** State tied to an older `conversation_id` must be discarded.
+- **Violations fail the stream:** an emit naming an outlet not in `Start.outlets`; an emit, ack or
+  fail for a batch that was never sent or is already acknowledged; an emit after its ack.
+- **Message size.** Batches are bounded by count, bytes and time so they stay under 4 MiB. A single
+  input record over the limit fails the stream naming its topic, partition and offset. An emit must
+  stay under `Start.max_message_bytes`.
+
+## Versioning
+
+`protocol_version` is `MAJOR.MINOR`, `1.0` here. The sidecar accepts a `Spec` of its own major
+whose minor is not later than its own, and refuses anything else naming both. Adding an optional
+field, a message, an rpc, a `ConfigType` value, a contract `format` or a fixture is a minor.
+Renaming, removing or re-meaning anything is a major.
+
+## Proving an SDK
+
+Two things define a compatible SDK:
+
+- **The descriptor fixtures.** Declare each streamlet in `fixtures/declarations/` in your language,
+  write its descriptor with `sdk` pinned to `{"name": "fixture", "version": "0.0.0"}`, and assert
+  the bytes equal `fixtures/descriptors/<name>.json`.
+- **The conformance suite.** Implement the `conformance` reference streamlet, serve it on a port,
+  and run `sbt 'sidecar/testOnly *ConformanceSuite' -Dflow.conformance.target=127.0.0.1:9010` from
+  the ankka-flow repository. Every case is named; a failure names the conversation that broke.

ankka_flow-0.1.0/proto/fixtures/conversations/run.batch-order-within-partition.json

@@ -0,0 +1,46 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "echo",
+          "offset": 0,
+          "value_base64": "eyJuIjowfQ=="
+        }
+      ]
+    },
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "echo",
+          "offset": 1,
+          "value_base64": "eyJuIjoxfQ=="
+        }
+      ]
+    },
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "echo",
+          "offset": 2,
+          "value_base64": "eyJuIjoyfQ=="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 1,
+    "mode": "echo"
+  },
+  "description": "Three sequential batches on one partition, acked in order.",
+  "name": "run.batch-order-within-partition"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.config-applied.json

@@ -0,0 +1,22 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "multiply",
+          "offset": 0,
+          "value_base64": "eyJuIjoxfQ=="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 3,
+    "mode": "echo"
+  },
+  "description": "Three emits: the factor from Start.config_json.",
+  "name": "run.config-applied"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.echo-preserves-record.json

@@ -0,0 +1,31 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [
+            {
+              "key": "ce_type",
+              "value_base64": "SXRlbUFkZGVk"
+            },
+            {
+              "key": "raw",
+              "value_base64": "AP8qf4A="
+            }
+          ],
+          "key": "echo",
+          "offset": 7,
+          "value_base64": "eyJ0b3RhbCI6M30="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 1,
+    "mode": "echo"
+  },
+  "description": "One Emit to out with the same key, headers in order and value bytes; then Ack.",
+  "name": "run.echo-preserves-record"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.emits-precede-ack.json

@@ -0,0 +1,22 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "multiply",
+          "offset": 0,
+          "value_base64": "eyJuIjoxfQ=="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 5,
+    "mode": "echo"
+  },
+  "description": "Five emits, then Ack; nothing after.",
+  "name": "run.emits-precede-ack"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.fail-sends-fail.json

@@ -0,0 +1,22 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "fail",
+          "offset": 0,
+          "value_base64": "eyJuIjoxfQ=="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 1,
+    "mode": "echo"
+  },
+  "description": "Fail with a message, no emits.",
+  "name": "run.fail-sends-fail"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.fan-out.json

@@ -0,0 +1,22 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "fan",
+          "offset": 0,
+          "value_base64": "eyJuIjoxfQ=="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 1,
+    "mode": "echo"
+  },
+  "description": "Emits to out then other; then Ack.",
+  "name": "run.fan-out"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.header-order.json

@@ -0,0 +1,39 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [
+            {
+              "key": "a",
+              "value_base64": "MQ=="
+            },
+            {
+              "key": "b",
+              "value_base64": "Mg=="
+            },
+            {
+              "key": "c",
+              "value_base64": "Mw=="
+            },
+            {
+              "key": "d",
+              "value_base64": "AP8qf4A="
+            }
+          ],
+          "key": "header-echo",
+          "offset": 0,
+          "value_base64": "eyJuIjoxfQ=="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 1,
+    "mode": "echo"
+  },
+  "description": "Headers reversed, bytes intact.",
+  "name": "run.header-order"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.large-record.json

@@ -0,0 +1,25 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "echo",
+          "offset": 0,
+          "value_repeat": {
+            "byte": "x",
+            "count": 3145728
+          }
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 1,
+    "mode": "echo"
+  },
+  "description": "A 3 MiB value echoed intact.",
+  "name": "run.large-record"
+}

ankka_flow-0.1.0/proto/fixtures/conversations/run.rogue-outlet.json

@@ -0,0 +1,22 @@
+{
+  "batches": [
+    {
+      "inlet": "in",
+      "partition": 0,
+      "records": [
+        {
+          "headers": [],
+          "key": "rogue-outlet",
+          "offset": 0,
+          "value_base64": "eyJuIjoxfQ=="
+        }
+      ]
+    }
+  ],
+  "config": {
+    "factor": 1,
+    "mode": "echo"
+  },
+  "description": "The streamlet tries to emit to an undeclared outlet: the SDK fails the batch, or the sidecar fails the stream.",
+  "name": "run.rogue-outlet"
+}