From d974be4eee60dcfd515e135b8bd839779b0f4ddc Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 7 May 2026 12:39:14 +0000
Subject: [PATCH 1/4] Add Streams and Chat Bots guides driven by Effect API
 modes

Document the new Effect API `mode` option (speculative, unordered, ordered,
unorderedAfterCommit, orderedAfterCommit) and add per-tool guides showing how
to replace rindexer's YAML-based streams/chatbots with handler code:

- Streams: Webhooks, Kafka, RabbitMQ, AWS SNS/SQS, Redis Streams, Cloudflare Queues
- Chat Bots: Telegram, Discord, Slack, Twilio, PagerDuty, OpsGenie

Each page covers client install/setup, the createEffect definition with the
appropriate after-commit mode, and a handler that uses normal TypeScript
conditionals in place of rindexer's filter expressions and message templates.
---
 docs/HyperIndex/Advanced/effect-api.md       |  87 ++++++++++---
 docs/HyperIndex/Chatbots/discord.md          |  98 ++++++++++++++
 docs/HyperIndex/Chatbots/index.md            |  48 +++++++
 docs/HyperIndex/Chatbots/opsgenie.md         | 112 ++++++++++++++++
 docs/HyperIndex/Chatbots/pagerduty.md        | 112 ++++++++++++++++
 docs/HyperIndex/Chatbots/slack.md            |  95 ++++++++++++++
 docs/HyperIndex/Chatbots/telegram.md         | 109 ++++++++++++++++
 docs/HyperIndex/Chatbots/twilio.md           | 122 ++++++++++++++++++
 docs/HyperIndex/Streams/cloudflare-queues.md |  91 +++++++++++++
 docs/HyperIndex/Streams/index.md             |  41 ++++++
 docs/HyperIndex/Streams/kafka.md             | 126 ++++++++++++++++++
 docs/HyperIndex/Streams/rabbitmq.md          | 109 ++++++++++++++++
 docs/HyperIndex/Streams/redis.md             |  91 +++++++++++++
 docs/HyperIndex/Streams/sns-sqs.md           | 128 +++++++++++++++++++
 docs/HyperIndex/Streams/webhooks.md          |  94 ++++++++++++++
 sidebarsHyperIndex.js                        |  26 ++++
 16 files changed, 1470 insertions(+), 19 deletions(-)
 create mode 100644 docs/HyperIndex/Chatbots/discord.md
 create mode 100644 docs/HyperIndex/Chatbots/index.md
 create mode 100644 docs/HyperIndex/Chatbots/opsgenie.md
 create mode 100644 docs/HyperIndex/Chatbots/pagerduty.md
 create mode 100644 docs/HyperIndex/Chatbots/slack.md
 create mode 100644 docs/HyperIndex/Chatbots/telegram.md
 create mode 100644 docs/HyperIndex/Chatbots/twilio.md
 create mode 100644 docs/HyperIndex/Streams/cloudflare-queues.md
 create mode 100644 docs/HyperIndex/Streams/index.md
 create mode 100644 docs/HyperIndex/Streams/kafka.md
 create mode 100644 docs/HyperIndex/Streams/rabbitmq.md
 create mode 100644 docs/HyperIndex/Streams/redis.md
 create mode 100644 docs/HyperIndex/Streams/sns-sqs.md
 create mode 100644 docs/HyperIndex/Streams/webhooks.md

diff --git a/docs/HyperIndex/Advanced/effect-api.md b/docs/HyperIndex/Advanced/effect-api.md
index 563e33ac..7e0bb685 100644
--- a/docs/HyperIndex/Advanced/effect-api.md
+++ b/docs/HyperIndex/Advanced/effect-api.md
@@ -51,9 +51,10 @@ The first argument is an options object that describes the effect:
 
 - `name` (required) - the name of the effect used for debugging and logging
 - `input` (required) - the input type of the effect
-- `output` (required) - the output type of the effect
+- `output` (required) - the output type of the effect (not required for `unorderedAfterCommit` and `orderedAfterCommit` modes which return `void`)
 - `rateLimit` (required) - the maximum calls allowed per timeframe, or `false` to disable
 - `cache` (optional) - save effect results in the database to prevent duplicate calls (Starting from `envio@2.26.0`)
+- `mode` (optional) - the execution intent of the effect. Defaults to `speculative`. See [Execution Modes](#execution-modes).
 
 The second argument is a function that will be called with the effect's input.
 
@@ -213,6 +214,63 @@ export const getBalance = createEffect(
 Watch the following video to learn more about createEffect and other updates introduced in [v2.32.0](https://github.com/enviodev/hyperindex/releases/tag/v2.32.0).
 <Video id="yvUVzV1ifig" title="Envio v2.32.0" />
 
+### Execution Modes
+
+The `mode` option controls **when** the effect runs, **how** it's ordered relative to other effect calls in the batch, and what `context.effect` returns. One constructor, one call verb — behavior shifts on `mode`.
+
+| Mode | Input | Order | Timing | Returns | Use case |
+| --- | --- | --- | --- | --- | --- |
+| `speculative` *(default)* | maybe-wrong | unordered | preload (parallel) | value | RPC reads, fetch, IPFS — the default behavior |
+| `unordered` | correct | unordered | inline (parallel within batch) | value | parallel reads/writes with verified input where order doesn't matter |
+| `ordered` | correct | in-order | inline (sequential pass) | value | low-latency writes where order matters (e.g. depends on prior entity writes in the same batch) |
+| `unorderedAfterCommit` | correct | unordered | after DB commit | `void` | high-throughput sends, fire-and-forget webhooks, partitioned Kafka |
+| `orderedAfterCommit` | correct | in-order | after DB commit | `void` | sends where order matters (Telegram, ordered streams) |
+
+The two `*AfterCommit` modes are the right choice for **outbound messaging** — Redis, Kafka, RabbitMQ, SNS/SQS, Telegram, Discord, Slack, webhooks. They fire only after the batch's database transaction commits, so a downstream consumer never sees a message for a state that didn't actually persist. They also return `void`, so you don't need to `await` the call from your handler — the runtime takes care of dispatching after commit.
+
+```typescript
+import { createEffect, S } from "envio";
+
+const notifyLargeSwap = createEffect(
+  {
+    name: "notifyLargeSwap",
+    input: { usd: S.bigint, blockNumber: S.number },
+    mode: "orderedAfterCommit",
+  },
+  async ({ input }) => {
+    const text = `Large swap: $${input.usd.toLocaleString()} in block ${input.blockNumber}`;
+    await fetch(`https://api.telegram.org/bot${process.env.TG_BOT_TOKEN}/sendMessage`, {
+      method: "POST",
+      body: JSON.stringify({
+        chat_id: process.env.TG_CHAT_ID,
+        text,
+      }),
+    });
+  }
+);
+
+Pool.Swap.handler(async ({ event, context }) => {
+  const usd = event.params.amount;
+  if (usd > 1_000_000n) {
+    context.effect(notifyLargeSwap, {
+      usd,
+      blockNumber: event.block.number,
+    });
+    // no await — orderedAfterCommit returns void; runtime fires it after the batch's DB commit
+  }
+});
+```
+
+#### When to pick which mode
+
+- **`speculative`** — your call is idempotent, the input may not be final (preloading runs handlers ahead of confirmed state), and you only need a value back. RPC `eth_call`s, `fetch` of IPFS metadata, and any read where retries are cheap belong here.
+- **`unordered`** — you've already verified the input (e.g. derived it from a committed entity) and the work is parallel-safe. Use this for batched reads/writes that don't depend on each other.
+- **`ordered`** — the effect's correctness depends on something written earlier in the same batch. The runtime will run these calls sequentially in handler order.
+- **`unorderedAfterCommit`** — fire-and-forget sends where ordering doesn't matter: partitioned Kafka topics, Redis Streams keyed by tx hash, generic webhooks. Highest throughput.
+- **`orderedAfterCommit`** — sends to a single ordered destination: a Telegram chat, a Slack channel, a single Kafka partition. The runtime preserves handler order across the batch.
+
+This mode is what makes the Effect API a good fit for **streams and chat bots** — you describe what to send and where, the runtime handles batching, ordering, and at-least-once delivery semantics. See the [Streams](/docs/HyperIndex/streams) and [Chat Bots](/docs/HyperIndex/chatbots) guides for end-to-end examples per provider.
+
 ### Sending Notifications (Webhooks)
 
 You can use the Effect API to send push notifications or webhook calls when specific events occur. This is useful for alerting systems, Discord/Slack bots, or triggering downstream workflows.
@@ -227,26 +285,18 @@ export const sendWebhook = createEffect(
       event: S.string,
       data: S.string,
     },
-    output: S.boolean,
     rateLimit: {
       calls: 10,
       per: "second",
     },
-    // Don't cache webhook calls - we want them to fire every time
-    cache: false,
+    mode: "unorderedAfterCommit",
   },
   async ({ input, context }) => {
-    try {
-      await fetch("https://your-webhook-url.com/notify", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ event: input.event, data: input.data }),
-      });
-      return true;
-    } catch (error) {
-      context.log.error(`Webhook failed: ${error}`);
-      return false;
-    }
+    await fetch("https://your-webhook-url.com/notify", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ event: input.event, data: input.data }),
+    });
   }
 );
 ```
@@ -255,7 +305,7 @@ Then call it from your handler:
 
 ```typescript
 MyContract.LargeTransfer.handler(async ({ event, context }) => {
-  await context.effect(sendWebhook, {
+  context.effect(sendWebhook, {
     event: "large_transfer",
     data: JSON.stringify({
       from: event.params.from,
@@ -263,12 +313,11 @@ MyContract.LargeTransfer.handler(async ({ event, context }) => {
       amount: event.params.value.toString(),
     }),
   });
+  // no await — `unorderedAfterCommit` returns void and dispatches after the DB commit
 });
 ```
 
-:::warning
-Webhook effects will fire on every indexer re-run unless you set `cache: true`. If you cache them, the webhook will only fire once per unique input. Consider which behavior is appropriate for your use case.
-:::
+Because the effect runs **after** the batch's DB commit, the webhook will only fire for state that actually persisted — a reorg or a failed batch never produces a phantom notification. For send-only effects you typically don't need `cache: true`; the mode itself prevents duplicate sends within a successful run.
 
 ### Migrate from Experimental
 
diff --git a/docs/HyperIndex/Chatbots/discord.md b/docs/HyperIndex/Chatbots/discord.md
new file mode 100644
index 00000000..e4232207
--- /dev/null
+++ b/docs/HyperIndex/Chatbots/discord.md
@@ -0,0 +1,98 @@
+---
+id: chatbots-discord
+title: Discord
+sidebar_label: Discord
+slug: /chatbots/discord
+description: Send Discord messages from HyperIndex handlers using the Effect API.
+---
+
+Post messages to a Discord channel using either an [incoming webhook](https://support.discord.com/hc/en-us/articles/228383668) (simplest) or a bot token. Both work with raw `fetch`.
+
+### Channel setup
+
+1. Channel **Settings → Integrations → Webhooks → New Webhook**.
+2. Copy the webhook URL.
+3. Set `DISCORD_WEBHOOK_URL` in your `.env`.
+
+### Define the effect
+
+```typescript title="src/effects/discord.ts"
+import { createEffect, S } from "envio";
+
+export const sendDiscord = createEffect(
+  {
+    name: "sendDiscord",
+    input: {
+      content: S.string,
+      embedsJson: S.optional(S.string), // JSON-encoded embeds array
+    },
+    rateLimit: { calls: 5, per: "second" }, // Discord webhook limit
+    mode: "orderedAfterCommit",
+  },
+  async ({ input, context }) => {
+    const res = await fetch(process.env.DISCORD_WEBHOOK_URL!, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        content: input.content,
+        embeds: input.embedsJson ? JSON.parse(input.embedsJson) : undefined,
+        allowed_mentions: { parse: [] },
+      }),
+    });
+    if (!res.ok) {
+      context.log.error(`Discord failed: ${res.status} ${await res.text()}`);
+      throw new Error(`Discord ${res.status}`);
+    }
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer template…
+
+```yaml
+chat:
+  discord:
+    - messages:
+        - event_name: Transfer
+          filter_expression: "value >= 10 && value <= 2000000000000000000"
+          template_inline: |
+            *New RETH Transfer Event*
+            from: {{from}}
+            to: {{to}}
+            amount: {{format_value(value, 18)}}
+            contract: {{transaction_information.address}}
+            [etherscan](https://etherscan.io/tx/{{transaction_information.transaction_hash}})
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { sendDiscord } from "./effects/discord";
+import { formatUnits } from "./utils/format";
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (value < 10n || value > 2_000_000_000_000_000_000n) return;
+
+  context.effect(sendDiscord, {
+    content: "**New RETH Transfer Event**",
+    embedsJson: JSON.stringify([
+      {
+        title: `${formatUnits(value)} RETH transferred`,
+        url: `https://etherscan.io/tx/${event.transaction.hash}`,
+        fields: [
+          { name: "From", value: from, inline: true },
+          { name: "To", value: to, inline: true },
+          { name: "Contract", value: event.srcAddress },
+        ],
+      },
+    ]),
+  });
+});
+```
+
+Discord embeds give you richer formatting than plain text — fields, colors, thumbnails — without any extra dependency. If you'd rather keep things simple, just send `content` as a markdown string and skip `embeds`.
diff --git a/docs/HyperIndex/Chatbots/index.md b/docs/HyperIndex/Chatbots/index.md
new file mode 100644
index 00000000..4260affc
--- /dev/null
+++ b/docs/HyperIndex/Chatbots/index.md
@@ -0,0 +1,48 @@
+---
+id: chatbots
+title: Chat Bots
+sidebar_label: Overview
+slug: /chatbots
+description: Send on-chain notifications from HyperIndex to Telegram, Discord, Slack, Twilio, PagerDuty, or OpsGenie.
+---
+
+Chat bots in HyperIndex are just [Effects](/docs/HyperIndex/effect-api) running in `orderedAfterCommit` mode that call a chat platform's API. There is no separate templating language and no separate config file — you build your message string with template literals and decide when to send it with normal `if` statements.
+
+### Why `orderedAfterCommit`?
+
+Chat platforms display messages in arrival order to humans, so you almost always want **ordered** delivery. The runtime preserves the order of `context.effect(...)` calls across the entire batch, then dispatches them sequentially after the DB commit. The `AfterCommit` half guarantees you never message users about a state that was rolled back by a reorg or a failed batch.
+
+If you don't care about order across events (e.g. one alert per swap, no relation between alerts), you can use `unorderedAfterCommit` for higher throughput.
+
+### Comparison with rindexer
+
+| rindexer | HyperIndex |
+| --- | --- |
+| `chat:` block in YAML, one entry per provider | A `createEffect({ mode: "orderedAfterCommit" })` per destination |
+| `filter_expression: "value >= 10 && from = '0x…'"` | A regular TypeScript `if` |
+| `template_inline` Mustache template | Template literal (full TypeScript expressions inside `${...}`) |
+| 10-block max range hard-coded | Use the rate-limit option to tune throughput |
+
+### Supported platforms
+
+- [Telegram](/docs/HyperIndex/chatbots/telegram)
+- [Discord](/docs/HyperIndex/chatbots/discord)
+- [Slack](/docs/HyperIndex/chatbots/slack)
+- [Twilio (SMS)](/docs/HyperIndex/chatbots/twilio)
+- [PagerDuty](/docs/HyperIndex/chatbots/pagerduty)
+- [OpsGenie](/docs/HyperIndex/chatbots/opsgenie)
+
+### Helper: human-readable token amounts
+
+Most examples below use a small `formatUnits` helper instead of rindexer's `{{format_value(value, 18)}}`:
+
+```typescript title="src/utils/format.ts"
+export const formatUnits = (value: bigint, decimals = 18) => {
+  const base = 10n ** BigInt(decimals);
+  const whole = value / base;
+  const frac = value % base;
+  if (frac === 0n) return whole.toString();
+  const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${whole}.${fracStr}`;
+};
+```
diff --git a/docs/HyperIndex/Chatbots/opsgenie.md b/docs/HyperIndex/Chatbots/opsgenie.md
new file mode 100644
index 00000000..5dab6954
--- /dev/null
+++ b/docs/HyperIndex/Chatbots/opsgenie.md
@@ -0,0 +1,112 @@
+---
+id: chatbots-opsgenie
+title: OpsGenie
+sidebar_label: OpsGenie
+slug: /chatbots/opsgenie
+description: Create OpsGenie alerts from HyperIndex handlers using the Effect API.
+---
+
+Create OpsGenie alerts using the [Alert API](https://docs.opsgenie.com/docs/alert-api). One JSON `POST` — no SDK required.
+
+### Integration setup
+
+1. OpsGenie → **Settings → Integrations → API**, then copy the API key.
+2. Set `OPSGENIE_API_KEY` in your `.env`.
+3. Use `https://api.opsgenie.com` (US) or `https://api.eu.opsgenie.com` (EU) as the host.
+
+### Define the effect
+
+```typescript title="src/effects/opsgenie.ts"
+import { createEffect, S } from "envio";
+
+type Priority = "P1" | "P2" | "P3" | "P4" | "P5";
+
+export const createOpsGenieAlert = createEffect(
+  {
+    name: "createOpsGenieAlert",
+    input: {
+      message: S.string,
+      priority: S.string, // Priority
+      alias: S.optional(S.string),
+      description: S.optional(S.string),
+      detailsJson: S.optional(S.string), // JSON-encoded details map
+    },
+    rateLimit: { calls: 100, per: "minute" },
+    mode: "orderedAfterCommit",
+  },
+  async ({ input, context }) => {
+    const res = await fetch("https://api.opsgenie.com/v2/alerts", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `GenieKey ${process.env.OPSGENIE_API_KEY}`,
+      },
+      body: JSON.stringify({
+        message: input.message,
+        priority: input.priority as Priority,
+        alias: input.alias,
+        description: input.description,
+        details: input.detailsJson ? JSON.parse(input.detailsJson) : undefined,
+        source: "hyperindex",
+      }),
+    });
+    if (!res.ok) {
+      context.log.error(`OpsGenie failed: ${res.status} ${await res.text()}`);
+      throw new Error(`OpsGenie ${res.status}`);
+    }
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+chat:
+  opsgenie:
+    - api_key: ${OPSGENIE_API_KEY}
+      priority: P1
+      messages:
+        - event_name: Transfer
+          filter_expression: "from = '0x0338ce5020c447f7e668dc2ef778025ce3982662' && value >= 10"
+          template_inline: |
+            New RETH Transfer Event
+            from: {{from}}
+            to: {{to}}
+            amount: {{format_value(value, 18)}}
+            etherscan: https://etherscan.io/tx/{{transaction_information.transaction_hash}}
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { createOpsGenieAlert } from "./effects/opsgenie";
+import { formatUnits } from "./utils/format";
+
+const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+  if (from.toLowerCase() !== WHALE || value < 10n) return;
+
+  context.effect(createOpsGenieAlert, {
+    priority: "P1",
+    message: `Whale moved ${formatUnits(value)} RETH`,
+    alias: event.transaction.hash, // dedup across reruns
+    description: [
+      `from: ${from}`,
+      `to: ${to}`,
+      `amount: ${formatUnits(value, 18)}`,
+      `etherscan: https://etherscan.io/tx/${event.transaction.hash}`,
+    ].join("\n"),
+    detailsJson: JSON.stringify({
+      chainId: event.chainId,
+      block: event.block.number,
+    }),
+  });
+});
+```
+
+`alias` deduplicates alerts in OpsGenie — keep it stable per logical event (e.g. the tx hash) to avoid duplicate alerts on indexer reruns.
diff --git a/docs/HyperIndex/Chatbots/pagerduty.md b/docs/HyperIndex/Chatbots/pagerduty.md
new file mode 100644
index 00000000..bf559316
--- /dev/null
+++ b/docs/HyperIndex/Chatbots/pagerduty.md
@@ -0,0 +1,112 @@
+---
+id: chatbots-pagerduty
+title: PagerDuty
+sidebar_label: PagerDuty
+slug: /chatbots/pagerduty
+description: Trigger PagerDuty incidents from HyperIndex handlers using the Effect API.
+---
+
+Trigger PagerDuty incidents using the [Events API v2](https://developer.pagerduty.com/docs/ZG9jOjExMDI5NTgw-events-api-v2-overview). No SDK needed — it's a single JSON `POST`.
+
+### Integration setup
+
+1. PagerDuty → **Services → Service Directory → your service → Integrations → Add → Events API v2**.
+2. Copy the **Integration Key** (a.k.a. routing key).
+3. Set `PAGERDUTY_ROUTING_KEY` in your `.env`.
+
+### Define the effect
+
+```typescript title="src/effects/pagerduty.ts"
+import { createEffect, S } from "envio";
+
+type Severity = "info" | "warning" | "error" | "critical";
+
+export const triggerPagerDuty = createEffect(
+  {
+    name: "triggerPagerDuty",
+    input: {
+      severity: S.string, // Severity
+      summary: S.string,
+      source: S.string,
+      dedupKey: S.optional(S.string),
+      detailsJson: S.optional(S.string), // JSON-encoded custom_details
+    },
+    rateLimit: { calls: 60, per: "minute" },
+    mode: "orderedAfterCommit",
+  },
+  async ({ input, context }) => {
+    const res = await fetch("https://events.pagerduty.com/v2/enqueue", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        routing_key: process.env.PAGERDUTY_ROUTING_KEY,
+        event_action: "trigger",
+        dedup_key: input.dedupKey,
+        payload: {
+          summary: input.summary,
+          source: input.source,
+          severity: input.severity as Severity,
+          custom_details: input.detailsJson
+            ? JSON.parse(input.detailsJson)
+            : undefined,
+        },
+      }),
+    });
+    if (!res.ok) {
+      context.log.error(`PagerDuty failed: ${res.status} ${await res.text()}`);
+      throw new Error(`PagerDuty ${res.status}`);
+    }
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+chat:
+  pagerduty:
+    - routing_key: ${PAGERDUTY_ROUTING_KEY}
+      severity: critical
+      messages:
+        - event_name: Transfer
+          filter_expression: "from = '0x0338ce5020c447f7e668dc2ef778025ce3982662' && value >= 10"
+          template_inline: |
+            New RETH Transfer Event
+            from: {{from}}
+            to: {{to}}
+            amount: {{format_value(value, 18)}}
+            link: https://etherscan.io/tx/{{transaction_information.transaction_hash}}
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { triggerPagerDuty } from "./effects/pagerduty";
+import { formatUnits } from "./utils/format";
+
+const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+  if (from.toLowerCase() !== WHALE || value < 10n) return;
+
+  context.effect(triggerPagerDuty, {
+    severity: "critical",
+    summary: `Whale moved ${formatUnits(value)} RETH`,
+    source: event.srcAddress,
+    // dedup_key prevents one alert per event from spamming PagerDuty if you re-run
+    dedupKey: event.transaction.hash,
+    detailsJson: JSON.stringify({
+      from,
+      to,
+      value: value.toString(),
+      link: `https://etherscan.io/tx/${event.transaction.hash}`,
+    }),
+  });
+});
+```
+
+`dedupKey` is the cleanest way to guarantee at-most-one incident per transaction even across reruns.
diff --git a/docs/HyperIndex/Chatbots/slack.md b/docs/HyperIndex/Chatbots/slack.md
new file mode 100644
index 00000000..67bce9d8
--- /dev/null
+++ b/docs/HyperIndex/Chatbots/slack.md
@@ -0,0 +1,95 @@
+---
+id: chatbots-slack
+title: Slack
+sidebar_label: Slack
+slug: /chatbots/slack
+description: Send Slack messages from HyperIndex handlers using the Effect API.
+---
+
+Post to a Slack channel using either an [incoming webhook](https://api.slack.com/messaging/webhooks) (no SDK needed) or the [Web API](https://api.slack.com/web) with `@slack/web-api`. The webhook flow is shown below.
+
+### Channel setup
+
+1. Create a Slack app and enable **Incoming Webhooks**.
+2. Add a new webhook for the target channel and copy the URL.
+3. Set `SLACK_WEBHOOK_URL` in your `.env`.
+
+### Define the effect
+
+```typescript title="src/effects/slack.ts"
+import { createEffect, S } from "envio";
+
+export const sendSlack = createEffect(
+  {
+    name: "sendSlack",
+    input: {
+      text: S.string,
+      blocksJson: S.optional(S.string), // JSON-encoded Block Kit array
+    },
+    rateLimit: { calls: 1, per: "second" }, // Slack: ~1 msg/sec/channel
+    mode: "orderedAfterCommit",
+  },
+  async ({ input, context }) => {
+    const res = await fetch(process.env.SLACK_WEBHOOK_URL!, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        text: input.text,
+        blocks: input.blocksJson ? JSON.parse(input.blocksJson) : undefined,
+      }),
+    });
+    if (!res.ok) {
+      context.log.error(`Slack failed: ${res.status} ${await res.text()}`);
+      throw new Error(`Slack ${res.status}`);
+    }
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+chat:
+  slack:
+    - bot_token: ${SLACK_BOT_TOKEN}
+      channel: "#RethTransferEvents"
+      messages:
+        - event_name: Transfer
+          filter_expression: "value >= 10 && value <= 2000000000000000000"
+          template_inline: |
+            *New RETH Transfer Event*
+            from: {{from}}
+            to: {{to}}
+            amount: {{format_value(value, 18)}}
+            RETH contract: {{transaction_information.address}}
+            <https://etherscan.io/tx/{{transaction_information.transaction_hash}}|etherscan>
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { sendSlack } from "./effects/slack";
+import { formatUnits } from "./utils/format";
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (value < 10n || value > 2_000_000_000_000_000_000n) return;
+
+  const text = [
+    `*New RETH Transfer Event*`,
+    `from: ${from}`,
+    `to: ${to}`,
+    `amount: ${formatUnits(value, 18)}`,
+    `RETH contract: ${event.srcAddress}`,
+    `<https://etherscan.io/tx/${event.transaction.hash}|etherscan>`,
+  ].join("\n");
+
+  context.effect(sendSlack, { text });
+});
+```
+
+For richer layouts (buttons, headers, dividers) build a [Block Kit](https://api.slack.com/block-kit) array and pass it as `blocksJson: JSON.stringify(blocks)`.
diff --git a/docs/HyperIndex/Chatbots/telegram.md b/docs/HyperIndex/Chatbots/telegram.md
new file mode 100644
index 00000000..8536f779
--- /dev/null
+++ b/docs/HyperIndex/Chatbots/telegram.md
@@ -0,0 +1,109 @@
+---
+id: chatbots-telegram
+title: Telegram
+sidebar_label: Telegram
+slug: /chatbots/telegram
+description: Send Telegram messages from HyperIndex handlers using the Effect API.
+---
+
+Send Telegram messages from your handlers via the [Bot API](https://core.telegram.org/bots/api). No SDK required — just `fetch`.
+
+### Bot setup
+
+1. Open [@BotFather](https://t.me/BotFather) in Telegram, run `/newbot`, and copy the bot token.
+2. Add the bot to a chat (or DM it) and grab the chat ID. The simplest way is to send any message and visit `https://api.telegram.org/bot<token>/getUpdates` — `chat.id` is in the JSON.
+3. Set `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID` in your `.env`.
+
+### Define the effect
+
+```typescript title="src/effects/telegram.ts"
+import { createEffect, S } from "envio";
+
+export const sendTelegram = createEffect(
+  {
+    name: "sendTelegram",
+    input: { chatId: S.string, text: S.string },
+    rateLimit: { calls: 25, per: "second" }, // Telegram limits ~30 msg/sec globally
+    mode: "orderedAfterCommit", // human-readable feed → keep order
+  },
+  async ({ input, context }) => {
+    const res = await fetch(
+      `https://api.telegram.org/bot${process.env.TELEGRAM_BOT_TOKEN}/sendMessage`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          chat_id: input.chatId,
+          text: input.text,
+          parse_mode: "Markdown",
+          disable_web_page_preview: true,
+        }),
+      }
+    );
+    if (!res.ok) {
+      context.log.error(`Telegram failed: ${res.status} ${await res.text()}`);
+      throw new Error(`Telegram ${res.status}`);
+    }
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+chat:
+  telegram:
+    - bot_token: ${TELEGRAM_BOT_TOKEN}
+      chat_id: -4223616270
+      messages:
+        - event_name: Transfer
+          filter_expression: "value >= 10 && value <= 2000000000000000000"
+          template_inline: |
+            *New RETH Transfer Event*
+            from: {{from}}
+            to: {{to}}
+            amount: {{format_value(value, 18)}}
+            RETH contract: {{transaction_information.address}}
+            [etherscan](https://etherscan.io/tx/{{transaction_information.transaction_hash}})
+```
+
+…becomes a regular handler with a template literal:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { sendTelegram } from "./effects/telegram";
+import { formatUnits } from "./utils/format";
+
+const CHAT_ID = process.env.TELEGRAM_CHAT_ID!;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (value < 10n || value > 2_000_000_000_000_000_000n) return;
+
+  const text = [
+    `*New RETH Transfer Event*`,
+    `from: ${from}`,
+    `to: ${to}`,
+    `amount: ${formatUnits(value, 18)}`,
+    `RETH contract: ${event.srcAddress}`,
+    `[etherscan](https://etherscan.io/tx/${event.transaction.hash})`,
+  ].join("\n");
+
+  context.effect(sendTelegram, { chatId: CHAT_ID, text });
+});
+```
+
+### Multiple chats / multiple alerts
+
+Just add more `if` blocks. There's no fixed schema — different events can route to different `chatId`s, and you can build totally different messages for the same event:
+
+```typescript
+if (value >= 1_000_000_000_000_000_000_000n) {
+  context.effect(sendTelegram, { chatId: WHALE_CHAT, text: `🐋 ${formatUnits(value)}` });
+} else if (value >= 100_000_000_000_000_000_000n) {
+  context.effect(sendTelegram, { chatId: NOTABLE_CHAT, text: `Heads up: ${formatUnits(value)}` });
+}
+```
diff --git a/docs/HyperIndex/Chatbots/twilio.md b/docs/HyperIndex/Chatbots/twilio.md
new file mode 100644
index 00000000..2d12b8cd
--- /dev/null
+++ b/docs/HyperIndex/Chatbots/twilio.md
@@ -0,0 +1,122 @@
+---
+id: chatbots-twilio
+title: Twilio (SMS)
+sidebar_label: Twilio (SMS)
+slug: /chatbots/twilio
+description: Send SMS notifications from HyperIndex handlers using the Effect API and Twilio.
+---
+
+Send SMS messages via [Twilio's Programmable Messaging API](https://www.twilio.com/docs/sms). You can use the official SDK or hit the REST endpoint directly with `fetch`.
+
+### Account setup
+
+From the Twilio Console grab:
+
+- `TWILIO_ACCOUNT_SID`
+- `TWILIO_AUTH_TOKEN`
+- `TWILIO_FROM_NUMBER` (in E.164 format, e.g. `+15551234567`)
+
+### Installation (SDK)
+
+```bash
+pnpm add twilio
+```
+
+### Configure the client
+
+```typescript title="src/clients/twilio.ts"
+import twilio from "twilio";
+
+export const twilioClient = twilio(
+  process.env.TWILIO_ACCOUNT_SID!,
+  process.env.TWILIO_AUTH_TOKEN!
+);
+```
+
+### Define the effect
+
+```typescript title="src/effects/twilio.ts"
+import { createEffect, S } from "envio";
+import { twilioClient } from "../clients/twilio";
+
+export const sendSms = createEffect(
+  {
+    name: "sendSms",
+    input: { to: S.string, body: S.string },
+    rateLimit: { calls: 1, per: "second" }, // Twilio default trial = 1 msg/sec
+    mode: "orderedAfterCommit",
+  },
+  async ({ input }) => {
+    await twilioClient.messages.create({
+      from: process.env.TWILIO_FROM_NUMBER!,
+      to: input.to,
+      body: input.body,
+    });
+  }
+);
+```
+
+### Raw `fetch` alternative
+
+If you'd rather skip the SDK:
+
+```typescript
+const auth = Buffer.from(
+  `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
+).toString("base64");
+
+await fetch(
+  `https://api.twilio.com/2010-04-01/Accounts/${process.env.TWILIO_ACCOUNT_SID}/Messages.json`,
+  {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${auth}`,
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: new URLSearchParams({
+      From: process.env.TWILIO_FROM_NUMBER!,
+      To: input.to,
+      Body: input.body,
+    }),
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+chat:
+  twilio:
+    - account_sid: ${TWILIO_ACCOUNT_SID}
+      auth_token: ${TWILIO_AUTH_TOKEN}
+      from_number: ${TWILIO_FROM_NUMBER}
+      to_number: ${TWILIO_TO_NUMBER}
+      messages:
+        - event_name: Transfer
+          filter_expression: "value >= 10"
+          template_inline: "Transfer detected: {{value}} tokens"
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { sendSms } from "./effects/twilio";
+import { formatUnits } from "./utils/format";
+
+const TO = process.env.TWILIO_TO_NUMBER!;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { value } = event.params;
+  if (value < 10n) return;
+
+  context.effect(sendSms, {
+    to: TO,
+    body: `Transfer detected: ${formatUnits(value)} RETH`,
+  });
+});
+```
+
+SMS is rate-limited and expensive — keep your conditions strict.
diff --git a/docs/HyperIndex/Streams/cloudflare-queues.md b/docs/HyperIndex/Streams/cloudflare-queues.md
new file mode 100644
index 00000000..f93cde99
--- /dev/null
+++ b/docs/HyperIndex/Streams/cloudflare-queues.md
@@ -0,0 +1,91 @@
+---
+id: streams-cloudflare-queues
+title: Cloudflare Queues
+sidebar_label: Cloudflare Queues
+slug: /streams/cloudflare-queues
+description: Stream decoded events from HyperIndex to Cloudflare Queues using the Effect API.
+---
+
+Cloudflare Queues exposes a [REST API](https://developers.cloudflare.com/api/operations/queue-publish-message) for sending messages, so no SDK is required — just `fetch`.
+
+### Installation
+
+Nothing to install.
+
+### Define the effect
+
+```typescript title="src/effects/cloudflare.ts"
+import { createEffect, S } from "envio";
+
+const ENDPOINT = (queueId: string) =>
+  `https://api.cloudflare.com/client/v4/accounts/${process.env.CLOUDFLARE_ACCOUNT_ID}/queues/${queueId}/messages`;
+
+export const sendToCloudflareQueue = createEffect(
+  {
+    name: "sendToCloudflareQueue",
+    input: {
+      queueId: S.string,
+      body: S.string, // JSON-encoded
+    },
+    rateLimit: { calls: 100, per: "second" },
+    mode: "unorderedAfterCommit",
+  },
+  async ({ input, context }) => {
+    const res = await fetch(ENDPOINT(input.queueId), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${process.env.CLOUDFLARE_API_TOKEN}`,
+      },
+      body: JSON.stringify({ body: input.body, content_type: "json" }),
+    });
+    if (!res.ok) {
+      context.log.error(`CF Queues failed: ${res.status} ${await res.text()}`);
+      throw new Error(`CF Queues ${res.status}`);
+    }
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+streams:
+  cloudflare_queues:
+    queues:
+      - queue_id: blockchain-transfers
+        events:
+          - event_name: Transfer
+            conditions:
+              - "value": ">=2000000000000000000"
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { sendToCloudflareQueue } from "./effects/cloudflare";
+
+const MIN = 2_000_000_000_000_000_000n;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (value >= MIN) {
+    context.effect(sendToCloudflareQueue, {
+      queueId: "blockchain-transfers",
+      body: JSON.stringify({
+        from,
+        to,
+        value: value.toString(),
+        txHash: event.transaction.hash,
+        chainId: event.chainId,
+      }),
+    });
+  }
+});
+```
+
+Use `orderedAfterCommit` if your queue consumer relies on per-batch ordering.
diff --git a/docs/HyperIndex/Streams/index.md b/docs/HyperIndex/Streams/index.md
new file mode 100644
index 00000000..93e2a502
--- /dev/null
+++ b/docs/HyperIndex/Streams/index.md
@@ -0,0 +1,41 @@
+---
+id: streams
+title: Streams
+sidebar_label: Overview
+slug: /streams
+description: Stream decoded blockchain events from HyperIndex to Webhooks, Kafka, RabbitMQ, SNS/SQS, Redis Streams, or Cloudflare Queues.
+---
+
+HyperIndex can publish decoded events to any external system from inside your handlers. Streams are not a separate subsystem — they're [Effects](/docs/HyperIndex/effect-api) running in `unorderedAfterCommit` or `orderedAfterCommit` mode, which means:
+
+- The send fires **after** the batch's database transaction commits, so a reorg or a failed batch never produces a phantom message.
+- You write **normal handler code** to decide what to send and when. There is no separate YAML for filters or routing — you call `context.effect(...)` inside an `if` block, just like any other branching logic.
+- You can install and configure any client SDK you want (`kafkajs`, `ioredis`, `amqplib`, `@aws-sdk/client-sns`, …) or just use raw `fetch`. The Effect API only cares about the function body.
+
+### Comparison with rindexer
+
+| rindexer | HyperIndex |
+| --- | --- |
+| YAML `streams:` block per contract | A `createEffect({ mode: "unorderedAfterCommit" \| "orderedAfterCommit" })` definition |
+| `conditions:` mini-language with `>=`, `&&`, `\|\|` | Plain TypeScript `if (...)` in your handler |
+| `template_inline` Mustache-style templates | Template literals / any string-building code you want |
+| Per-provider client baked into the binary | Use any npm package, or raw `fetch` |
+| Fires per event, no DB-commit guarantee | Fires after DB commit, so streams reflect persisted state |
+
+### Choosing a mode
+
+- **`unorderedAfterCommit`** — fire-and-forget, parallel dispatch. Best for partitioned destinations (Kafka with a partition key, Redis Streams keyed by tx hash, generic webhooks).
+- **`orderedAfterCommit`** — preserves the order in which `context.effect(...)` was called across the batch. Use for single-stream destinations like a Telegram chat, a Slack channel, or a single Kafka partition.
+
+### Supported tools
+
+Each tool has a dedicated page with installation, configuration, and a full handler example:
+
+- [Webhooks](/docs/HyperIndex/streams/webhooks)
+- [Kafka](/docs/HyperIndex/streams/kafka)
+- [RabbitMQ](/docs/HyperIndex/streams/rabbitmq)
+- [AWS SNS / SQS](/docs/HyperIndex/streams/sns-sqs)
+- [Redis Streams](/docs/HyperIndex/streams/redis)
+- [Cloudflare Queues](/docs/HyperIndex/streams/cloudflare-queues)
+
+Need something else? Anything reachable from Node — gRPC, NATS, Postgres LISTEN/NOTIFY, GCP Pub/Sub, a custom HTTP service — works the same way: install the client, call it from inside an effect.
diff --git a/docs/HyperIndex/Streams/kafka.md b/docs/HyperIndex/Streams/kafka.md
new file mode 100644
index 00000000..d00a5208
--- /dev/null
+++ b/docs/HyperIndex/Streams/kafka.md
@@ -0,0 +1,126 @@
+---
+id: streams-kafka
+title: Kafka
+sidebar_label: Kafka
+slug: /streams/kafka
+description: Stream decoded events from HyperIndex to Apache Kafka using the Effect API.
+---
+
+Publish decoded events to one or more Kafka topics. Use a partition key to fan out across partitions (with `unorderedAfterCommit`) or pin the topic to a single partition for strict ordering (with `orderedAfterCommit`).
+
+### Installation
+
+```bash
+pnpm add kafkajs
+```
+
+### Configure the client
+
+```typescript title="src/clients/kafka.ts"
+import { Kafka, Partitioners } from "kafkajs";
+
+export const kafka = new Kafka({
+  clientId: "envio-indexer",
+  brokers: (process.env.KAFKA_BROKERS ?? "").split(","),
+  ssl: true,
+  sasl: {
+    mechanism: "plain",
+    username: process.env.KAFKA_USERNAME!,
+    password: process.env.KAFKA_PASSWORD!,
+  },
+});
+
+export const producer = kafka.producer({
+  createPartitioner: Partitioners.DefaultPartitioner,
+  allowAutoTopicCreation: false,
+});
+
+let connected: Promise<void> | undefined;
+export const ensureConnected = () => (connected ??= producer.connect());
+```
+
+### Define the effect
+
+```typescript title="src/effects/kafka.ts"
+import { createEffect, S } from "envio";
+import { ensureConnected, producer } from "../clients/kafka";
+
+export const publishToKafka = createEffect(
+  {
+    name: "publishToKafka",
+    input: {
+      topic: S.string,
+      key: S.string,
+      value: S.string,
+    },
+    rateLimit: { calls: 200, per: "second" },
+    // unordered = parallel dispatch, partition order preserved by `key`
+    mode: "unorderedAfterCommit",
+  },
+  async ({ input }) => {
+    await ensureConnected();
+    await producer.send({
+      topic: input.topic,
+      acks: -1, // "all"
+      messages: [{ key: input.key, value: input.value }],
+    });
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+streams:
+  kafka:
+    topics:
+      - topic: test-topic
+        key: my-routing-key
+        events:
+          - event_name: Transfer
+            conditions:
+              - "value": ">=2000000000000000000"
+              - "from": "0x0338ce5020c447f7e668dc2ef778025ce3982662"
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { publishToKafka } from "./effects/kafka";
+
+const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
+const MIN = 2_000_000_000_000_000_000n;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (from.toLowerCase() === WHALE && value >= MIN) {
+    context.effect(publishToKafka, {
+      topic: "rocketpool.transfers",
+      key: from, // partition by sender so per-sender order is preserved
+      value: JSON.stringify({
+        from,
+        to,
+        value: value.toString(),
+        txHash: event.transaction.hash,
+        blockNumber: event.block.number,
+        chainId: event.chainId,
+      }),
+    });
+  }
+});
+```
+
+### Mode picker
+
+| You need | Mode |
+| --- | --- |
+| High throughput, partition by key | `unorderedAfterCommit` |
+| Strict global order across the whole topic | `orderedAfterCommit` (and a single-partition topic) |
+
+### Raw `fetch` alternative
+
+If you'd rather not pull in `kafkajs`, point the effect at a Kafka REST proxy (e.g. Confluent REST Proxy) and POST JSON instead.
diff --git a/docs/HyperIndex/Streams/rabbitmq.md b/docs/HyperIndex/Streams/rabbitmq.md
new file mode 100644
index 00000000..0e84d7bf
--- /dev/null
+++ b/docs/HyperIndex/Streams/rabbitmq.md
@@ -0,0 +1,109 @@
+---
+id: streams-rabbitmq
+title: RabbitMQ
+sidebar_label: RabbitMQ
+slug: /streams/rabbitmq
+description: Stream decoded events from HyperIndex to RabbitMQ exchanges using the Effect API.
+---
+
+Publish decoded events to a RabbitMQ exchange — `direct`, `topic`, or `fanout` — using `amqplib`.
+
+### Installation
+
+```bash
+pnpm add amqplib
+pnpm add -D @types/amqplib
+```
+
+### Configure the client
+
+```typescript title="src/clients/rabbitmq.ts"
+import amqp from "amqplib";
+
+let chanPromise: Promise<amqp.Channel> | undefined;
+
+export const getChannel = () =>
+  (chanPromise ??= (async () => {
+    const conn = await amqp.connect(process.env.RABBITMQ_URL!);
+    const ch = await conn.createChannel();
+    await ch.assertExchange("transfer", "direct", { durable: true });
+    return ch;
+  })());
+```
+
+### Define the effect
+
+```typescript title="src/effects/rabbitmq.ts"
+import { createEffect, S } from "envio";
+import { getChannel } from "../clients/rabbitmq";
+
+export const publishToRabbit = createEffect(
+  {
+    name: "publishToRabbit",
+    input: {
+      exchange: S.string,
+      routingKey: S.string,
+      body: S.string,
+    },
+    rateLimit: { calls: 200, per: "second" },
+    mode: "unorderedAfterCommit",
+  },
+  async ({ input }) => {
+    const ch = await getChannel();
+    ch.publish(
+      input.exchange,
+      input.routingKey,
+      Buffer.from(input.body),
+      { contentType: "application/json", persistent: true }
+    );
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+streams:
+  rabbitmq:
+    exchanges:
+      - exchange: transfer
+        exchange_type: direct
+        routing_key: my-routing-key
+        events:
+          - event_name: Transfer
+            conditions:
+              - "value": ">=2000000000000000000 && value <=4000000000000000000"
+              - "from": "0x0338ce5020c447f7e668dc2ef778025ce3982662"
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { publishToRabbit } from "./effects/rabbitmq";
+
+const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
+const MIN = 2_000_000_000_000_000_000n;
+const MAX = 4_000_000_000_000_000_000n;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+    context.effect(publishToRabbit, {
+      exchange: "transfer",
+      routingKey: "my-routing-key",
+      body: JSON.stringify({
+        from,
+        to,
+        value: value.toString(),
+        txHash: event.transaction.hash,
+      }),
+    });
+  }
+});
+```
+
+Pick `orderedAfterCommit` if your consumer needs strict per-batch ordering. For `fanout` exchanges, leave `routingKey` as an empty string.
diff --git a/docs/HyperIndex/Streams/redis.md b/docs/HyperIndex/Streams/redis.md
new file mode 100644
index 00000000..319c4f6f
--- /dev/null
+++ b/docs/HyperIndex/Streams/redis.md
@@ -0,0 +1,91 @@
+---
+id: streams-redis
+title: Redis Streams
+sidebar_label: Redis Streams
+slug: /streams/redis
+description: Stream decoded events from HyperIndex to Redis Streams using the Effect API.
+---
+
+Push decoded events into a Redis Stream with `XADD`. Pair with consumer groups on the read side for at-least-once processing.
+
+### Installation
+
+```bash
+pnpm add ioredis
+```
+
+### Configure the client
+
+```typescript title="src/clients/redis.ts"
+import Redis from "ioredis";
+
+export const redis = new Redis(process.env.REDIS_CONNECTION_URI!);
+```
+
+### Define the effect
+
+```typescript title="src/effects/redis.ts"
+import { createEffect, S } from "envio";
+import { redis } from "../clients/redis";
+
+export const xaddRedis = createEffect(
+  {
+    name: "xaddRedis",
+    input: {
+      stream: S.string,
+      payload: S.string, // JSON-encoded
+    },
+    rateLimit: { calls: 500, per: "second" },
+    mode: "unorderedAfterCommit",
+  },
+  async ({ input }) => {
+    await redis.xadd(input.stream, "*", "data", input.payload);
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+streams:
+  redis:
+    streams:
+      - stream_name: "ethereum_rocketpool_transfer_stream"
+        events:
+          - event_name: Transfer
+            conditions:
+              - "value": ">=2000000000000000000 && value <=4000000000000000000"
+              - "from": "0x0338ce5020c447f7e668dc2ef778025ce3982662"
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { xaddRedis } from "./effects/redis";
+
+const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
+const MIN = 2_000_000_000_000_000_000n;
+const MAX = 4_000_000_000_000_000_000n;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+    context.effect(xaddRedis, {
+      stream: "ethereum_rocketpool_transfer_stream",
+      payload: JSON.stringify({
+        from,
+        to,
+        value: value.toString(),
+        txHash: event.transaction.hash,
+        blockNumber: event.block.number,
+      }),
+    });
+  }
+});
+```
+
+Redis Streams already give you total ordering per stream (the `*` ID is monotonically increasing), so `unorderedAfterCommit` is fine here — concurrent `XADD`s within a batch will simply interleave by arrival time. Use `orderedAfterCommit` only if downstream consumers expect strict handler-order across the batch.
diff --git a/docs/HyperIndex/Streams/sns-sqs.md b/docs/HyperIndex/Streams/sns-sqs.md
new file mode 100644
index 00000000..fabc7b16
--- /dev/null
+++ b/docs/HyperIndex/Streams/sns-sqs.md
@@ -0,0 +1,128 @@
+---
+id: streams-sns-sqs
+title: AWS SNS / SQS
+sidebar_label: AWS SNS / SQS
+slug: /streams/sns-sqs
+description: Stream decoded events from HyperIndex to AWS SNS topics or SQS queues using the Effect API.
+---
+
+Publish to an SNS topic (pub/sub fan-out) or directly to an SQS queue. Both use the official AWS SDK.
+
+### Installation
+
+```bash
+# SNS
+pnpm add @aws-sdk/client-sns
+# SQS
+pnpm add @aws-sdk/client-sqs
+```
+
+### Configure the client
+
+```typescript title="src/clients/aws.ts"
+import { SNSClient } from "@aws-sdk/client-sns";
+import { SQSClient } from "@aws-sdk/client-sqs";
+
+const region = process.env.AWS_REGION ?? "us-east-1";
+const credentials = {
+  accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
+  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
+  ...(process.env.AWS_SESSION_TOKEN
+    ? { sessionToken: process.env.AWS_SESSION_TOKEN }
+    : {}),
+};
+
+export const sns = new SNSClient({ region, credentials });
+export const sqs = new SQSClient({ region, credentials });
+```
+
+### Define the effects
+
+```typescript title="src/effects/sns.ts"
+import { PublishCommand } from "@aws-sdk/client-sns";
+import { SendMessageCommand } from "@aws-sdk/client-sqs";
+import { createEffect, S } from "envio";
+import { sns, sqs } from "../clients/aws";
+
+export const publishToSns = createEffect(
+  {
+    name: "publishToSns",
+    input: { topicArn: S.string, message: S.string },
+    rateLimit: { calls: 100, per: "second" },
+    mode: "unorderedAfterCommit",
+  },
+  async ({ input }) => {
+    await sns.send(
+      new PublishCommand({ TopicArn: input.topicArn, Message: input.message })
+    );
+  }
+);
+
+export const sendToSqs = createEffect(
+  {
+    name: "sendToSqs",
+    input: {
+      queueUrl: S.string,
+      body: S.string,
+      groupId: S.optional(S.string), // for FIFO queues
+    },
+    rateLimit: { calls: 100, per: "second" },
+    mode: "unorderedAfterCommit",
+  },
+  async ({ input }) => {
+    await sqs.send(
+      new SendMessageCommand({
+        QueueUrl: input.queueUrl,
+        MessageBody: input.body,
+        MessageGroupId: input.groupId,
+      })
+    );
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer config…
+
+```yaml
+streams:
+  sns:
+    topics:
+      - topic_arn: "arn:aws:sns:us-east-1:664643779377:test"
+        events:
+          - event_name: Transfer
+            conditions:
+              - "value": ">=2000000000000000000 && value <=4000000000000000000"
+              - "from": "0x0338ce5020c447f7e668dc2ef778025ce3982662"
+```
+
+…becomes:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { publishToSns } from "./effects/sns";
+
+const TOPIC = "arn:aws:sns:us-east-1:664643779377:test";
+const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
+const MIN = 2_000_000_000_000_000_000n;
+const MAX = 4_000_000_000_000_000_000n;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+    context.effect(publishToSns, {
+      topicArn: TOPIC,
+      message: JSON.stringify({
+        from,
+        to,
+        value: value.toString(),
+        txHash: event.transaction.hash,
+      }),
+    });
+  }
+});
+```
+
+For SQS FIFO queues, switch the effect to `orderedAfterCommit` and set a `groupId` (e.g. the contract address) — the runtime preserves handler order, and SQS preserves order per `MessageGroupId`.
diff --git a/docs/HyperIndex/Streams/webhooks.md b/docs/HyperIndex/Streams/webhooks.md
new file mode 100644
index 00000000..b2d120a3
--- /dev/null
+++ b/docs/HyperIndex/Streams/webhooks.md
@@ -0,0 +1,94 @@
+---
+id: streams-webhooks
+title: Webhooks
+sidebar_label: Webhooks
+slug: /streams/webhooks
+description: Stream decoded events from HyperIndex to a webhook endpoint using the Effect API.
+---
+
+Send decoded events to any HTTP endpoint when on-chain conditions are met. No extra dependency required — `fetch` is built into Node.
+
+### Installation
+
+Nothing to install. Use the global `fetch`.
+
+### Define the effect
+
+```typescript title="src/effects/webhook.ts"
+import { createEffect, S } from "envio";
+
+export const sendWebhook = createEffect(
+  {
+    name: "sendWebhook",
+    input: {
+      eventName: S.string,
+      payload: S.string, // JSON-encoded body
+    },
+    rateLimit: { calls: 25, per: "second" },
+    mode: "unorderedAfterCommit",
+  },
+  async ({ input, context }) => {
+    const res = await fetch(process.env.WEBHOOK_URL!, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-envio-shared-secret": process.env.WEBHOOK_SHARED_SECRET ?? "",
+      },
+      body: input.payload,
+    });
+    if (!res.ok) {
+      context.log.error(`Webhook failed: ${res.status} ${res.statusText}`);
+      throw new Error(`Webhook ${res.status}`);
+    }
+  }
+);
+```
+
+### Call it from a handler
+
+The rindexer YAML below…
+
+```yaml
+events:
+  - event_name: Transfer
+    conditions:
+      - "value": ">=2000000000000000000 && value <=4000000000000000000"
+      - "from": "0x0338ce5020c447f7e668dc2ef778025ce3982662"
+```
+
+…becomes plain TypeScript:
+
+```typescript title="src/EventHandlers.ts"
+import { RocketPoolETH } from "generated";
+import { sendWebhook } from "./effects/webhook";
+
+const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
+const MIN = 2_000_000_000_000_000_000n;
+const MAX = 4_000_000_000_000_000_000n;
+
+RocketPoolETH.Transfer.handler(async ({ event, context }) => {
+  const { from, to, value } = event.params;
+
+  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+    context.effect(sendWebhook, {
+      eventName: "RocketPoolTransfer",
+      payload: JSON.stringify({
+        network: event.chainId,
+        from,
+        to,
+        value: value.toString(),
+        txHash: event.transaction.hash,
+        blockNumber: event.block.number,
+      }),
+    });
+  }
+});
+```
+
+Because the effect is `unorderedAfterCommit`, the handler returns immediately — the runtime dispatches the webhook in parallel after the batch's DB commit. You only see a delivered request for state that actually persisted.
+
+### Tips
+
+- Switch to `mode: "orderedAfterCommit"` if your downstream consumer requires per-batch ordering.
+- Set `cache: true` on the effect if you also want to skip duplicates across full indexer reruns. By default the effect fires every run.
+- Use the rate-limit option to stay under your endpoint's throughput cap.
diff --git a/sidebarsHyperIndex.js b/sidebarsHyperIndex.js
index a9d8a546..f8298a31 100644
--- a/sidebarsHyperIndex.js
+++ b/sidebarsHyperIndex.js
@@ -79,6 +79,32 @@ module.exports = {
         // "Examples/example-ens",
       ],
     },
+    {
+      type: "category",
+      label: "Streams",
+      link: { type: "doc", id: "Streams/streams" },
+      items: [
+        "Streams/streams-webhooks",
+        "Streams/streams-kafka",
+        "Streams/streams-rabbitmq",
+        "Streams/streams-sns-sqs",
+        "Streams/streams-redis",
+        "Streams/streams-cloudflare-queues",
+      ],
+    },
+    {
+      type: "category",
+      label: "Chat Bots",
+      link: { type: "doc", id: "Chatbots/chatbots" },
+      items: [
+        "Chatbots/chatbots-telegram",
+        "Chatbots/chatbots-discord",
+        "Chatbots/chatbots-slack",
+        "Chatbots/chatbots-twilio",
+        "Chatbots/chatbots-pagerduty",
+        "Chatbots/chatbots-opsgenie",
+      ],
+    },
     {
       type: "category",
       label: "Envio Cloud",

From 9bce1124cad59dc14a20abe88e1514ebd067b190 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 7 May 2026 13:04:55 +0000
Subject: [PATCH 2/4] Use a separate sidebar for HyperIndexV2 without
 Streams/Chat Bots

The Streams and Chat Bots guides only apply to v3.1 (Effect API mode option),
so V2 should not show them. Point HyperIndexV2 at a new sidebar that reuses
the V3 sidebar but strips the V3-only categories.
---
 docusaurus.config.js    |  2 +-
 sidebarsHyperIndexV2.js | 17 +++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 sidebarsHyperIndexV2.js

diff --git a/docusaurus.config.js b/docusaurus.config.js
index a1da3c31..1c6f6f3e 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -621,7 +621,7 @@ This file contains links to documentation sections following the llmstxt.org sta
         id: "HyperIndexV2",
         path: "docs/HyperIndexV2",
         routeBasePath: "docs/v2/HyperIndex",
-        sidebarPath: require.resolve("./sidebarsHyperIndex.js"),
+        sidebarPath: require.resolve("./sidebarsHyperIndexV2.js"),
         editUrl: "https://github.com/enviodev/docs/edit/main/",
         showLastUpdateAuthor: false,
         showLastUpdateTime: false,
diff --git a/sidebarsHyperIndexV2.js b/sidebarsHyperIndexV2.js
new file mode 100644
index 00000000..7cc3b954
--- /dev/null
+++ b/sidebarsHyperIndexV2.js
@@ -0,0 +1,17 @@
+// Sidebar for HyperIndexV2. Reuses the V3 sidebar but strips categories that
+// only exist in V3 (e.g. Streams, Chat Bots).
+const v3Sidebar = require("./sidebarsHyperIndex.js");
+
+const V3_ONLY_LABELS = new Set(["Streams", "Chat Bots"]);
+
+const stripV3Only = (items) =>
+  items.filter((item) => {
+    if (typeof item === "object" && item !== null && item.type === "category") {
+      return !V3_ONLY_LABELS.has(item.label);
+    }
+    return true;
+  });
+
+module.exports = {
+  someSidebar: stripV3Only(v3Sidebar.someSidebar),
+};

From b259987966962f89203821d3ebc64482e258c412 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 7 May 2026 13:31:09 +0000
Subject: [PATCH 3/4] Refactor Streams/Chatbots examples + suggest inline modes
 for low latency
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Examples now follow the Effect API best-practice cheatsheet:

- Bake static config (URLs, tokens, channel IDs, ARNs, queue names) into
  the effect body — input carries only the values that vary per call.
- Build payloads/strings inside the effect; handlers pass raw values.
- Update all examples to the v3 API (indexer.onEvent, context.chain.id,
  src/handlers/<Contract>.ts, src/effects/<tool>.ts).

Also suggest the inline `unordered` / `ordered` modes as lower-latency
alternatives to the after-commit modes when the consumer is idempotent.

Drop the `link:` property from the Streams, Chat Bots, and Supported
Networks categories so they render with the same dropdown component as
Guides/Examples; the overview page is now an "Overview" item under each
category.
---
 docs/HyperIndex/Advanced/effect-api.md       |  71 ++++++----
 docs/HyperIndex/Chatbots/discord.md          |  82 +++++++-----
 docs/HyperIndex/Chatbots/index.md            |  28 ++--
 docs/HyperIndex/Chatbots/opsgenie.md         |  89 +++++++------
 docs/HyperIndex/Chatbots/pagerduty.md        |  80 ++++++-----
 docs/HyperIndex/Chatbots/slack.md            |  72 ++++++----
 docs/HyperIndex/Chatbots/telegram.md         | 132 +++++++++++++------
 docs/HyperIndex/Chatbots/twilio.md           |  52 +++++---
 docs/HyperIndex/Streams/cloudflare-queues.md |  56 ++++----
 docs/HyperIndex/Streams/index.md             |  10 +-
 docs/HyperIndex/Streams/kafka.md             |  61 +++++----
 docs/HyperIndex/Streams/rabbitmq.md          |  58 ++++----
 docs/HyperIndex/Streams/redis.md             |  48 ++++---
 docs/HyperIndex/Streams/sns-sqs.md           |  70 ++++++----
 docs/HyperIndex/Streams/webhooks.md          |  51 ++++---
 sidebarsHyperIndex.js                        |  13 +-
 16 files changed, 587 insertions(+), 386 deletions(-)

diff --git a/docs/HyperIndex/Advanced/effect-api.md b/docs/HyperIndex/Advanced/effect-api.md
index 7e0bb685..d649fad3 100644
--- a/docs/HyperIndex/Advanced/effect-api.md
+++ b/docs/HyperIndex/Advanced/effect-api.md
@@ -65,10 +65,15 @@ After defining an effect, you can use `context.effect` to call it from your hand
 The `context.effect` function accepts an effect as the first argument and the effect's input as the second argument:
 
 ```typescript
-ERC20.Transfer.handler(async ({ event, context }) => {
-  const metadata = await context.effect(getMetadata, event.params.from);
-  // Process the event with the metadata
-});
+import { indexer } from "envio";
+
+indexer.onEvent(
+  { contract: "ERC20", event: "Transfer" },
+  async ({ event, context }) => {
+    const metadata = await context.effect(getMetadata, event.params.from);
+    // Process the event with the metadata
+  },
+);
 ```
 
 ### Reading On-Chain State (eth_call)
@@ -229,7 +234,7 @@ The `mode` option controls **when** the effect runs, **how** it's ordered relati
 The two `*AfterCommit` modes are the right choice for **outbound messaging** — Redis, Kafka, RabbitMQ, SNS/SQS, Telegram, Discord, Slack, webhooks. They fire only after the batch's database transaction commits, so a downstream consumer never sees a message for a state that didn't actually persist. They also return `void`, so you don't need to `await` the call from your handler — the runtime takes care of dispatching after commit.
 
 ```typescript
-import { createEffect, S } from "envio";
+import { createEffect, indexer, S } from "envio";
 
 const notifyLargeSwap = createEffect(
   {
@@ -249,16 +254,19 @@ const notifyLargeSwap = createEffect(
   }
 );
 
-Pool.Swap.handler(async ({ event, context }) => {
-  const usd = event.params.amount;
-  if (usd > 1_000_000n) {
-    context.effect(notifyLargeSwap, {
-      usd,
-      blockNumber: event.block.number,
-    });
-    // no await — orderedAfterCommit returns void; runtime fires it after the batch's DB commit
-  }
-});
+indexer.onEvent(
+  { contract: "Pool", event: "Swap" },
+  async ({ event, context }) => {
+    const usd = event.params.amount;
+    if (usd > 1_000_000n) {
+      context.effect(notifyLargeSwap, {
+        usd,
+        blockNumber: event.block.number,
+      });
+      // no await — orderedAfterCommit returns void; runtime fires it after the batch's DB commit
+    }
+  },
+);
 ```
 
 #### When to pick which mode
@@ -266,10 +274,12 @@ Pool.Swap.handler(async ({ event, context }) => {
 - **`speculative`** — your call is idempotent, the input may not be final (preloading runs handlers ahead of confirmed state), and you only need a value back. RPC `eth_call`s, `fetch` of IPFS metadata, and any read where retries are cheap belong here.
 - **`unordered`** — you've already verified the input (e.g. derived it from a committed entity) and the work is parallel-safe. Use this for batched reads/writes that don't depend on each other.
 - **`ordered`** — the effect's correctness depends on something written earlier in the same batch. The runtime will run these calls sequentially in handler order.
-- **`unorderedAfterCommit`** — fire-and-forget sends where ordering doesn't matter: partitioned Kafka topics, Redis Streams keyed by tx hash, generic webhooks. Highest throughput.
+- **`unorderedAfterCommit`** — fire-and-forget sends where ordering doesn't matter: partitioned Kafka topics, Redis Streams keyed by tx hash, generic webhooks. Highest throughput, never sends for state that wasn't committed.
 - **`orderedAfterCommit`** — sends to a single ordered destination: a Telegram chat, a Slack channel, a single Kafka partition. The runtime preserves handler order across the batch.
 
-This mode is what makes the Effect API a good fit for **streams and chat bots** — you describe what to send and where, the runtime handles batching, ordering, and at-least-once delivery semantics. See the [Streams](/docs/HyperIndex/streams) and [Chat Bots](/docs/HyperIndex/chatbots) guides for end-to-end examples per provider.
+For outbound messaging, `*AfterCommit` is the safe default. If you've measured commit latency as the bottleneck and your downstream consumer is idempotent, you can also use the inline `unordered` / `ordered` modes for **lower latency** sends — same parallel/sequential semantics, but they fire before the DB commit and return a value. The tradeoff is weaker delivery: a failed batch can still produce a delivered message, so retries on the next run are duplicates rather than first-time sends.
+
+This is what makes the Effect API a good fit for **streams and chat bots** — you describe what to send and where, the runtime handles batching, ordering, and delivery semantics. See the [Streams](/docs/HyperIndex/streams) and [Chat Bots](/docs/HyperIndex/chatbots) guides for end-to-end examples per provider.
 
 ### Sending Notifications (Webhooks)
 
@@ -304,17 +314,22 @@ export const sendWebhook = createEffect(
 Then call it from your handler:
 
 ```typescript
-MyContract.LargeTransfer.handler(async ({ event, context }) => {
-  context.effect(sendWebhook, {
-    event: "large_transfer",
-    data: JSON.stringify({
-      from: event.params.from,
-      to: event.params.to,
-      amount: event.params.value.toString(),
-    }),
-  });
-  // no await — `unorderedAfterCommit` returns void and dispatches after the DB commit
-});
+import { indexer } from "envio";
+
+indexer.onEvent(
+  { contract: "MyContract", event: "LargeTransfer" },
+  async ({ event, context }) => {
+    context.effect(sendWebhook, {
+      event: "large_transfer",
+      data: JSON.stringify({
+        from: event.params.from,
+        to: event.params.to,
+        amount: event.params.value.toString(),
+      }),
+    });
+    // no await — `unorderedAfterCommit` returns void and dispatches after the DB commit
+  },
+);
 ```
 
 Because the effect runs **after** the batch's DB commit, the webhook will only fire for state that actually persisted — a reorg or a failed batch never produces a phantom notification. For send-only effects you typically don't need `cache: true`; the mode itself prevents duplicate sends within a successful run.
diff --git a/docs/HyperIndex/Chatbots/discord.md b/docs/HyperIndex/Chatbots/discord.md
index e4232207..9f8a7f56 100644
--- a/docs/HyperIndex/Chatbots/discord.md
+++ b/docs/HyperIndex/Chatbots/discord.md
@@ -16,15 +16,28 @@ Post messages to a Discord channel using either an [incoming webhook](https://su
 
 ### Define the effect
 
+Webhook URL is baked into the effect. The embed is built inside the effect body — `input` is just raw event data.
+
 ```typescript title="src/effects/discord.ts"
 import { createEffect, S } from "envio";
 
-export const sendDiscord = createEffect(
+const formatUnits = (value: bigint, decimals = 18) => {
+  const base = 10n ** BigInt(decimals);
+  const whole = value / base;
+  const frac = value % base;
+  if (frac === 0n) return whole.toString();
+  return `${whole}.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
+
+export const notifyTransfer = createEffect(
   {
-    name: "sendDiscord",
+    name: "notifyTransfer",
     input: {
-      content: S.string,
-      embedsJson: S.optional(S.string), // JSON-encoded embeds array
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      contract: S.string,
+      txHash: S.string,
     },
     rateLimit: { calls: 5, per: "second" }, // Discord webhook limit
     mode: "orderedAfterCommit",
@@ -34,8 +47,18 @@ export const sendDiscord = createEffect(
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        content: input.content,
-        embeds: input.embedsJson ? JSON.parse(input.embedsJson) : undefined,
+        content: "**New RETH Transfer Event**",
+        embeds: [
+          {
+            title: `${formatUnits(input.value)} RETH transferred`,
+            url: `https://etherscan.io/tx/${input.txHash}`,
+            fields: [
+              { name: "From", value: input.from, inline: true },
+              { name: "To", value: input.to, inline: true },
+              { name: "Contract", value: input.contract },
+            ],
+          },
+        ],
         allowed_mentions: { parse: [] },
       }),
     });
@@ -68,31 +91,26 @@ chat:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { sendDiscord } from "./effects/discord";
-import { formatUnits } from "./utils/format";
-
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
-
-  if (value < 10n || value > 2_000_000_000_000_000_000n) return;
-
-  context.effect(sendDiscord, {
-    content: "**New RETH Transfer Event**",
-    embedsJson: JSON.stringify([
-      {
-        title: `${formatUnits(value)} RETH transferred`,
-        url: `https://etherscan.io/tx/${event.transaction.hash}`,
-        fields: [
-          { name: "From", value: from, inline: true },
-          { name: "To", value: to, inline: true },
-          { name: "Contract", value: event.srcAddress },
-        ],
-      },
-    ]),
-  });
-});
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { notifyTransfer } from "../effects/discord";
+
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
+
+    if (value < 10n || value > 2_000_000_000_000_000_000n) return;
+
+    context.effect(notifyTransfer, {
+      from,
+      to,
+      value,
+      contract: event.srcAddress,
+      txHash: event.transaction.hash,
+    });
+  },
+);
 ```
 
-Discord embeds give you richer formatting than plain text — fields, colors, thumbnails — without any extra dependency. If you'd rather keep things simple, just send `content` as a markdown string and skip `embeds`.
+Discord embeds give you richer formatting than plain text — fields, colors, thumbnails — without any extra dependency. If you'd rather keep things simple, replace `embeds` with a markdown `content` string. For lower latency, switch the effect to `mode: "ordered"` (or `"unordered"` if order doesn't matter) — Discord is rate-limited so the gain is small, but it skips the wait for the DB commit.
diff --git a/docs/HyperIndex/Chatbots/index.md b/docs/HyperIndex/Chatbots/index.md
index 4260affc..6ece3d63 100644
--- a/docs/HyperIndex/Chatbots/index.md
+++ b/docs/HyperIndex/Chatbots/index.md
@@ -8,11 +8,18 @@ description: Send on-chain notifications from HyperIndex to Telegram, Discord, S
 
 Chat bots in HyperIndex are just [Effects](/docs/HyperIndex/effect-api) running in `orderedAfterCommit` mode that call a chat platform's API. There is no separate templating language and no separate config file — you build your message string with template literals and decide when to send it with normal `if` statements.
 
-### Why `orderedAfterCommit`?
+### Picking a mode
 
-Chat platforms display messages in arrival order to humans, so you almost always want **ordered** delivery. The runtime preserves the order of `context.effect(...)` calls across the entire batch, then dispatches them sequentially after the DB commit. The `AfterCommit` half guarantees you never message users about a state that was rolled back by a reorg or a failed batch.
+Chat platforms display messages in arrival order to humans, so you almost always want **ordered** delivery. The runtime preserves the order of `context.effect(...)` calls across the entire batch, then dispatches them after the DB commit.
 
-If you don't care about order across events (e.g. one alert per swap, no relation between alerts), you can use `unorderedAfterCommit` for higher throughput.
+| Mode | When to use |
+| --- | --- |
+| `orderedAfterCommit` *(default choice for chat bots)* | Single ordered destination (Telegram chat, Slack channel). Won't message users about state that was rolled back. |
+| `unorderedAfterCommit` | Independent alerts where order doesn't matter (one alert per swap, fan-out to multiple channels). Higher throughput. |
+| `ordered` *(lower latency)* | Need the message out as fast as possible and your operators tolerate the rare duplicate on a failed batch. Inline, sequential, returns a value. |
+| `unordered` *(lower latency)* | Same speed/safety tradeoff as `ordered`, but parallel dispatch. Use when alerts are fully independent. |
+
+Use the after-commit modes by default. Switch to `ordered` / `unordered` only when you measure commit latency as the bottleneck — chat platforms are rate-limited anyway, so the gain is usually small.
 
 ### Comparison with rindexer
 
@@ -32,17 +39,8 @@ If you don't care about order across events (e.g. one alert per swap, no relatio
 - [PagerDuty](/docs/HyperIndex/chatbots/pagerduty)
 - [OpsGenie](/docs/HyperIndex/chatbots/opsgenie)
 
-### Helper: human-readable token amounts
+### Pattern
 
-Most examples below use a small `formatUnits` helper instead of rindexer's `{{format_value(value, 18)}}`:
+Each effect bakes in its own static config (token, channel, rate limit, message template) and accepts only the per-event values that vary in `input`. That keeps call sites tiny, makes deduplication effective, and means switching destinations later is a one-line change.
 
-```typescript title="src/utils/format.ts"
-export const formatUnits = (value: bigint, decimals = 18) => {
-  const base = 10n ** BigInt(decimals);
-  const whole = value / base;
-  const frac = value % base;
-  if (frac === 0n) return whole.toString();
-  const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
-  return `${whole}.${fracStr}`;
-};
-```
+The example pages below all use a small `formatUnits` helper inside the effect body to render bigints — equivalent to rindexer's `{{format_value(value, 18)}}`.
diff --git a/docs/HyperIndex/Chatbots/opsgenie.md b/docs/HyperIndex/Chatbots/opsgenie.md
index 5dab6954..aa7da031 100644
--- a/docs/HyperIndex/Chatbots/opsgenie.md
+++ b/docs/HyperIndex/Chatbots/opsgenie.md
@@ -16,20 +16,29 @@ Create OpsGenie alerts using the [Alert API](https://docs.opsgenie.com/docs/aler
 
 ### Define the effect
 
+API key, priority, and the alert template are baked into the effect. `input` is just the raw event data.
+
 ```typescript title="src/effects/opsgenie.ts"
 import { createEffect, S } from "envio";
 
-type Priority = "P1" | "P2" | "P3" | "P4" | "P5";
+const formatUnits = (value: bigint, decimals = 18) => {
+  const base = 10n ** BigInt(decimals);
+  const whole = value / base;
+  const frac = value % base;
+  if (frac === 0n) return whole.toString();
+  return `${whole}.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
 
-export const createOpsGenieAlert = createEffect(
+export const whaleAlert = createEffect(
   {
-    name: "createOpsGenieAlert",
+    name: "whaleAlert",
     input: {
-      message: S.string,
-      priority: S.string, // Priority
-      alias: S.optional(S.string),
-      description: S.optional(S.string),
-      detailsJson: S.optional(S.string), // JSON-encoded details map
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
+      chainId: S.number,
+      blockNumber: S.number,
     },
     rateLimit: { calls: 100, per: "minute" },
     mode: "orderedAfterCommit",
@@ -42,11 +51,20 @@ export const createOpsGenieAlert = createEffect(
         Authorization: `GenieKey ${process.env.OPSGENIE_API_KEY}`,
       },
       body: JSON.stringify({
-        message: input.message,
-        priority: input.priority as Priority,
-        alias: input.alias,
-        description: input.description,
-        details: input.detailsJson ? JSON.parse(input.detailsJson) : undefined,
+        message: `Whale moved ${formatUnits(input.value)} RETH`,
+        priority: "P1",
+        // alias deduplicates alerts in OpsGenie — keep it stable per logical event.
+        alias: input.txHash,
+        description: [
+          `from: ${input.from}`,
+          `to: ${input.to}`,
+          `amount: ${formatUnits(input.value, 18)}`,
+          `etherscan: https://etherscan.io/tx/${input.txHash}`,
+        ].join("\n"),
+        details: {
+          chainId: input.chainId,
+          block: input.blockNumber,
+        },
         source: "hyperindex",
       }),
     });
@@ -80,33 +98,28 @@ chat:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { createOpsGenieAlert } from "./effects/opsgenie";
-import { formatUnits } from "./utils/format";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { whaleAlert } from "../effects/opsgenie";
 
 const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
-  if (from.toLowerCase() !== WHALE || value < 10n) return;
-
-  context.effect(createOpsGenieAlert, {
-    priority: "P1",
-    message: `Whale moved ${formatUnits(value)} RETH`,
-    alias: event.transaction.hash, // dedup across reruns
-    description: [
-      `from: ${from}`,
-      `to: ${to}`,
-      `amount: ${formatUnits(value, 18)}`,
-      `etherscan: https://etherscan.io/tx/${event.transaction.hash}`,
-    ].join("\n"),
-    detailsJson: JSON.stringify({
-      chainId: event.chainId,
-      block: event.block.number,
-    }),
-  });
-});
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
+    if (from.toLowerCase() !== WHALE || value < 10n) return;
+
+    context.effect(whaleAlert, {
+      from,
+      to,
+      value,
+      txHash: event.transaction.hash,
+      chainId: context.chain.id,
+      blockNumber: event.block.number,
+    });
+  },
+);
 ```
 
-`alias` deduplicates alerts in OpsGenie — keep it stable per logical event (e.g. the tx hash) to avoid duplicate alerts on indexer reruns.
+For time-sensitive alerts, switch the effect to `mode: "ordered"` so the alert is created inline within the batch; the `alias` still protects you from duplicates if the batch later fails.
diff --git a/docs/HyperIndex/Chatbots/pagerduty.md b/docs/HyperIndex/Chatbots/pagerduty.md
index bf559316..0d58e090 100644
--- a/docs/HyperIndex/Chatbots/pagerduty.md
+++ b/docs/HyperIndex/Chatbots/pagerduty.md
@@ -16,20 +16,28 @@ Trigger PagerDuty incidents using the [Events API v2](https://developer.pagerdut
 
 ### Define the effect
 
+Routing key, severity, and the alert template are baked into the effect — `input` is just the raw event data.
+
 ```typescript title="src/effects/pagerduty.ts"
 import { createEffect, S } from "envio";
 
-type Severity = "info" | "warning" | "error" | "critical";
+const formatUnits = (value: bigint, decimals = 18) => {
+  const base = 10n ** BigInt(decimals);
+  const whole = value / base;
+  const frac = value % base;
+  if (frac === 0n) return whole.toString();
+  return `${whole}.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
 
-export const triggerPagerDuty = createEffect(
+export const whaleAlert = createEffect(
   {
-    name: "triggerPagerDuty",
+    name: "whaleAlert",
     input: {
-      severity: S.string, // Severity
-      summary: S.string,
-      source: S.string,
-      dedupKey: S.optional(S.string),
-      detailsJson: S.optional(S.string), // JSON-encoded custom_details
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      contract: S.string,
+      txHash: S.string,
     },
     rateLimit: { calls: 60, per: "minute" },
     mode: "orderedAfterCommit",
@@ -41,14 +49,18 @@ export const triggerPagerDuty = createEffect(
       body: JSON.stringify({
         routing_key: process.env.PAGERDUTY_ROUTING_KEY,
         event_action: "trigger",
-        dedup_key: input.dedupKey,
+        // Stable dedup_key prevents one alert per event from spamming PagerDuty if you re-run.
+        dedup_key: input.txHash,
         payload: {
-          summary: input.summary,
-          source: input.source,
-          severity: input.severity as Severity,
-          custom_details: input.detailsJson
-            ? JSON.parse(input.detailsJson)
-            : undefined,
+          summary: `Whale moved ${formatUnits(input.value)} RETH`,
+          source: input.contract,
+          severity: "critical",
+          custom_details: {
+            from: input.from,
+            to: input.to,
+            value: input.value.toString(),
+            link: `https://etherscan.io/tx/${input.txHash}`,
+          },
         },
       }),
     });
@@ -82,31 +94,27 @@ chat:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { triggerPagerDuty } from "./effects/pagerduty";
-import { formatUnits } from "./utils/format";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { whaleAlert } from "../effects/pagerduty";
 
 const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
-  if (from.toLowerCase() !== WHALE || value < 10n) return;
-
-  context.effect(triggerPagerDuty, {
-    severity: "critical",
-    summary: `Whale moved ${formatUnits(value)} RETH`,
-    source: event.srcAddress,
-    // dedup_key prevents one alert per event from spamming PagerDuty if you re-run
-    dedupKey: event.transaction.hash,
-    detailsJson: JSON.stringify({
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
+    if (from.toLowerCase() !== WHALE || value < 10n) return;
+
+    context.effect(whaleAlert, {
       from,
       to,
-      value: value.toString(),
-      link: `https://etherscan.io/tx/${event.transaction.hash}`,
-    }),
-  });
-});
+      value,
+      contract: event.srcAddress,
+      txHash: event.transaction.hash,
+    });
+  },
+);
 ```
 
-`dedupKey` is the cleanest way to guarantee at-most-one incident per transaction even across reruns.
+The `dedup_key` baked into the effect (the tx hash) guarantees at-most-one incident per transaction even across reruns. For incidents that need to fire ASAP, switch the effect to `mode: "ordered"` so the trigger runs inline within the batch — the dedup key still protects you from duplicates if the batch later fails and re-runs.
diff --git a/docs/HyperIndex/Chatbots/slack.md b/docs/HyperIndex/Chatbots/slack.md
index 67bce9d8..17fc0ba6 100644
--- a/docs/HyperIndex/Chatbots/slack.md
+++ b/docs/HyperIndex/Chatbots/slack.md
@@ -16,27 +16,46 @@ Post to a Slack channel using either an [incoming webhook](https://api.slack.com
 
 ### Define the effect
 
+Webhook URL is baked in. The message string is built inside the effect — `input` is just raw event data.
+
 ```typescript title="src/effects/slack.ts"
 import { createEffect, S } from "envio";
 
-export const sendSlack = createEffect(
+const formatUnits = (value: bigint, decimals = 18) => {
+  const base = 10n ** BigInt(decimals);
+  const whole = value / base;
+  const frac = value % base;
+  if (frac === 0n) return whole.toString();
+  return `${whole}.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
+
+export const notifyTransfer = createEffect(
   {
-    name: "sendSlack",
+    name: "notifyTransfer",
     input: {
-      text: S.string,
-      blocksJson: S.optional(S.string), // JSON-encoded Block Kit array
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      contract: S.string,
+      txHash: S.string,
     },
     rateLimit: { calls: 1, per: "second" }, // Slack: ~1 msg/sec/channel
     mode: "orderedAfterCommit",
   },
   async ({ input, context }) => {
+    const text = [
+      `*New RETH Transfer Event*`,
+      `from: ${input.from}`,
+      `to: ${input.to}`,
+      `amount: ${formatUnits(input.value, 18)}`,
+      `RETH contract: ${input.contract}`,
+      `<https://etherscan.io/tx/${input.txHash}|etherscan>`,
+    ].join("\n");
+
     const res = await fetch(process.env.SLACK_WEBHOOK_URL!, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        text: input.text,
-        blocks: input.blocksJson ? JSON.parse(input.blocksJson) : undefined,
-      }),
+      body: JSON.stringify({ text }),
     });
     if (!res.ok) {
       context.log.error(`Slack failed: ${res.status} ${await res.text()}`);
@@ -69,27 +88,26 @@ chat:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { sendSlack } from "./effects/slack";
-import { formatUnits } from "./utils/format";
-
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { notifyTransfer } from "../effects/slack";
 
-  if (value < 10n || value > 2_000_000_000_000_000_000n) return;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-  const text = [
-    `*New RETH Transfer Event*`,
-    `from: ${from}`,
-    `to: ${to}`,
-    `amount: ${formatUnits(value, 18)}`,
-    `RETH contract: ${event.srcAddress}`,
-    `<https://etherscan.io/tx/${event.transaction.hash}|etherscan>`,
-  ].join("\n");
+    if (value < 10n || value > 2_000_000_000_000_000_000n) return;
 
-  context.effect(sendSlack, { text });
-});
+    context.effect(notifyTransfer, {
+      from,
+      to,
+      value,
+      contract: event.srcAddress,
+      txHash: event.transaction.hash,
+    });
+  },
+);
 ```
 
-For richer layouts (buttons, headers, dividers) build a [Block Kit](https://api.slack.com/block-kit) array and pass it as `blocksJson: JSON.stringify(blocks)`.
+For richer layouts (buttons, headers, dividers) build a [Block Kit](https://api.slack.com/block-kit) array inside the effect body and add it to the request as `blocks`. If you need lower latency, switch the effect to `mode: "ordered"` — the message is posted inline within the batch instead of after the DB commit.
diff --git a/docs/HyperIndex/Chatbots/telegram.md b/docs/HyperIndex/Chatbots/telegram.md
index 8536f779..2158bc53 100644
--- a/docs/HyperIndex/Chatbots/telegram.md
+++ b/docs/HyperIndex/Chatbots/telegram.md
@@ -16,36 +16,61 @@ Send Telegram messages from your handlers via the [Bot API](https://core.telegra
 
 ### Define the effect
 
+Bot token and chat ID are static — bake them in. The handler hands the effect raw values; the message string is built inside the effect body.
+
 ```typescript title="src/effects/telegram.ts"
 import { createEffect, S } from "envio";
 
-export const sendTelegram = createEffect(
+const ENDPOINT = `https://api.telegram.org/bot${process.env.TELEGRAM_BOT_TOKEN}/sendMessage`;
+const CHAT_ID = process.env.TELEGRAM_CHAT_ID!;
+
+export const notifyTransfer = createEffect(
   {
-    name: "sendTelegram",
-    input: { chatId: S.string, text: S.string },
+    name: "notifyTransfer",
+    input: {
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      contract: S.string,
+      txHash: S.string,
+    },
     rateLimit: { calls: 25, per: "second" }, // Telegram limits ~30 msg/sec globally
     mode: "orderedAfterCommit", // human-readable feed → keep order
   },
   async ({ input, context }) => {
-    const res = await fetch(
-      `https://api.telegram.org/bot${process.env.TELEGRAM_BOT_TOKEN}/sendMessage`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          chat_id: input.chatId,
-          text: input.text,
-          parse_mode: "Markdown",
-          disable_web_page_preview: true,
-        }),
-      }
-    );
+    const text = [
+      `*New RETH Transfer Event*`,
+      `from: ${input.from}`,
+      `to: ${input.to}`,
+      `amount: ${formatUnits(input.value, 18)}`,
+      `RETH contract: ${input.contract}`,
+      `[etherscan](https://etherscan.io/tx/${input.txHash})`,
+    ].join("\n");
+
+    const res = await fetch(ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chat_id: CHAT_ID,
+        text,
+        parse_mode: "Markdown",
+        disable_web_page_preview: true,
+      }),
+    });
     if (!res.ok) {
       context.log.error(`Telegram failed: ${res.status} ${await res.text()}`);
       throw new Error(`Telegram ${res.status}`);
     }
   }
 );
+
+const formatUnits = (value: bigint, decimals = 18) => {
+  const base = 10n ** BigInt(decimals);
+  const whole = value / base;
+  const frac = value % base;
+  if (frac === 0n) return whole.toString();
+  return `${whole}.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
 ```
 
 ### Call it from a handler
@@ -71,39 +96,68 @@ chat:
 
 …becomes a regular handler with a template literal:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { sendTelegram } from "./effects/telegram";
-import { formatUnits } from "./utils/format";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { notifyTransfer } from "../effects/telegram";
 
-const CHAT_ID = process.env.TELEGRAM_CHAT_ID!;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+    if (value < 10n || value > 2_000_000_000_000_000_000n) return;
 
-  if (value < 10n || value > 2_000_000_000_000_000_000n) return;
+    context.effect(notifyTransfer, {
+      from,
+      to,
+      value,
+      contract: event.srcAddress,
+      txHash: event.transaction.hash,
+    });
+  },
+);
+```
 
-  const text = [
-    `*New RETH Transfer Event*`,
-    `from: ${from}`,
-    `to: ${to}`,
-    `amount: ${formatUnits(value, 18)}`,
-    `RETH contract: ${event.srcAddress}`,
-    `[etherscan](https://etherscan.io/tx/${event.transaction.hash})`,
-  ].join("\n");
+### Lower latency
 
-  context.effect(sendTelegram, { chatId: CHAT_ID, text });
-});
-```
+If a delay between the on-chain event and the Telegram message is a problem (e.g. you're driving an alerting bot), switch the effect to `mode: "ordered"` — the runtime fires it inline within the batch instead of waiting for the DB commit. The tradeoff: a failed batch may still produce a delivered message, so retries on the next run are duplicates.
 
 ### Multiple chats / multiple alerts
 
-Just add more `if` blocks. There's no fixed schema — different events can route to different `chatId`s, and you can build totally different messages for the same event:
+If you need to route to different chat IDs, define one effect per destination — each bakes in its own chat ID and message template — and pick the right one in the handler. A small factory keeps this DRY:
+
+```typescript title="src/effects/telegram.ts"
+const sendTo = (chatId: string, label: string) =>
+  createEffect(
+    {
+      name: `telegram:${label}`,
+      input: { value: S.bigint },
+      rateLimit: { calls: 25, per: "second" },
+      mode: "orderedAfterCommit",
+    },
+    async ({ input }) => {
+      await fetch(ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          chat_id: chatId,
+          text: `${label}: ${formatUnits(input.value)} RETH`,
+          parse_mode: "Markdown",
+        }),
+      });
+    },
+  );
+
+export const whaleAlert = sendTo(process.env.TELEGRAM_WHALE_CHAT_ID!, "🐋 Whale");
+export const notableAlert = sendTo(process.env.TELEGRAM_NOTABLE_CHAT_ID!, "Heads up");
+```
 
-```typescript
+```typescript title="src/handlers/RocketPoolETH.ts"
 if (value >= 1_000_000_000_000_000_000_000n) {
-  context.effect(sendTelegram, { chatId: WHALE_CHAT, text: `🐋 ${formatUnits(value)}` });
+  context.effect(whaleAlert, { value });
 } else if (value >= 100_000_000_000_000_000_000n) {
-  context.effect(sendTelegram, { chatId: NOTABLE_CHAT, text: `Heads up: ${formatUnits(value)}` });
+  context.effect(notableAlert, { value });
 }
 ```
+
+Keeping each destination in its own effect avoids passing `chatId` through `input` (which would defeat dedup and clutter the call site).
diff --git a/docs/HyperIndex/Chatbots/twilio.md b/docs/HyperIndex/Chatbots/twilio.md
index 2d12b8cd..9b405306 100644
--- a/docs/HyperIndex/Chatbots/twilio.md
+++ b/docs/HyperIndex/Chatbots/twilio.md
@@ -35,22 +35,35 @@ export const twilioClient = twilio(
 
 ### Define the effect
 
+From/to numbers are baked in. The handler hands the effect raw values; the SMS body is built inside.
+
 ```typescript title="src/effects/twilio.ts"
 import { createEffect, S } from "envio";
 import { twilioClient } from "../clients/twilio";
 
-export const sendSms = createEffect(
+const FROM = process.env.TWILIO_FROM_NUMBER!;
+const TO = process.env.TWILIO_TO_NUMBER!;
+
+const formatUnits = (value: bigint, decimals = 18) => {
+  const base = 10n ** BigInt(decimals);
+  const whole = value / base;
+  const frac = value % base;
+  if (frac === 0n) return whole.toString();
+  return `${whole}.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
+
+export const notifyTransfer = createEffect(
   {
-    name: "sendSms",
-    input: { to: S.string, body: S.string },
+    name: "notifyTransfer",
+    input: { value: S.bigint },
     rateLimit: { calls: 1, per: "second" }, // Twilio default trial = 1 msg/sec
     mode: "orderedAfterCommit",
   },
   async ({ input }) => {
     await twilioClient.messages.create({
-      from: process.env.TWILIO_FROM_NUMBER!,
-      to: input.to,
-      body: input.body,
+      from: FROM,
+      to: TO,
+      body: `Transfer detected: ${formatUnits(input.value)} RETH`,
     });
   }
 );
@@ -101,22 +114,19 @@ chat:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { sendSms } from "./effects/twilio";
-import { formatUnits } from "./utils/format";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { notifyTransfer } from "../effects/twilio";
 
-const TO = process.env.TWILIO_TO_NUMBER!;
-
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { value } = event.params;
-  if (value < 10n) return;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { value } = event.params;
+    if (value < 10n) return;
 
-  context.effect(sendSms, {
-    to: TO,
-    body: `Transfer detected: ${formatUnits(value)} RETH`,
-  });
-});
+    context.effect(notifyTransfer, { value });
+  },
+);
 ```
 
-SMS is rate-limited and expensive — keep your conditions strict.
+SMS is rate-limited and expensive — keep your conditions strict. For time-sensitive alerts, switch the effect to `mode: "ordered"` so the SMS is dispatched inline rather than after the DB commit.
diff --git a/docs/HyperIndex/Streams/cloudflare-queues.md b/docs/HyperIndex/Streams/cloudflare-queues.md
index f93cde99..87eced55 100644
--- a/docs/HyperIndex/Streams/cloudflare-queues.md
+++ b/docs/HyperIndex/Streams/cloudflare-queues.md
@@ -14,30 +14,38 @@ Nothing to install.
 
 ### Define the effect
 
+Account ID, API token, and queue ID are static — bake them in. `input` is just event data.
+
 ```typescript title="src/effects/cloudflare.ts"
 import { createEffect, S } from "envio";
 
-const ENDPOINT = (queueId: string) =>
-  `https://api.cloudflare.com/client/v4/accounts/${process.env.CLOUDFLARE_ACCOUNT_ID}/queues/${queueId}/messages`;
+const QUEUE_ID = "blockchain-transfers";
+const ENDPOINT = `https://api.cloudflare.com/client/v4/accounts/${process.env.CLOUDFLARE_ACCOUNT_ID}/queues/${QUEUE_ID}/messages`;
 
-export const sendToCloudflareQueue = createEffect(
+export const sendTransfer = createEffect(
   {
-    name: "sendToCloudflareQueue",
+    name: "sendTransfer",
     input: {
-      queueId: S.string,
-      body: S.string, // JSON-encoded
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
+      chainId: S.number,
     },
     rateLimit: { calls: 100, per: "second" },
     mode: "unorderedAfterCommit",
   },
   async ({ input, context }) => {
-    const res = await fetch(ENDPOINT(input.queueId), {
+    const res = await fetch(ENDPOINT, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${process.env.CLOUDFLARE_API_TOKEN}`,
       },
-      body: JSON.stringify({ body: input.body, content_type: "json" }),
+      body: JSON.stringify({
+        body: { ...input, value: input.value.toString() },
+        content_type: "json",
+      }),
     });
     if (!res.ok) {
       context.log.error(`CF Queues failed: ${res.status} ${await res.text()}`);
@@ -64,28 +72,28 @@ streams:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { sendToCloudflareQueue } from "./effects/cloudflare";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { sendTransfer } from "../effects/cloudflare";
 
 const MIN = 2_000_000_000_000_000_000n;
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-  if (value >= MIN) {
-    context.effect(sendToCloudflareQueue, {
-      queueId: "blockchain-transfers",
-      body: JSON.stringify({
+    if (value >= MIN) {
+      context.effect(sendTransfer, {
         from,
         to,
-        value: value.toString(),
+        value,
         txHash: event.transaction.hash,
-        chainId: event.chainId,
-      }),
-    });
-  }
-});
+        chainId: context.chain.id,
+      });
+    }
+  },
+);
 ```
 
-Use `orderedAfterCommit` if your queue consumer relies on per-batch ordering.
+Use `orderedAfterCommit` if your queue consumer relies on per-batch ordering. For lower latency at the cost of commit-safe delivery, switch to `mode: "unordered"` (or `"ordered"`) — the message is sent inline within the batch.
diff --git a/docs/HyperIndex/Streams/index.md b/docs/HyperIndex/Streams/index.md
index 93e2a502..77887a49 100644
--- a/docs/HyperIndex/Streams/index.md
+++ b/docs/HyperIndex/Streams/index.md
@@ -24,8 +24,14 @@ HyperIndex can publish decoded events to any external system from inside your ha
 
 ### Choosing a mode
 
-- **`unorderedAfterCommit`** — fire-and-forget, parallel dispatch. Best for partitioned destinations (Kafka with a partition key, Redis Streams keyed by tx hash, generic webhooks).
-- **`orderedAfterCommit`** — preserves the order in which `context.effect(...)` was called across the batch. Use for single-stream destinations like a Telegram chat, a Slack channel, or a single Kafka partition.
+Pick by latency vs. delivery semantics:
+
+- **`unorderedAfterCommit`** — fire-and-forget, parallel dispatch, **after** the DB commits. Best for partitioned destinations (Kafka with a partition key, Redis Streams keyed by tx hash, generic webhooks). Highest throughput; messages only fire for state that actually persisted.
+- **`orderedAfterCommit`** — preserves the order in which `context.effect(...)` was called across the batch, dispatched **after** the DB commits. Use for single-stream destinations like a Telegram chat, a Slack channel, or a single Kafka partition.
+- **`unordered`** *(lower latency)* — same as `unorderedAfterCommit` but fires **inline within the batch**, in parallel, returning a value. Skip this if your stream must never see a message for a state that was rolled back; pick it if you need the fastest possible push (no wait for DB commit) and your downstream tolerates duplicates on retry.
+- **`ordered`** *(lower latency)* — same as `orderedAfterCommit` but fires inline, sequentially, returning a value. Useful when a handler needs the response (e.g. a stream-side ID) before continuing, and you're willing to accept that a failed batch may still produce a delivered message.
+
+Rule of thumb: **start with `*AfterCommit`**. Drop down to `unordered` / `ordered` only when you've measured commit latency as the bottleneck and your consumer is idempotent.
 
 ### Supported tools
 
diff --git a/docs/HyperIndex/Streams/kafka.md b/docs/HyperIndex/Streams/kafka.md
index d00a5208..045770ce 100644
--- a/docs/HyperIndex/Streams/kafka.md
+++ b/docs/HyperIndex/Streams/kafka.md
@@ -41,17 +41,25 @@ export const ensureConnected = () => (connected ??= producer.connect());
 
 ### Define the effect
 
+Topic name is baked into the effect — `input` carries only the partition key and the per-event payload. The effect serialises to JSON internally; the handler passes raw values.
+
 ```typescript title="src/effects/kafka.ts"
 import { createEffect, S } from "envio";
 import { ensureConnected, producer } from "../clients/kafka";
 
-export const publishToKafka = createEffect(
+const TOPIC = "rocketpool.transfers";
+
+export const publishTransfer = createEffect(
   {
-    name: "publishToKafka",
+    name: "publishTransfer",
     input: {
-      topic: S.string,
-      key: S.string,
-      value: S.string,
+      key: S.string, // partition key
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
+      blockNumber: S.number,
+      chainId: S.number,
     },
     rateLimit: { calls: 200, per: "second" },
     // unordered = parallel dispatch, partition order preserved by `key`
@@ -59,10 +67,16 @@ export const publishToKafka = createEffect(
   },
   async ({ input }) => {
     await ensureConnected();
+    const { key, value, ...rest } = input;
     await producer.send({
-      topic: input.topic,
+      topic: TOPIC,
       acks: -1, // "all"
-      messages: [{ key: input.key, value: input.value }],
+      messages: [
+        {
+          key,
+          value: JSON.stringify({ ...rest, value: value.toString() }),
+        },
+      ],
     });
   }
 );
@@ -87,31 +101,31 @@ streams:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { publishToKafka } from "./effects/kafka";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { publishTransfer } from "../effects/kafka";
 
 const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
 const MIN = 2_000_000_000_000_000_000n;
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-  if (from.toLowerCase() === WHALE && value >= MIN) {
-    context.effect(publishToKafka, {
-      topic: "rocketpool.transfers",
-      key: from, // partition by sender so per-sender order is preserved
-      value: JSON.stringify({
+    if (from.toLowerCase() === WHALE && value >= MIN) {
+      context.effect(publishTransfer, {
+        key: from, // partition by sender so per-sender order is preserved
         from,
         to,
-        value: value.toString(),
+        value,
         txHash: event.transaction.hash,
         blockNumber: event.block.number,
-        chainId: event.chainId,
-      }),
-    });
-  }
-});
+        chainId: context.chain.id,
+      });
+    }
+  },
+);
 ```
 
 ### Mode picker
@@ -120,6 +134,7 @@ RocketPoolETH.Transfer.handler(async ({ event, context }) => {
 | --- | --- |
 | High throughput, partition by key | `unorderedAfterCommit` |
 | Strict global order across the whole topic | `orderedAfterCommit` (and a single-partition topic) |
+| Lowest latency, idempotent consumer | `unordered` (parallel, inline) or `ordered` (sequential, inline) — fires before the DB commit |
 
 ### Raw `fetch` alternative
 
diff --git a/docs/HyperIndex/Streams/rabbitmq.md b/docs/HyperIndex/Streams/rabbitmq.md
index 0e84d7bf..c8fd3e29 100644
--- a/docs/HyperIndex/Streams/rabbitmq.md
+++ b/docs/HyperIndex/Streams/rabbitmq.md
@@ -33,29 +33,34 @@ export const getChannel = () =>
 
 ### Define the effect
 
+Exchange and routing key are static config — bake them in. `input` is just the per-event values.
+
 ```typescript title="src/effects/rabbitmq.ts"
 import { createEffect, S } from "envio";
 import { getChannel } from "../clients/rabbitmq";
 
-export const publishToRabbit = createEffect(
+const EXCHANGE = "transfer";
+const ROUTING_KEY = "my-routing-key";
+
+export const publishTransfer = createEffect(
   {
-    name: "publishToRabbit",
+    name: "publishTransfer",
     input: {
-      exchange: S.string,
-      routingKey: S.string,
-      body: S.string,
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
     },
     rateLimit: { calls: 200, per: "second" },
     mode: "unorderedAfterCommit",
   },
   async ({ input }) => {
     const ch = await getChannel();
-    ch.publish(
-      input.exchange,
-      input.routingKey,
-      Buffer.from(input.body),
-      { contentType: "application/json", persistent: true }
-    );
+    const body = JSON.stringify({ ...input, value: input.value.toString() });
+    ch.publish(EXCHANGE, ROUTING_KEY, Buffer.from(body), {
+      contentType: "application/json",
+      persistent: true,
+    });
   }
 );
 ```
@@ -80,30 +85,29 @@ streams:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { publishToRabbit } from "./effects/rabbitmq";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { publishTransfer } from "../effects/rabbitmq";
 
 const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
 const MIN = 2_000_000_000_000_000_000n;
 const MAX = 4_000_000_000_000_000_000n;
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
-    context.effect(publishToRabbit, {
-      exchange: "transfer",
-      routingKey: "my-routing-key",
-      body: JSON.stringify({
+    if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+      context.effect(publishTransfer, {
         from,
         to,
-        value: value.toString(),
+        value,
         txHash: event.transaction.hash,
-      }),
-    });
-  }
-});
+      });
+    }
+  },
+);
 ```
 
-Pick `orderedAfterCommit` if your consumer needs strict per-batch ordering. For `fanout` exchanges, leave `routingKey` as an empty string.
+Pick `orderedAfterCommit` if your consumer needs strict per-batch ordering. For `fanout` exchanges, leave `routingKey` as an empty string. If your consumer is idempotent and you want lower latency, switch the effect to `mode: "unordered"` (or `"ordered"`) to publish inline before the DB commit.
diff --git a/docs/HyperIndex/Streams/redis.md b/docs/HyperIndex/Streams/redis.md
index 319c4f6f..6737532c 100644
--- a/docs/HyperIndex/Streams/redis.md
+++ b/docs/HyperIndex/Streams/redis.md
@@ -24,22 +24,30 @@ export const redis = new Redis(process.env.REDIS_CONNECTION_URI!);
 
 ### Define the effect
 
+Stream name is static — bake it in. `input` is just event data.
+
 ```typescript title="src/effects/redis.ts"
 import { createEffect, S } from "envio";
 import { redis } from "../clients/redis";
 
-export const xaddRedis = createEffect(
+const STREAM = "ethereum_rocketpool_transfer_stream";
+
+export const xaddTransfer = createEffect(
   {
-    name: "xaddRedis",
+    name: "xaddTransfer",
     input: {
-      stream: S.string,
-      payload: S.string, // JSON-encoded
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
+      blockNumber: S.number,
     },
     rateLimit: { calls: 500, per: "second" },
     mode: "unorderedAfterCommit",
   },
   async ({ input }) => {
-    await redis.xadd(input.stream, "*", "data", input.payload);
+    const data = JSON.stringify({ ...input, value: input.value.toString() });
+    await redis.xadd(STREAM, "*", "data", data);
   }
 );
 ```
@@ -62,30 +70,30 @@ streams:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { xaddRedis } from "./effects/redis";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { xaddTransfer } from "../effects/redis";
 
 const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
 const MIN = 2_000_000_000_000_000_000n;
 const MAX = 4_000_000_000_000_000_000n;
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
-    context.effect(xaddRedis, {
-      stream: "ethereum_rocketpool_transfer_stream",
-      payload: JSON.stringify({
+    if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+      context.effect(xaddTransfer, {
         from,
         to,
-        value: value.toString(),
+        value,
         txHash: event.transaction.hash,
         blockNumber: event.block.number,
-      }),
-    });
-  }
-});
+      });
+    }
+  },
+);
 ```
 
-Redis Streams already give you total ordering per stream (the `*` ID is monotonically increasing), so `unorderedAfterCommit` is fine here — concurrent `XADD`s within a batch will simply interleave by arrival time. Use `orderedAfterCommit` only if downstream consumers expect strict handler-order across the batch.
+Redis Streams already give you total ordering per stream (the `*` ID is monotonically increasing), so `unorderedAfterCommit` is fine here — concurrent `XADD`s within a batch will simply interleave by arrival time. Use `orderedAfterCommit` only if downstream consumers expect strict handler-order across the batch. For lowest latency, switch to `mode: "unordered"` so the `XADD` runs inline within the batch — fastest, but a failed batch can leave entries in the stream that no longer reflect committed state.
diff --git a/docs/HyperIndex/Streams/sns-sqs.md b/docs/HyperIndex/Streams/sns-sqs.md
index fabc7b16..c53a0ecb 100644
--- a/docs/HyperIndex/Streams/sns-sqs.md
+++ b/docs/HyperIndex/Streams/sns-sqs.md
@@ -38,43 +38,60 @@ export const sqs = new SQSClient({ region, credentials });
 
 ### Define the effects
 
+Topic ARN / queue URL are static — bake them in. `input` carries only event data.
+
 ```typescript title="src/effects/sns.ts"
 import { PublishCommand } from "@aws-sdk/client-sns";
 import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import { createEffect, S } from "envio";
 import { sns, sqs } from "../clients/aws";
 
-export const publishToSns = createEffect(
+const TOPIC_ARN = process.env.SNS_TOPIC_ARN!;
+
+export const publishTransferSns = createEffect(
   {
-    name: "publishToSns",
-    input: { topicArn: S.string, message: S.string },
+    name: "publishTransferSns",
+    input: {
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
+    },
     rateLimit: { calls: 100, per: "second" },
     mode: "unorderedAfterCommit",
   },
   async ({ input }) => {
     await sns.send(
-      new PublishCommand({ TopicArn: input.topicArn, Message: input.message })
+      new PublishCommand({
+        TopicArn: TOPIC_ARN,
+        Message: JSON.stringify({ ...input, value: input.value.toString() }),
+      })
     );
   }
 );
 
-export const sendToSqs = createEffect(
+const QUEUE_URL = process.env.SQS_QUEUE_URL!;
+
+export const publishTransferSqs = createEffect(
   {
-    name: "sendToSqs",
+    name: "publishTransferSqs",
     input: {
-      queueUrl: S.string,
-      body: S.string,
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
       groupId: S.optional(S.string), // for FIFO queues
     },
     rateLimit: { calls: 100, per: "second" },
     mode: "unorderedAfterCommit",
   },
   async ({ input }) => {
+    const { groupId, value, ...rest } = input;
     await sqs.send(
       new SendMessageCommand({
-        QueueUrl: input.queueUrl,
-        MessageBody: input.body,
-        MessageGroupId: input.groupId,
+        QueueUrl: QUEUE_URL,
+        MessageBody: JSON.stringify({ ...rest, value: value.toString() }),
+        MessageGroupId: groupId,
       })
     );
   }
@@ -99,30 +116,29 @@ streams:
 
 …becomes:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { publishToSns } from "./effects/sns";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { publishTransferSns } from "../effects/sns";
 
-const TOPIC = "arn:aws:sns:us-east-1:664643779377:test";
 const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
 const MIN = 2_000_000_000_000_000_000n;
 const MAX = 4_000_000_000_000_000_000n;
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
-    context.effect(publishToSns, {
-      topicArn: TOPIC,
-      message: JSON.stringify({
+    if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+      context.effect(publishTransferSns, {
         from,
         to,
-        value: value.toString(),
+        value,
         txHash: event.transaction.hash,
-      }),
-    });
-  }
-});
+      });
+    }
+  },
+);
 ```
 
-For SQS FIFO queues, switch the effect to `orderedAfterCommit` and set a `groupId` (e.g. the contract address) — the runtime preserves handler order, and SQS preserves order per `MessageGroupId`.
+For SQS FIFO queues, switch the effect to `orderedAfterCommit` and set a `groupId` (e.g. the contract address) — the runtime preserves handler order, and SQS preserves order per `MessageGroupId`. If your consumer is idempotent and you want the message out before the DB commit, use `mode: "unordered"` or `"ordered"` for lower latency.
diff --git a/docs/HyperIndex/Streams/webhooks.md b/docs/HyperIndex/Streams/webhooks.md
index b2d120a3..198da259 100644
--- a/docs/HyperIndex/Streams/webhooks.md
+++ b/docs/HyperIndex/Streams/webhooks.md
@@ -14,15 +14,21 @@ Nothing to install. Use the global `fetch`.
 
 ### Define the effect
 
+URL, shared secret, and the `eventName` constant are baked into the effect body — only the values that vary per call go in `input`.
+
 ```typescript title="src/effects/webhook.ts"
 import { createEffect, S } from "envio";
 
-export const sendWebhook = createEffect(
+export const notifyTransfer = createEffect(
   {
-    name: "sendWebhook",
+    name: "notifyTransfer",
     input: {
-      eventName: S.string,
-      payload: S.string, // JSON-encoded body
+      from: S.string,
+      to: S.string,
+      value: S.bigint,
+      txHash: S.string,
+      blockNumber: S.number,
+      chainId: S.number,
     },
     rateLimit: { calls: 25, per: "second" },
     mode: "unorderedAfterCommit",
@@ -34,7 +40,11 @@ export const sendWebhook = createEffect(
         "Content-Type": "application/json",
         "x-envio-shared-secret": process.env.WEBHOOK_SHARED_SECRET ?? "",
       },
-      body: input.payload,
+      body: JSON.stringify({
+        event: "RocketPoolTransfer",
+        ...input,
+        value: input.value.toString(),
+      }),
     });
     if (!res.ok) {
       context.log.error(`Webhook failed: ${res.status} ${res.statusText}`);
@@ -58,31 +68,31 @@ events:
 
 …becomes plain TypeScript:
 
-```typescript title="src/EventHandlers.ts"
-import { RocketPoolETH } from "generated";
-import { sendWebhook } from "./effects/webhook";
+```typescript title="src/handlers/RocketPoolETH.ts"
+import { indexer } from "envio";
+import { notifyTransfer } from "../effects/webhook";
 
 const WHALE = "0x0338ce5020c447f7e668dc2ef778025ce3982662";
 const MIN = 2_000_000_000_000_000_000n;
 const MAX = 4_000_000_000_000_000_000n;
 
-RocketPoolETH.Transfer.handler(async ({ event, context }) => {
-  const { from, to, value } = event.params;
+indexer.onEvent(
+  { contract: "RocketPoolETH", event: "Transfer" },
+  async ({ event, context }) => {
+    const { from, to, value } = event.params;
 
-  if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
-    context.effect(sendWebhook, {
-      eventName: "RocketPoolTransfer",
-      payload: JSON.stringify({
-        network: event.chainId,
+    if (from.toLowerCase() === WHALE && value >= MIN && value <= MAX) {
+      context.effect(notifyTransfer, {
         from,
         to,
-        value: value.toString(),
+        value,
         txHash: event.transaction.hash,
         blockNumber: event.block.number,
-      }),
-    });
-  }
-});
+        chainId: context.chain.id,
+      });
+    }
+  },
+);
 ```
 
 Because the effect is `unorderedAfterCommit`, the handler returns immediately — the runtime dispatches the webhook in parallel after the batch's DB commit. You only see a delivered request for state that actually persisted.
@@ -90,5 +100,6 @@ Because the effect is `unorderedAfterCommit`, the handler returns immediately 
 ### Tips
 
 - Switch to `mode: "orderedAfterCommit"` if your downstream consumer requires per-batch ordering.
+- Need lower latency than `*AfterCommit`? Use `mode: "unordered"` (or `"ordered"`) to fire inline within the batch — same parallel/sequential semantics, but the call returns a value and runs before the DB commit. Trades commit-safe delivery for speed; pick it only if your endpoint is idempotent.
 - Set `cache: true` on the effect if you also want to skip duplicates across full indexer reruns. By default the effect fires every run.
 - Use the rate-limit option to stay under your endpoint's throughput cap.
diff --git a/sidebarsHyperIndex.js b/sidebarsHyperIndex.js
index f8298a31..b58fbaa7 100644
--- a/sidebarsHyperIndex.js
+++ b/sidebarsHyperIndex.js
@@ -28,11 +28,10 @@ if (process.env.DOCS_FOR_LLM === "true") {
 const networksSection = {
   type: "category",
   label: "Supported Networks",
-  link: {
-    type: "doc",
-    id: "supported-networks/index",
-  },
-  items: filteredNetworks,
+  items: [
+    { type: "doc", id: "supported-networks/index", label: "Overview" },
+    ...filteredNetworks,
+  ],
 };
 
 module.exports = {
@@ -82,8 +81,8 @@ module.exports = {
     {
       type: "category",
       label: "Streams",
-      link: { type: "doc", id: "Streams/streams" },
       items: [
+        { type: "doc", id: "Streams/streams", label: "Overview" },
         "Streams/streams-webhooks",
         "Streams/streams-kafka",
         "Streams/streams-rabbitmq",
@@ -95,8 +94,8 @@ module.exports = {
     {
       type: "category",
       label: "Chat Bots",
-      link: { type: "doc", id: "Chatbots/chatbots" },
       items: [
+        { type: "doc", id: "Chatbots/chatbots", label: "Overview" },
         "Chatbots/chatbots-telegram",
         "Chatbots/chatbots-discord",
         "Chatbots/chatbots-slack",

From e467f3d867a4df8e0156ba40620019b3257f1836 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 7 May 2026 14:36:47 +0000
Subject: [PATCH 4/4] Prefix all stream/chatbot env vars with ENVIO_

---
 docs/HyperIndex/Advanced/effect-api.md       |  4 +--
 docs/HyperIndex/Chatbots/discord.md          |  4 +--
 docs/HyperIndex/Chatbots/opsgenie.md         |  6 ++---
 docs/HyperIndex/Chatbots/pagerduty.md        |  6 ++---
 docs/HyperIndex/Chatbots/slack.md            |  4 +--
 docs/HyperIndex/Chatbots/telegram.md         | 12 ++++-----
 docs/HyperIndex/Chatbots/twilio.md           | 28 ++++++++++----------
 docs/HyperIndex/Streams/cloudflare-queues.md |  4 +--
 docs/HyperIndex/Streams/kafka.md             |  6 ++---
 docs/HyperIndex/Streams/rabbitmq.md          |  2 +-
 docs/HyperIndex/Streams/redis.md             |  2 +-
 docs/HyperIndex/Streams/sns-sqs.md           | 14 +++++-----
 docs/HyperIndex/Streams/webhooks.md          |  4 +--
 13 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/docs/HyperIndex/Advanced/effect-api.md b/docs/HyperIndex/Advanced/effect-api.md
index d649fad3..8f68a440 100644
--- a/docs/HyperIndex/Advanced/effect-api.md
+++ b/docs/HyperIndex/Advanced/effect-api.md
@@ -244,10 +244,10 @@ const notifyLargeSwap = createEffect(
   },
   async ({ input }) => {
     const text = `Large swap: $${input.usd.toLocaleString()} in block ${input.blockNumber}`;
-    await fetch(`https://api.telegram.org/bot${process.env.TG_BOT_TOKEN}/sendMessage`, {
+    await fetch(`https://api.telegram.org/bot${process.env.ENVIO_TG_BOT_TOKEN}/sendMessage`, {
       method: "POST",
       body: JSON.stringify({
-        chat_id: process.env.TG_CHAT_ID,
+        chat_id: process.env.ENVIO_TG_CHAT_ID,
         text,
       }),
     });
diff --git a/docs/HyperIndex/Chatbots/discord.md b/docs/HyperIndex/Chatbots/discord.md
index 9f8a7f56..576320c5 100644
--- a/docs/HyperIndex/Chatbots/discord.md
+++ b/docs/HyperIndex/Chatbots/discord.md
@@ -12,7 +12,7 @@ Post messages to a Discord channel using either an [incoming webhook](https://su
 
 1. Channel **Settings → Integrations → Webhooks → New Webhook**.
 2. Copy the webhook URL.
-3. Set `DISCORD_WEBHOOK_URL` in your `.env`.
+3. Set `ENVIO_DISCORD_WEBHOOK_URL` in your `.env`.
 
 ### Define the effect
 
@@ -43,7 +43,7 @@ export const notifyTransfer = createEffect(
     mode: "orderedAfterCommit",
   },
   async ({ input, context }) => {
-    const res = await fetch(process.env.DISCORD_WEBHOOK_URL!, {
+    const res = await fetch(process.env.ENVIO_DISCORD_WEBHOOK_URL!, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
diff --git a/docs/HyperIndex/Chatbots/opsgenie.md b/docs/HyperIndex/Chatbots/opsgenie.md
index aa7da031..5d4c4af3 100644
--- a/docs/HyperIndex/Chatbots/opsgenie.md
+++ b/docs/HyperIndex/Chatbots/opsgenie.md
@@ -11,7 +11,7 @@ Create OpsGenie alerts using the [Alert API](https://docs.opsgenie.com/docs/aler
 ### Integration setup
 
 1. OpsGenie → **Settings → Integrations → API**, then copy the API key.
-2. Set `OPSGENIE_API_KEY` in your `.env`.
+2. Set `ENVIO_OPSGENIE_API_KEY` in your `.env`.
 3. Use `https://api.opsgenie.com` (US) or `https://api.eu.opsgenie.com` (EU) as the host.
 
 ### Define the effect
@@ -48,7 +48,7 @@ export const whaleAlert = createEffect(
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `GenieKey ${process.env.OPSGENIE_API_KEY}`,
+        Authorization: `GenieKey ${process.env.ENVIO_OPSGENIE_API_KEY}`,
       },
       body: JSON.stringify({
         message: `Whale moved ${formatUnits(input.value)} RETH`,
@@ -83,7 +83,7 @@ The rindexer config…
 ```yaml
 chat:
   opsgenie:
-    - api_key: ${OPSGENIE_API_KEY}
+    - api_key: ${ENVIO_OPSGENIE_API_KEY}
       priority: P1
       messages:
         - event_name: Transfer
diff --git a/docs/HyperIndex/Chatbots/pagerduty.md b/docs/HyperIndex/Chatbots/pagerduty.md
index 0d58e090..fc795837 100644
--- a/docs/HyperIndex/Chatbots/pagerduty.md
+++ b/docs/HyperIndex/Chatbots/pagerduty.md
@@ -12,7 +12,7 @@ Trigger PagerDuty incidents using the [Events API v2](https://developer.pagerdut
 
 1. PagerDuty → **Services → Service Directory → your service → Integrations → Add → Events API v2**.
 2. Copy the **Integration Key** (a.k.a. routing key).
-3. Set `PAGERDUTY_ROUTING_KEY` in your `.env`.
+3. Set `ENVIO_PAGERDUTY_ROUTING_KEY` in your `.env`.
 
 ### Define the effect
 
@@ -47,7 +47,7 @@ export const whaleAlert = createEffect(
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        routing_key: process.env.PAGERDUTY_ROUTING_KEY,
+        routing_key: process.env.ENVIO_PAGERDUTY_ROUTING_KEY,
         event_action: "trigger",
         // Stable dedup_key prevents one alert per event from spamming PagerDuty if you re-run.
         dedup_key: input.txHash,
@@ -79,7 +79,7 @@ The rindexer config…
 ```yaml
 chat:
   pagerduty:
-    - routing_key: ${PAGERDUTY_ROUTING_KEY}
+    - routing_key: ${ENVIO_PAGERDUTY_ROUTING_KEY}
       severity: critical
       messages:
         - event_name: Transfer
diff --git a/docs/HyperIndex/Chatbots/slack.md b/docs/HyperIndex/Chatbots/slack.md
index 17fc0ba6..45367874 100644
--- a/docs/HyperIndex/Chatbots/slack.md
+++ b/docs/HyperIndex/Chatbots/slack.md
@@ -12,7 +12,7 @@ Post to a Slack channel using either an [incoming webhook](https://api.slack.com
 
 1. Create a Slack app and enable **Incoming Webhooks**.
 2. Add a new webhook for the target channel and copy the URL.
-3. Set `SLACK_WEBHOOK_URL` in your `.env`.
+3. Set `ENVIO_SLACK_WEBHOOK_URL` in your `.env`.
 
 ### Define the effect
 
@@ -52,7 +52,7 @@ export const notifyTransfer = createEffect(
       `<https://etherscan.io/tx/${input.txHash}|etherscan>`,
     ].join("\n");
 
-    const res = await fetch(process.env.SLACK_WEBHOOK_URL!, {
+    const res = await fetch(process.env.ENVIO_SLACK_WEBHOOK_URL!, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ text }),
diff --git a/docs/HyperIndex/Chatbots/telegram.md b/docs/HyperIndex/Chatbots/telegram.md
index 2158bc53..8d1c9268 100644
--- a/docs/HyperIndex/Chatbots/telegram.md
+++ b/docs/HyperIndex/Chatbots/telegram.md
@@ -12,7 +12,7 @@ Send Telegram messages from your handlers via the [Bot API](https://core.telegra
 
 1. Open [@BotFather](https://t.me/BotFather) in Telegram, run `/newbot`, and copy the bot token.
 2. Add the bot to a chat (or DM it) and grab the chat ID. The simplest way is to send any message and visit `https://api.telegram.org/bot<token>/getUpdates` — `chat.id` is in the JSON.
-3. Set `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID` in your `.env`.
+3. Set `ENVIO_TELEGRAM_BOT_TOKEN` and `ENVIO_TELEGRAM_CHAT_ID` in your `.env`.
 
 ### Define the effect
 
@@ -21,8 +21,8 @@ Bot token and chat ID are static — bake them in. The handler hands the effect
 ```typescript title="src/effects/telegram.ts"
 import { createEffect, S } from "envio";
 
-const ENDPOINT = `https://api.telegram.org/bot${process.env.TELEGRAM_BOT_TOKEN}/sendMessage`;
-const CHAT_ID = process.env.TELEGRAM_CHAT_ID!;
+const ENDPOINT = `https://api.telegram.org/bot${process.env.ENVIO_TELEGRAM_BOT_TOKEN}/sendMessage`;
+const CHAT_ID = process.env.ENVIO_TELEGRAM_CHAT_ID!;
 
 export const notifyTransfer = createEffect(
   {
@@ -80,7 +80,7 @@ The rindexer config…
 ```yaml
 chat:
   telegram:
-    - bot_token: ${TELEGRAM_BOT_TOKEN}
+    - bot_token: ${ENVIO_TELEGRAM_BOT_TOKEN}
       chat_id: -4223616270
       messages:
         - event_name: Transfer
@@ -148,8 +148,8 @@ const sendTo = (chatId: string, label: string) =>
     },
   );
 
-export const whaleAlert = sendTo(process.env.TELEGRAM_WHALE_CHAT_ID!, "🐋 Whale");
-export const notableAlert = sendTo(process.env.TELEGRAM_NOTABLE_CHAT_ID!, "Heads up");
+export const whaleAlert = sendTo(process.env.ENVIO_TELEGRAM_WHALE_CHAT_ID!, "🐋 Whale");
+export const notableAlert = sendTo(process.env.ENVIO_TELEGRAM_NOTABLE_CHAT_ID!, "Heads up");
 ```
 
 ```typescript title="src/handlers/RocketPoolETH.ts"
diff --git a/docs/HyperIndex/Chatbots/twilio.md b/docs/HyperIndex/Chatbots/twilio.md
index 9b405306..9ffe6ded 100644
--- a/docs/HyperIndex/Chatbots/twilio.md
+++ b/docs/HyperIndex/Chatbots/twilio.md
@@ -12,9 +12,9 @@ Send SMS messages via [Twilio's Programmable Messaging API](https://www.twilio.c
 
 From the Twilio Console grab:
 
-- `TWILIO_ACCOUNT_SID`
-- `TWILIO_AUTH_TOKEN`
-- `TWILIO_FROM_NUMBER` (in E.164 format, e.g. `+15551234567`)
+- `ENVIO_TWILIO_ACCOUNT_SID`
+- `ENVIO_TWILIO_AUTH_TOKEN`
+- `ENVIO_TWILIO_FROM_NUMBER` (in E.164 format, e.g. `+15551234567`)
 
 ### Installation (SDK)
 
@@ -28,8 +28,8 @@ pnpm add twilio
 import twilio from "twilio";
 
 export const twilioClient = twilio(
-  process.env.TWILIO_ACCOUNT_SID!,
-  process.env.TWILIO_AUTH_TOKEN!
+  process.env.ENVIO_TWILIO_ACCOUNT_SID!,
+  process.env.ENVIO_TWILIO_AUTH_TOKEN!
 );
 ```
 
@@ -41,8 +41,8 @@ From/to numbers are baked in. The handler hands the effect raw values; the SMS b
 import { createEffect, S } from "envio";
 import { twilioClient } from "../clients/twilio";
 
-const FROM = process.env.TWILIO_FROM_NUMBER!;
-const TO = process.env.TWILIO_TO_NUMBER!;
+const FROM = process.env.ENVIO_TWILIO_FROM_NUMBER!;
+const TO = process.env.ENVIO_TWILIO_TO_NUMBER!;
 
 const formatUnits = (value: bigint, decimals = 18) => {
   const base = 10n ** BigInt(decimals);
@@ -75,11 +75,11 @@ If you'd rather skip the SDK:
 
 ```typescript
 const auth = Buffer.from(
-  `${process.env.TWILIO_ACCOUNT_SID}:${process.env.TWILIO_AUTH_TOKEN}`
+  `${process.env.ENVIO_TWILIO_ACCOUNT_SID}:${process.env.ENVIO_TWILIO_AUTH_TOKEN}`
 ).toString("base64");
 
 await fetch(
-  `https://api.twilio.com/2010-04-01/Accounts/${process.env.TWILIO_ACCOUNT_SID}/Messages.json`,
+  `https://api.twilio.com/2010-04-01/Accounts/${process.env.ENVIO_TWILIO_ACCOUNT_SID}/Messages.json`,
   {
     method: "POST",
     headers: {
@@ -87,7 +87,7 @@ await fetch(
       "Content-Type": "application/x-www-form-urlencoded",
     },
     body: new URLSearchParams({
-      From: process.env.TWILIO_FROM_NUMBER!,
+      From: process.env.ENVIO_TWILIO_FROM_NUMBER!,
       To: input.to,
       Body: input.body,
     }),
@@ -102,10 +102,10 @@ The rindexer config…
 ```yaml
 chat:
   twilio:
-    - account_sid: ${TWILIO_ACCOUNT_SID}
-      auth_token: ${TWILIO_AUTH_TOKEN}
-      from_number: ${TWILIO_FROM_NUMBER}
-      to_number: ${TWILIO_TO_NUMBER}
+    - account_sid: ${ENVIO_TWILIO_ACCOUNT_SID}
+      auth_token: ${ENVIO_TWILIO_AUTH_TOKEN}
+      from_number: ${ENVIO_TWILIO_FROM_NUMBER}
+      to_number: ${ENVIO_TWILIO_TO_NUMBER}
       messages:
         - event_name: Transfer
           filter_expression: "value >= 10"
diff --git a/docs/HyperIndex/Streams/cloudflare-queues.md b/docs/HyperIndex/Streams/cloudflare-queues.md
index 87eced55..95679148 100644
--- a/docs/HyperIndex/Streams/cloudflare-queues.md
+++ b/docs/HyperIndex/Streams/cloudflare-queues.md
@@ -20,7 +20,7 @@ Account ID, API token, and queue ID are static — bake them in. `input` is just
 import { createEffect, S } from "envio";
 
 const QUEUE_ID = "blockchain-transfers";
-const ENDPOINT = `https://api.cloudflare.com/client/v4/accounts/${process.env.CLOUDFLARE_ACCOUNT_ID}/queues/${QUEUE_ID}/messages`;
+const ENDPOINT = `https://api.cloudflare.com/client/v4/accounts/${process.env.ENVIO_CLOUDFLARE_ACCOUNT_ID}/queues/${QUEUE_ID}/messages`;
 
 export const sendTransfer = createEffect(
   {
@@ -40,7 +40,7 @@ export const sendTransfer = createEffect(
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${process.env.CLOUDFLARE_API_TOKEN}`,
+        Authorization: `Bearer ${process.env.ENVIO_CLOUDFLARE_API_TOKEN}`,
       },
       body: JSON.stringify({
         body: { ...input, value: input.value.toString() },
diff --git a/docs/HyperIndex/Streams/kafka.md b/docs/HyperIndex/Streams/kafka.md
index 045770ce..fc29485f 100644
--- a/docs/HyperIndex/Streams/kafka.md
+++ b/docs/HyperIndex/Streams/kafka.md
@@ -21,12 +21,12 @@ import { Kafka, Partitioners } from "kafkajs";
 
 export const kafka = new Kafka({
   clientId: "envio-indexer",
-  brokers: (process.env.KAFKA_BROKERS ?? "").split(","),
+  brokers: (process.env.ENVIO_KAFKA_BROKERS ?? "").split(","),
   ssl: true,
   sasl: {
     mechanism: "plain",
-    username: process.env.KAFKA_USERNAME!,
-    password: process.env.KAFKA_PASSWORD!,
+    username: process.env.ENVIO_KAFKA_USERNAME!,
+    password: process.env.ENVIO_KAFKA_PASSWORD!,
   },
 });
 
diff --git a/docs/HyperIndex/Streams/rabbitmq.md b/docs/HyperIndex/Streams/rabbitmq.md
index c8fd3e29..ec6d35c6 100644
--- a/docs/HyperIndex/Streams/rabbitmq.md
+++ b/docs/HyperIndex/Streams/rabbitmq.md
@@ -24,7 +24,7 @@ let chanPromise: Promise<amqp.Channel> | undefined;
 
 export const getChannel = () =>
   (chanPromise ??= (async () => {
-    const conn = await amqp.connect(process.env.RABBITMQ_URL!);
+    const conn = await amqp.connect(process.env.ENVIO_RABBITMQ_URL!);
     const ch = await conn.createChannel();
     await ch.assertExchange("transfer", "direct", { durable: true });
     return ch;
diff --git a/docs/HyperIndex/Streams/redis.md b/docs/HyperIndex/Streams/redis.md
index 6737532c..2e65c426 100644
--- a/docs/HyperIndex/Streams/redis.md
+++ b/docs/HyperIndex/Streams/redis.md
@@ -19,7 +19,7 @@ pnpm add ioredis
 ```typescript title="src/clients/redis.ts"
 import Redis from "ioredis";
 
-export const redis = new Redis(process.env.REDIS_CONNECTION_URI!);
+export const redis = new Redis(process.env.ENVIO_REDIS_CONNECTION_URI!);
 ```
 
 ### Define the effect
diff --git a/docs/HyperIndex/Streams/sns-sqs.md b/docs/HyperIndex/Streams/sns-sqs.md
index c53a0ecb..8437ce3e 100644
--- a/docs/HyperIndex/Streams/sns-sqs.md
+++ b/docs/HyperIndex/Streams/sns-sqs.md
@@ -23,12 +23,12 @@ pnpm add @aws-sdk/client-sqs
 import { SNSClient } from "@aws-sdk/client-sns";
 import { SQSClient } from "@aws-sdk/client-sqs";
 
-const region = process.env.AWS_REGION ?? "us-east-1";
+const region = process.env.ENVIO_AWS_REGION ?? "us-east-1";
 const credentials = {
-  accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-  ...(process.env.AWS_SESSION_TOKEN
-    ? { sessionToken: process.env.AWS_SESSION_TOKEN }
+  accessKeyId: process.env.ENVIO_AWS_ACCESS_KEY_ID!,
+  secretAccessKey: process.env.ENVIO_AWS_SECRET_ACCESS_KEY!,
+  ...(process.env.ENVIO_AWS_SESSION_TOKEN
+    ? { sessionToken: process.env.ENVIO_AWS_SESSION_TOKEN }
     : {}),
 };
 
@@ -46,7 +46,7 @@ import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import { createEffect, S } from "envio";
 import { sns, sqs } from "../clients/aws";
 
-const TOPIC_ARN = process.env.SNS_TOPIC_ARN!;
+const TOPIC_ARN = process.env.ENVIO_SNS_TOPIC_ARN!;
 
 export const publishTransferSns = createEffect(
   {
@@ -70,7 +70,7 @@ export const publishTransferSns = createEffect(
   }
 );
 
-const QUEUE_URL = process.env.SQS_QUEUE_URL!;
+const QUEUE_URL = process.env.ENVIO_SQS_QUEUE_URL!;
 
 export const publishTransferSqs = createEffect(
   {
diff --git a/docs/HyperIndex/Streams/webhooks.md b/docs/HyperIndex/Streams/webhooks.md
index 198da259..cb6e3ba3 100644
--- a/docs/HyperIndex/Streams/webhooks.md
+++ b/docs/HyperIndex/Streams/webhooks.md
@@ -34,11 +34,11 @@ export const notifyTransfer = createEffect(
     mode: "unorderedAfterCommit",
   },
   async ({ input, context }) => {
-    const res = await fetch(process.env.WEBHOOK_URL!, {
+    const res = await fetch(process.env.ENVIO_WEBHOOK_URL!, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "x-envio-shared-secret": process.env.WEBHOOK_SHARED_SECRET ?? "",
+        "x-envio-shared-secret": process.env.ENVIO_WEBHOOK_SHARED_SECRET ?? "",
       },
       body: JSON.stringify({
         event: "RocketPoolTransfer",